expressionish 0.1.0 → 0.1.2

package/dist/expressionish.d.ts

@@ -0,0 +1,798 @@
+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";
+    /** 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
+     * @throws {import("./errors.ts").ExpressionArgumentsError} If an argument or the arguments list is invalid
+    */
+    export type ArgsCheck = (
+    /** meta data passed to the evaluate() call */
+    data: EvaluateData, 
+    /** Arguments passed to the variable */
+    ...args: unknown[]) => undefined | Promise<never>;
+    /** Function to call just prior to evaluating a variable or looked up variable */
+    export type PreEval = (
+    /** Options passed to the `<root>.evaluate()` function */
+    data: EvaluateData, 
+    /** variable or lookup name */
+    variable: Variable) => undefined | Promise<never>;
+    /** 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;
+        /** 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: 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 */
+    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 LogicOperatorFnc = (data: EvaluateData, ...args: unknown[]) => boolean | Promise<boolean>;
+    /** 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>;
+    /** 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 */
+        expression: string;
+        /** A map of Lookup handlers available to be accessed by the expression*/
+        lookups: LookupMap;
+        /** A map of variable handlers available to be accessed by the expression */
+        variables: VariableMap;
+        /** A map of additional condition logical operators */
+        logicalOperators?: LogicOperatorMap;
+        /** A map of additional condition comparison operators */
+        comparisonOperators?: ComparisonOperatorMap;
+    }
+    /** Options when evaluating a tokenized expression */
+    export interface EvaluateOptions extends TokenizeOptions {
+        /** When true the parser will only validate syntax, variable existence and lookup existence */
+        onlyValidate?: boolean;
+        /** Function to be called just prior to evaluating any variable or lookup */
+        preeval?: PreEval;
+        /** Data to be passed into variable and/or lookup evaluators */
+        data?: EvaluateData;
+    }
+}
+declare module "tojson-types" {
+    /** Base that all other Token JSON inherit from */
+    export interface BaseTokenJSON {
+        /** Token's position withing the expression text */
+        position: number;
+        /** Token Type */
+        type: string;
+        /** Value of the token */
+        value?: unknown;
+    }
+    /** Represents a Text Token */
+    export interface TextTokenJSON extends BaseTokenJSON {
+        /** The text of the token */
+        value: string;
+    }
+    /** Represets a Sequence Token */
+    export interface SequenceTokenJSON extends BaseTokenJSON {
+        /** The tokens making up the sequence */
+        value: Array<LookupTokenJSON | IfTokenJSON | VariableTokenJSON | TextTokenJSON | SequenceTokenJSON>;
+    }
+    /** Represents an Argument Token */
+    export interface ArgumentsTokenJSON<T = GroupedTokensJSON> extends BaseTokenJSON {
+        /** Arguments of the token */
+        value: Array<T>;
+    }
+    /** Represents a Lookup Token */
+    export interface LookupTokenJSON extends BaseTokenJSON {
+        /** The prefix of the variable */
+        prefix: string;
+        /** The variable to be looked up */
+        value: string;
+        /** Arguments to be passed to the looked up variable during evaluation */
+        arguments?: ArgumentsTokenJSON;
+    }
+    /** Represents a Comparison Token */
+    export interface ComparisonTokenJSON extends BaseTokenJSON {
+        /** The comparison operator */
+        value: string;
+        /** The left-hand side of the comparison */
+        left: GroupedTokensJSON;
+        /** The right-hand side of the comparison */
+        right?: GroupedTokensJSON;
+    }
+    /** Represents a Logic Token */
+    export interface LogicTokenJSON extends BaseTokenJSON {
+        /** The logic operator */
+        value: string;
+        /** Arguments to be passed to the logic operator's handler */
+        arguments: ArgumentsTokenJSON<LogicTokenJSON | ComparisonTokenJSON | GroupedTokensJSON>;
+    }
+    /** Represents an If Token */
+    export interface IfTokenJSON extends BaseTokenJSON {
+        /** The condition */
+        value: ComparisonTokenJSON | LogicTokenJSON;
+        /** Value to return when the condition is truthy */
+        whenTrue: GroupedTokensJSON;
+        /** 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;
+    export type RootTokenJSON = SequenceTokenJSON | LookupTokenJSON | IfTokenJSON | VariableTokenJSON | TextTokenJSON;
+}
+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 { LogicOperatorMap } from "types";
+    /** Built-in Logic Operators Map */
+    const _default: LogicOperatorMap;
+    export default _default;
+}
+declare module "parse/logic/token" {
+    import type { EvaluateOptions } from "types";
+    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>;
+    }
+}
+declare module "parse/variable/token" {
+    import type { EvaluateOptions } from "types";
+    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>;
+    }
+}
+declare module "parse/sequence-token" {
+    import type { EvaluateOptions } from "types";
+    import type { LookupTokenJSON, IfTokenJSON, VariableTokenJSON, TextTokenJSON, SequenceTokenJSON } from "tojson-types";
+    import type { default as TextToken } from "parse/text/token";
+    import type { default as LookupToken } from "parse/lookup/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;
+    }
+    /** Represents a sequence of tokens from the expression */
+    export default class SequenceToken extends BaseToken {
+        value: Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
+        constructor(options: SequenceTokenOptions);
+        /** 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>;
+    }
+}
+declare module "parse/arguments/token" {
+    import type { EvaluateOptions } from "types";
+    import type { ArgumentsTokenJSON } from "tojson-types";
+    import type ComparisonToken from "parse/comparison/token";
+    import type IfToken from "parse/if/token";
+    import type LogicToken from "parse/logic/token";
+    import type LookupToken from "parse/lookup/token";
+    import type TextToken from "parse/text/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[]>;
+    }
+}
+declare module "errors" {
+    /** Represents a generic error when attempting to parse an expression */
+    export class ExpressionError extends Error {
+        /** When defined: where the error was encountered within the expression text */
+        position?: number;
+        constructor(
+        /** Message to associate with the error */
+        message: string, 
+        /** Where the error was encountered within the expression text */
+        position?: number);
+        static get name(): string;
+    }
+    /** Represents an error related to the arguments list or a singular argument to be passed to a variable */
+    export class ExpressionArgumentsError extends ExpressionError {
+        /** The index of the argument in the arguments list */
+        index?: number;
+        /** The variable name the arguments list belongs to */
+        varname?: string;
+        constructor(
+        /** Message to associate with the error */
+        message: string, 
+        /** Where the error was encountered within the expression text */
+        position?: number, 
+        /** The index of the argument in the arguments list */
+        index?: number, 
+        /** The variable name the arguments list belongs to */
+        varname?: string);
+        static get name(): string;
+    }
+    /** Represents an error related to parsing a variable */
+    export class ExpressionVariableError extends ExpressionError {
+        /** The associated variable name */
+        varname?: string;
+        constructor(
+        /** Message to associate with the error */
+        message: string, 
+        /** Where the error was encountered within the expression text */
+        position?: number, 
+        /** The variable name to associate with the error */
+        varname?: string);
+        static get name(): string;
+    }
+    /** Represents a syntax error within the given expression */
+    export class ExpressionSyntaxError extends ExpressionError {
+        /** The character associated with the error */
+        character?: string;
+        constructor(
+        /** Message to associate with the error */
+        message: string, 
+        /** Where the error was encountered within the expression text */
+        position?: number, 
+        /** The character associated with the error */
+        character?: string);
+        static get name(): string;
+    }
+}
+declare module "parse/lookup/token" {
+    import type { EvaluateOptions } from "types";
+    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 { ComparisonOperatorMap } from "types";
+    /** Built-in Comparison Operators Map */
+    const _default_1: ComparisonOperatorMap;
+    export default _default_1;
+}
+declare module "parse/comparison/token" {
+    import type { EvaluateOptions } from "types";
+    import type { ComparisonTokenJSON } from "tojson-types";
+    import type { default as TextToken } from "parse/text/token";
+    import type { default as LookupToken } from "parse/lookup/token";
+    import type { default as IfToken } from "parse/if/token";
+    import type { default as VariableToken } from "parse/variable/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>;
+    }
+}
+declare module "parse/if/token" {
+    import type { EvaluateOptions } from "types";
+    import type { IfTokenJSON } from "tojson-types";
+    import type ComparisonToken from "parse/comparison/token";
+    import type LogicToken from "parse/logic/token";
+    import type LookupToken from "parse/lookup/token";
+    import type VariableToken from "parse/variable/token";
+    import type SequenceToken from "parse/sequence-token";
+    import type TextToken from "parse/text/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>;
+    }
+}
+declare module "misc/split" {
+    import { type GenericToken } from "types";
+    /** Splits the input into an array of unicode-aware characters
+     * @returns {string[]} An array containing the delimited characters where each entry is a character
+    */
+    export const split: (
+    /** Input text to split into characters */
+    input: string) => string[];
+    /** Converts the input into a list of Generic tokens for further processing
+     * * Unicode multi-byte/character glyphs are treated as a singular entry
+     * * Each whitespace character is treated as a singular entry
+     * * `\` is treated as a singular entry, the following character is also treated as a singular entry regardless of what it is
+     * * \`\` is treated as a singular entry
+     * * All other ascii punctionation is treated as a singular entry
+     * * Non-unicode characters that are not whitespace or punctuation are grouped together and treated as a singular entry
+    */
+    export const tokenize: (input: string) => GenericToken[];
+}
+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;
+        /** 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";
+    /** 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";
+    /** 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";
+    /** 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";
+    /** 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";
+    /** 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";
+    /** 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";
+    /** 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" {
+    import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
+    import IfToken from "parse/if/token";
+    import LookupToken from "parse/lookup/token";
+    import SequenceToken from "parse/sequence-token";
+    import TextToken from "parse/text/token";
+    import VariableToken from "parse/variable/token";
+    /** 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";
+    /** 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";
+    /** 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" {
+    import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
+    import type IfToken from "parse/if/token";
+    import type LookupToken from "parse/lookup/token";
+    import type VariableToken from "parse/variable/token";
+    import SequenceToken from "parse/sequence-token";
+    import TextToken from "parse/text/token";
+    /** 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";
+    /** 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, 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 SequenceToken } from "parse/sequence-token";
+    export { default as TextToken, TextTokenOptions } from "parse/text/token";
+    export { default as VariableToken, VariableTokenOptions } from "parse/variable/token";
+    export { ExpressionError, ExpressionArgumentsError, ExpressionSyntaxError, ExpressionVariableError } from "errors";
+    /** Parses a string expression into a usable Expressionish-Token instance */
+    export const tokenize: (
+    /** Options to use during tokenization */
+    options: TokenizeOptions) => RootToken;
+    /** Parses then evaluates expression text */
+    export const evaluate: (
+    /** Options passed to the parser and evaluator */
+    options: EvaluateOptions) => Promise<unknown>;
+}

package/dist/expressionish.mjs

@@ -0,0 +1,8 @@
+var Q=55296,pe=56319,ue=56320,H=127462,X=127487,le=127995,fe=127999,me=65024,ke=65039,Te=8400,he=8447,de=8205,ce=new Set([776,2359,2367,2984,3007,3021,3633,3635,3648,3657,4352,4449,4520]),A=(t,e,n)=>t>=e&&t<=n,Z=t=>{let e=t.charCodeAt(0)-Q,n=t.charCodeAt(1)-ue;return(e<<10)+n+65536};var Y=t=>{if(typeof t!="string")throw new Error("string cannot be undefined or null");let e=/^[\x01-\x2F\x3A-\x40\x5B-\x60\x7B-\x7E]$/,n=[],o=0,a=0,i=null,r=!1;for(;o<t.length;){let u=o+a,p=t[u];if(u<t.length-1&&p&&A(p.charCodeAt(0),Q,pe)){let s=Z(p+t[u+1]),l=Z(t.substring(u+2,u+5));A(s,H,X)&&A(l,H,X)||A(l,le,fe)?a+=4:a+=2}else a+=1;if(ce.has((t[o+a]+"").charCodeAt(0))&&(a+=1),A((t[o+a]+"").charCodeAt(0),me,ke)&&(a+=1),A((t[o+a]+"").charCodeAt(0),Te,he)&&(a+=1),(t[o+a]+"").charCodeAt(0)===de){a+=1;continue}a>1?(i!=null&&(n.push(i),i=null),n.push({position:o,value:t.substring(o,o+a)}),r=!1):t.substring(o,o+2)==="``"?(i!=null&&(n.push(i),i=null),r?(n.push({position:o,value:"`"}),r=!1):(n.push({position:o,value:"``"}),a+=1)):t[o]==="\\"?(i!=null&&(n.push(i),i=null),n.push({position:o,value:"\\"}),r=!r):e.test(t[o])?(i!=null&&(n.push(i),i=null),n.push({position:o,value:t[o]}),r=!1):r?(n.push({position:o,value:t[o]}),r=!1):i==null?i={position:o,value:t[o]}:i.value+=t[o],o+=a,a=0}return i!=null&&n.push(i),n};var T=class{position;type;value;constructor(e){this.position=e.position,this.type=e.type||"UNKNOWN",this.value=e.value}toJSON(){return{position:this.position,type:this.type,value:this.value}}async evaluate(e){if(!e.onlyValidate)return this.value}};var v=class extends T{value;constructor(e){super({...e,type:"LIST"}),this.value=[]}add(e){e.type!=="TEXT"||!this.value.length||this.value[this.value.length-1].type!=="TEXT"?this.value.push(e):this.value[this.value.length-1].value+=e.value}get unwrap(){return this.value.length===1?this.value[0]:this}toJSON(){let e=this.unwrap;return e!==this?e.toJSON():{position:this.position,type:this.type,value:this.value.map(n=>n.toJSON())}}async evaluate(e){if(!(this.value==null||this.value.length===0))return this.value.length===1?this.value[0].evaluate(e||{}):(await Promise.all(this.value.map(n=>n.evaluate(e||{})))).reduce((n,o)=>n==null?o:o==null?n:n+o)}};var R=class extends v{lookups;variables;logicOperators;comparisonOperators;expression;constructor(e){super({position:0}),this.type="ROOT",this.lookups=e.lookups,this.variables=e.variables,this.logicOperators=e.logicalOperators||new Map,this.comparisonOperators=e.comparisonOperators||new Map,this.expression=e.expression}toJSON(){return super.toJSON()}async evaluate(e={}){return super.evaluate({...e,lookups:this.lookups,variables:this.variables,logicalOperators:this.logicOperators,comparisonOperators:this.comparisonOperators,expression:this.expression})}};var d=class extends T{value;constructor(e){super({...e,type:"TEXT"}),this.value=e.value||""}toJSON(){return{position:this.position,type:this.type,value:this.value}}};var I=class extends Error{position;constructor(e,n){super(e),Error.captureStackTrace(this,this.constructor),this.name="ExpressionError",this.message=e,this.position=n}static get name(){return"ExpressionError"}},c=class extends I{index;varname;constructor(e,n,o,a){super(e,n),Error.captureStackTrace(this,this.constructor),this.name="ExpressionArgumentsError",this.index=o||-1,this.varname=a}static get name(){return"ExpressionArgumentsError"}},b=class extends I{varname;constructor(e,n,o){super(e,n),Error.captureStackTrace(this,this.constructor),this.name="ExpressionVariableError",this.varname=o}static get name(){return"ExpressionVariableError"}},m=class extends I{character;constructor(e,n,o){super(e,n),Error.captureStackTrace(this,this.constructor),this.name="ExpressionSyntaxError",this.character=o}static get name(){return"ExpressionSyntaxError"}};var N=class extends T{prefix;value;arguments;constructor(e){super({...e,type:"LOOKUP"}),this.value=e.value,this.prefix=e.prefix,this.arguments=e.arguments}toJSON(){return{position:this.position,type:this.type,prefix:this.prefix,value:this.value,arguments:this.arguments?this.arguments.toJSON():void 0}}async evaluate(e){if(!e.lookups)throw new b("lookup map invalid",this.position,this.value);let n=e.lookups.get(this.prefix);if(n==null)throw new b("unknown lookup prefix",this.position,this.prefix);let o=await n(e.data||{},this.value);if(o==null)return;e.preeval&&await e.preeval(e.data||{},o),o.preeval&&await o.preeval(e.data||{},o);let a=[];if(this.arguments&&(a=await this.arguments.evaluate(e)),!e.onlyValidate)return o.argsCheck&&await o.argsCheck(e.data||{},...a),o.evaluate(e.data||{},...a)}};var E=class extends T{value;constructor(e){super({...e,type:"ARGUMENTS_LIST"}),this.value=e.value||[]}toJSON(){return{position:this.position,type:this.type,value:this.value.map(e=>e.toJSON())}}async evaluate(e){return Promise.all(this.value.map(n=>n.evaluate(e)))}};var z=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!="\\")return[!1];if(n==null&&(n='"$[,]\\rnt`'),n.includes("`")&&t[e+1].value==="`"&&t[e+2].value==="`")return[!0,e+3,{position:e,value:"``"}];if(!n.includes(t[e+1].value))return[!0,e+1,{position:e,value:"\\"}];e+=1;let a={...t[e]};switch(a.value){case"n":a.value=`
+`;break;case"r":a.value="\r";break;case"t":a.value="	";break}return[!0,e+1,a]};var $=(t,e)=>{let n=t.length;if(e>=n||t[e]==null||t[e].value!=='"')return[!1];let o=e;e+=1;let a="";for(;e<n;){if(t[e].value==='"')return[!0,e+1,new d({position:o,value:a})];let[i,r,u]=z(t,e,'\\"nrt');if(i){e=r,a+=u.value;continue}a+=t[e].value,e+=1}throw new m("End quote missing",t[o].position)};var V=class extends T{value;whenTrue;whenFalse;constructor(e){super({position:e.position,type:"IF"}),this.value=e.value,this.whenTrue=e.whenTrue,this.whenFalse=e.whenFalse}toJSON(){return{position:this.position,type:this.type,value:this.value.toJSON(),whenTrue:this.whenTrue.toJSON(),whenFalse:this.whenFalse?this.whenFalse.toJSON():void 0}}async evaluate(e){let n=await this.value.evaluate(e);if(e.onlyValidate)await this.whenTrue.evaluate(e),this.whenFalse&&await this.whenFalse.evaluate(e);else if(n)return this.whenTrue.evaluate(e);if(this.whenFalse)return this.whenFalse.evaluate(e)}};var F=(t,e,n)=>{if(e===""||n==="")return[e,n];let o=Number(e);if(!Number.isFinite(o))return[e,n];let a=Number(n);return Number.isFinite(a)?[o,a]:[e,n]},ee=(t,e,n)=>([e,n]=F(t,e,n),e===n),te=(t,e)=>e!=null&&e!==!1&&e!==0&&e!=="",q=new Map([["istruthy",{right:"never",evaluate:te}],["!istruthy",{right:"never",evaluate:(t,e)=>!te(t,e)}],["===",{right:"required",evaluate:ee}],["!==",{right:"required",evaluate:(t,e,n)=>!ee(t,e,n)}],["<",{right:"required",evaluate:(t,e,n)=>([e,n]=F(t,e,n),typeof e!="number"||typeof n!="number"?!1:e<n)}],["<=",{right:"required",evaluate:(t,e,n)=>([e,n]=F(t,e,n),typeof e!="number"||typeof n!="number"?!1:e<=n)}],[">",{right:"required",evaluate:(t,e,n)=>([e,n]=F(t,e,n),typeof e!="number"||typeof n!="number"?!1:e>n)}],[">=",{right:"required",evaluate:(t,e,n)=>([e,n]=F(t,e,n),typeof e!="number"||typeof n!="number"?!1:e>=n)}]]);var J=class extends T{value;left;right;constructor(e){super({...e,type:"COMPARISON"}),this.value=e.value,this.left=e.left,this.right=e.right}toJSON(){return{position:this.position,type:this.type,value:this.value,left:this.left.toJSON(),right:this.right?this.right.toJSON():void 0}}async evaluate(e){(!this.value||this.value==="")&&(this.value="istruthy");let n=q.get(this.value);if(n==null)return!1;let o=await this.left.evaluate(e),a;if(this.right&&(a=await this.right.evaluate(e)),!e.onlyValidate)return n.evaluate(e.data||{},o,a)}};var M=class extends T{value;arguments;constructor(e){super({...e,type:"VARIABLE"}),this.value=e.value||"",this.arguments=e.arguments}toJSON(){return{position:this.position,type:this.type,value:this.value,arguments:this.arguments?this.arguments.toJSON():void 0}}async evaluate(e){if(!e.variables||!e.variables.has(this.value))throw new Error("unknown variable");let n=e.variables.get(this.value);e.preeval&&await e.preeval(e.data||{},n),n.preeval&&await n.preeval(e.data||{},n);let o=[];if(this.arguments&&(o=await this.arguments.evaluate(e)),n.argsCheck&&await n.argsCheck(e.data||{},...o),!e.onlyValidate)return n.evaluate(e.data||{},...o)}};var S=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!=="$")return[!1];let a=e;e+=1;let i=t[e].value;if(!/^[a-z][a-z\d]*/i.test(i))return[!1];if(!n.variables.has(i))throw new b("unknown variable",t[e].position,i);e+=1;let[r,u,p]=B(t,e,n);return r&&(e=u),[!0,e,new M({position:a,value:i,arguments:p})]};var x=((t,e)=>{let n=t.length;if(e>=n)return[!1];let o="",a=e;for(;a<n&&(t[a].value===" "||t[a].value===`
+`||t[a].value==="\r"||t[a].value==="	"||t[a].value==="\b"||t[a].value==="\f");)o+=t[a].value,a+=1;return e===a?[!1]:[!0,a,o]});var ve=(t,e,n)=>{let o=t.length;if(e>=o||t[e].value===","||t[e].value==="]"||/^\s/.test(t[e].value))return[!1];let a="";if(t[e].value==="!"&&(a="!",e+=1,e>=o||t[e].value===","||t[e].value==="]"||/^\s/.test(t[e].value)))return[!1];let i=n.comparisonOperators;if(/^[a-z]+$/i.test(t[e].value))a+=t[e].value.toLowerCase(),e+=1;else{let p=a,s=e;for(;s<o&&/^[\x21-\x2F\x3A-\x40\x5E-\x60]$/.test(t[s].value);)p+=t[s].value,s+=1,i.has(p)&&(a=p,e=s)}if(e>=o||!i.has(a)||t[e].value!==","&&t[e].value!=="]"&&!/^\s+$/.test(t[e].value))return[!1];let[r,u]=x(t,e);return r&&(e=u),[!0,e,a]},W=(t,e,n)=>{let o=t.length;if(e>=o||t[e].value===","||t[e].value==="]")return[!1];let a=new Map(q);n.comparisonOperators&&n.comparisonOperators.forEach((h,k)=>{a.set(k,h)});let i={...n,comparisonOperators:a},r=t[e].position,u=()=>{let[h,k,f]=x(t,e);return h?(e=k,f):""},p=new v({position:r}),s,l;for(;e<o;){let h=e,k=u();if(e>=o||t[e].value===","||t[e].value==="]")break;if(p.value.length>0&&s==null&&k!==""){let[ie,re,se]=ve(t,e,i);if(ie){if(p.value.length===0)throw new m("left operand not specified",r);e=re,s=se,l=new v({position:e});continue}}let f=l||p;k!==""&&f.add(new d({position:h,value:k}));let[g,_,K]=z(t,e,'"$,\\`]');g&&(f.add(new d({position:h,value:K.value})),e=_);let[w,O,y]=$(t,e);if(w){f.add(y),e=O;continue}if([w,O,y]=L(t,e,n),w){f.add(y),e=O;continue}if([w,O,y]=C(t,e,n),w){f.add(y),e=O;continue}if([w,O,y]=S(t,e,n),w){f.add(y),e=O;continue}f.add(new d(t[e])),e+=1}if(!p.value.length)return[!1];if(s=s||"istruthy",q.get(s)?.right==="never"&&l!=null&&(!(l instanceof v)||l.value.length!==0))throw new c(`comparison operator ${s} must not have a right-hand-side value`);if(q.get(s)?.right==="required"&&(l==null||l instanceof v&&l.value.length===0))throw new c(`comparison operator ${s} requires a right-hand-side value`);return[!0,e,new J({position:r,value:s,left:p.unwrap,right:l?l.unwrap:void 0})]};var U=(t,e)=>e==null||e===!1||e===0||e==="",G=new Map([["not",{minArgumentsCount:1,maxArgumentsCount:1,evaluate:U}],["and",{minArgumentsCount:1,evaluate:(t,...e)=>e==null||!e.length?!1:!e.some(n=>U(t,n))}],["or",{minArgumentsCount:1,evaluate:(t,...e)=>e==null||!e.length?!1:e.some(n=>!U(t,n))}]]);var D=class extends T{value;arguments;constructor(e){super({...e,type:"LOGIC"}),this.value=e.value,this.arguments=e.arguments}toJSON(){return{position:this.position,type:this.type,value:this.value,arguments:this.arguments.toJSON()}}async evaluate(e){let n;if(e.logicalOperators?.has(this.value))n=e.logicalOperators.get(this.value);else if(G.has(this.value))n=G.get(this.value);else return!1;let o=await this.arguments.evaluate(e);if(n.argsCheck&&n.argsCheck(e.data||{},...o),!e.onlyValidate)return n.evaluate(e.data||{},...o)}};var ne=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!=="$")return[!1];let a=t[e].position;e+=1;let i=new Map(G);n.logicalOperators&&n.logicalOperators.forEach((l,h)=>{i.set(h,l)});let r;if(i.has(t[e].value)){if(r=t[e].value,e+=1,e>=o)return[!1]}else return[!1];if(t[e].value!=="[")throw new m("Logic Operators require atleast one argument",t[e].position);let u=t[e].position;e+=1;let p=l=>{let[h,k,f]=x(t,e);if(h&&(e=k),l&&e>=o)throw new m("unexpected end of expression");return f};p(!0);let s=[];for(;e<o&&(p(),!(e>=o));){let[l,h,k]=ne(t,e,n);if(l||([l,h,k]=W(t,e,n)),!l)throw new c("conditional expected",t[e].position,s.length);if(s.push(k),e=h,t[e].value===","){e+=1;continue}if(t[e].value==="]"){let f=G.get(r);if(f.minArgumentsCount!=null&&s.length<f.minArgumentsCount)throw new c(`$${r} expects atleast ${f.minArgumentsCount} argument(s)`);if(f.maxArgumentsCount!=null&&s.length>f.maxArgumentsCount)throw new c(`$${r} expects at most ${f.maxArgumentsCount} argument(s)`);return[!0,e+1,new D({position:a,value:r,arguments:new E({position:u,value:s})})]}throw new m("unexpected token",t[e].position)}throw new m("unexpected end of expression",o)},oe=ne;var C=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!=="$"||t[e+1].value!=="if")return[!1];let a=t[e].position;if(e+=2,e>=o)throw new c("$if requires atleast 2 arguments",a,0,"if");if(t[e].value!=="[")throw new c("$if requires atleast 2 arguments",t[e].position,0,"if");e+=1;let i=K=>{let[w,O,y]=x(t,e);if(w&&(e=O),K&&e>=o)throw new m("unexpected end of expression");return y};i(!0);let[r,u,p]=oe(t,e,n);if(!r&&([r,u,p]=W(t,e,n),!r))throw new c("$if requires the first argument to be a conditional",t[e].position,0,"if");let s=p;if(e=u,e>=o)throw new m("unexpected end of expression");if(t[e].value==="]")throw new c("$if requires atleast 2 arguments",t[e].position,2,"if");if(t[e].value!==",")throw new m("expected end of conditional",t[e].position);if(e+=1,i(!0),e>=o)throw new m("unexpected end of expression");let[l,h,k]=P(t,e,n);if(l){if(e=h,e>=o)throw new m("unexpected end of expression")}else throw new c("$if must have atleast a condition and 1 parameter",t[e].position,1,"if");let f,g,_;if(t[e].value===","&&(e+=1,i(!0),t[e].value!=="]")){if([f,g,_]=P(t,e,n),!f)throw new m("expected 3rd parameter");if(e=g,e>=o)throw new m("unexpected end of expression")}if(t[e].value!=="]")throw new m("expected end of arguments list",t[e].position);return[!0,e+1,new V({position:a,value:s,whenTrue:k,whenFalse:_})]};var P=(t,e,n)=>{let o=t.length;if(e>=o)return[!1];let a=t[e].position,i=u=>{let[p,s,l]=x(t,e);if(p&&(e=s),u&&e>=o)throw new m("unexpected end of expression");return l||""};if(i(),e>=o)return[!1];let r=new v({position:a});for(;e<o;){let u=t[e].position,p=i();if(e>=o)break;if(t[e].value==="]"||t[e].value===",")return[!0,e,r.unwrap];p!==""&&r.add(new d({position:u,value:p}));let[s,l,h]=z(t,e,'"$,\\`]');s&&(r.add(new d({position:u,value:h.value})),e=l);let[k,f,g]=j(t,e,n);if(k){r.add(g),e=f;continue}if([k,f,g]=$(t,e),k){r.add(g),e=f;continue}if([k,f,g]=L(t,e,n),k){r.add(g),e=f;continue}if([k,f,g]=C(t,e,n),k){r.add(g),e=f;continue}if([k,f,g]=S(t,e,n),k){r.add(g),e=f;continue}r.add(new d(t[e])),e+=1}throw new m("unexpected end of arguments list")};var B=(t,e,n)=>{let o=t.length;if(e>=o||t[e].value!=="[")return[!1];let a=t[e].position;e+=1;let i=()=>{let[u,p,s]=x(t,e);return u?(e=p,s):""};i();let r=[];for(;e<o&&(i(),!(e>=o));){let[u,p,s]=P(t,e,n);if(!u)throw new m("encountered missing or invalid argument",t[e].position);if(e=p,r.push(s),e>=o)break;if(t[e].value==="]")return[!0,e+1,new E({position:a,value:r})];if(t[e].value!==",")throw new m("expected end of argument",t[e].position);e+=1}throw e>=o?new m("unexpected end of expression"):new m("unexpected end of arguments list",t[e].position)};var L=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!=="$")return[!1];let a=t[e].position;e+=1;let i="",r="",u=e;for(;u<o;){let f=t[u].value;if(!/[\x21-\x47\x3A-\x40\x5B\x5D-\x60\x7B-\x7E]/.test(f))break;i+=f,u+=1,n.lookups.has(i)&&(r=i,e=u)}if(e>=o||!r)return[!1];let p="";if(!/^[a-z]/i.test(t[e].value))return[!1];for(;e<o&&(/^[a-z\d]+$/i.test(t[e].value)||t[e].value==="_"||t[e].value==="-");)p+=t[e].value,e+=1;if(!/^[a-z][a-z\d_-]+/i.test(p))return[!1];let s,[l,h,k]=B(t,e,n);return l&&(e=h,s=k),[!0,e,new N({position:a,prefix:r,value:p,arguments:s})]};var j=(t,e,n)=>{let o=t.length;if(e+1>=o||t[e].value!=="``")return[!1];e+=1;let a=new v({position:t[e].position});for(;e<o;){if(t[e].value==="``")return[!0,e+1,a.unwrap];let[i,r,u]=L(t,e,n);if(i){a.add(u),e=r;continue}if([i,r,u]=C(t,e,n),i){a.add(u),e=r;continue}if([i,r,u]=S(t,e,n),i){a.add(u),e=r;continue}a.add(new d(t[e])),e+=1}return[!1]};var ae=t=>{let e=new R(t),n=Y(t.expression),o=n.length,a=0;for(;a<o;){let[i,r,u]=z(n,a);if(i){e.add(new d(u)),a=r;continue}let[p,s,l]=j(n,a,t);if(p){e.add(l),a=s;continue}if([p,s,l]=L(n,a,t),p){e.add(l),a=s;continue}if([p,s,l]=C(n,a,t),p){e.add(l),a=s;continue}if([p,s,l]=S(n,a,t),p){e.add(l),a=s;continue}e.add(new d(n[a])),a+=1}return e};var ge=t=>{if(t==null)throw new TypeError("options not specified");if(t.variables==null)throw new TypeError("variables map is null");if(!(t.variables instanceof Map))throw new TypeError("variables map is not a Map instance");if(t.lookups==null)t.lookups=new Map;else if(!(t.lookups instanceof Map))throw new TypeError("lookups option specified but is not a Map instance");if(t.logicalOperators==null)t.logicalOperators=new Map;else if(!(t.logicalOperators instanceof Map))throw new TypeError("logical operators options specified but is not a Map instance");if(t.comparisonOperators==null)t.comparisonOperators=new Map;else if(!(t.comparisonOperators instanceof Map))throw new TypeError("comparison operators options specified but is not a Map instance");if(t.expression==null)throw new TypeError("expression not specified");if(typeof t.expression!="string")throw new TypeError("expression must be a string");return ae(t)},kn=async t=>ge(t).evaluate({onlyValidate:t.onlyValidate,preeval:t.preeval,data:t.data});export{E as ArgumentsToken,T as BaseToken,J as ComparisonToken,c as ExpressionArgumentsError,I as ExpressionError,m as ExpressionSyntaxError,b as ExpressionVariableError,V as IfToken,D as LogicToken,N as LookupToken,R as RootToken,v as SequenceToken,d as TextToken,M as VariableToken,kn as evaluate,ge as tokenize};
+/*!
+The MIT License (MIT) @ Copyright (c) 2016 Justin Sippel, Vitaly Domnikov
+https://github.com/bluelovers/runes/blob/8013b6e4021a41d6b579d76b3332c87389c5f092/LICENSE
+*/
+//# sourceMappingURL=expressionish.mjs.map

package/dist/expressionish.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/misc/split.ts", "../src/parse/base-token.ts", "../src/parse/sequence-token.ts", "../src/parse/root/token.ts", "../src/parse/text/token.ts", "../src/errors.ts", "../src/parse/lookup/token.ts", "../src/parse/arguments/token.ts", "../src/parse/text/escape.ts", "../src/parse/text/quote.ts", "../src/parse/if/token.ts", "../src/parse/comparison/operators.ts", "../src/parse/comparison/token.ts", "../src/parse/variable/token.ts", "../src/parse/variable/tokenize.ts", "../src/parse/whitespace/tokenize.ts", "../src/parse/comparison/tokenize.ts", "../src/parse/logic/operators.ts", "../src/parse/logic/token.ts", "../src/parse/logic/tokenize.ts", "../src/parse/if/tokenize.ts", "../src/parse/arguments/argument.ts", "../src/parse/arguments/tokenize.ts", "../src/parse/lookup/tokenize.ts", "../src/parse/text/block.ts", "../src/parse/root/tokenize.ts", "../src/expressionish.ts"],
+  "sourcesContent": ["import { type GenericToken } from '../types';\n\n/*!\nThe MIT License (MIT) @ Copyright (c) 2016 Justin Sippel, Vitaly Domnikov\nhttps://github.com/bluelovers/runes/blob/8013b6e4021a41d6b579d76b3332c87389c5f092/LICENSE\n*/\nconst HIGH_SURROGATE_START = 0xd800;\nconst HIGH_SURROGATE_END = 0xdbff;\nconst LOW_SURROGATE_START = 0xdc00;\nconst REGIONAL_INDICATOR_START = 0x1f1e6;\nconst REGIONAL_INDICATOR_END = 0x1f1ff;\nconst FITZPATRICK_MODIFIER_START = 0x1f3fb;\nconst FITZPATRICK_MODIFIER_END = 0x1f3ff;\nconst VARIATION_MODIFIER_START = 0xfe00;\nconst VARIATION_MODIFIER_END = 0xfe0f;\nconst DIACRITICAL_MARKS_START = 0x20d0;\nconst DIACRITICAL_MARKS_END = 0x20ff;\nconst ZWJ = 0x200d;\nconst GRAPHEMS = new Set([\n    0x0308, // ( \u25CC\u0308 ) COMBINING DIAERESIS\n    0x0937, // ( \u0937 ) DEVANAGARI LETTER SSA\n    0x093F, // ( \u093F ) DEVANAGARI VOWEL SIGN I\n    0x0BA8, // ( \u0BA8 ) TAMIL LETTER NA\n    0x0BBF, // ( \u0BBF ) TAMIL VOWEL SIGN I\n    0x0BCD, // ( \u25CC\u0BCD) TAMIL SIGN VIRAMA\n    0x0E31, // ( \u25CC\u0E31 ) THAI CHARACTER MAI HAN-AKAT\n    0x0E33, // ( \u0E33 ) THAI CHARACTER SARA AM\n    0x0E40, // ( \u0E40 ) THAI CHARACTER SARA E\n    0x0E49, // ( \u0E40 ) THAI CHARACTER MAI THO\n    0x1100, // ( \u1100 ) HANGUL CHOSEONG KIYEOK\n    0x1161, // ( \u1161 ) HANGUL JUNGSEONG A\n    0x11A8  // ( \u11A8 ) HANGUL JONGSEONG KIYEOK\n]);\n\nconst betweenInclusive = (value: number, lower: number, upper: number) => {\n    return (value >= lower && value <= upper);\n};\n\nconst codePointFromSurrogatePair = (pair: string) => {\n    const highOffset = pair.charCodeAt(0) - HIGH_SURROGATE_START;\n    const lowOffset = pair.charCodeAt(1) - LOW_SURROGATE_START;\n    return (highOffset << 10) + lowOffset + 0x10000;\n};\n\n/** Splits the input into an array of unicode-aware characters\n * @returns {string[]} An array containing the delimited characters where each entry is a character\n*/\nexport const split = (\n    /** Input text to split into characters */\n    input: string\n) : string[] => {\n    if (typeof input !== 'string') {\n        throw new Error('string cannot be undefined or null')\n    }\n    const result : string[] = [];\n    let idx = 0;\n    let inc = 0;\n    while (idx < input.length) {\n        const idxInc = idx + inc;\n        const current = input[idxInc];\n        if (\n            idxInc < (input.length - 1) &&\n            current &&\n            betweenInclusive(current.charCodeAt(0), HIGH_SURROGATE_START, HIGH_SURROGATE_END)\n        ) {\n            const currPair = codePointFromSurrogatePair(current + input[idxInc + 1]);\n            const nextPair = codePointFromSurrogatePair(input.substring(idxInc + 2, idxInc + 5));\n            if (\n                betweenInclusive(currPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END) &&\n                betweenInclusive(nextPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END)\n            ) {\n                inc += 4;\n            } else if (betweenInclusive(nextPair, FITZPATRICK_MODIFIER_START, FITZPATRICK_MODIFIER_END)) {\n                inc += 4;\n            } else {\n                inc += 2;\n            }\n        } else {\n            inc += 1;\n        }\n        if (GRAPHEMS.has((input[idx + inc] + '').charCodeAt(0))) {\n            inc += 1;\n        }\n        if (betweenInclusive((input[idx + inc] + '').charCodeAt(0), VARIATION_MODIFIER_START, VARIATION_MODIFIER_END)) {\n            inc += 1;\n        }\n        if (betweenInclusive((input[idx + inc] + '').charCodeAt(0), DIACRITICAL_MARKS_START, DIACRITICAL_MARKS_END)) {\n            inc += 1;\n        }\n        if ((input[idx + inc] + '').charCodeAt(0) === ZWJ) {\n            inc += 1;\n            continue;\n        }\n        result.push(input.substring(idx, idx + inc));\n        idx += inc;\n        inc = 0;\n    }\n    return result;\n};\n\n/** Converts the input into a list of Generic tokens for further processing\n * * Unicode multi-byte/character glyphs are treated as a singular entry\n * * Each whitespace character is treated as a singular entry\n * * `\\` is treated as a singular entry, the following character is also treated as a singular entry regardless of what it is\n * * \\`\\` is treated as a singular entry\n * * All other ascii punctionation is treated as a singular entry\n * * Non-unicode characters that are not whitespace or punctuation are grouped together and treated as a singular entry\n*/\nexport const tokenize = (input: string) : GenericToken[] => {\n\n    if (typeof input !== 'string') {\n        throw new Error('string cannot be undefined or null')\n    }\n\n    // eslint-disable-next-line no-control-regex\n    const asciiPunct = /^[\\x01-\\x2F\\x3A-\\x40\\x5B-\\x60\\x7B-\\x7E]$/;\n\n    const result : GenericToken[] = [];\n    let idx = 0;\n    let inc = 0;\n    let tok = null;\n    let escaped = false;\n    while (idx < input.length) {\n        const idxInc = idx + inc;\n        const current = input[idxInc];\n\n        // unicode multi-byte character\n        if (\n            idxInc < (input.length - 1) &&\n            current &&\n            betweenInclusive(current.charCodeAt(0), HIGH_SURROGATE_START, HIGH_SURROGATE_END)\n        ) {\n            const currPair = codePointFromSurrogatePair(current + input[idxInc + 1]);\n            const nextPair = codePointFromSurrogatePair(input.substring(idxInc + 2, idxInc + 5));\n            if (\n                betweenInclusive(currPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END) &&\n                betweenInclusive(nextPair, REGIONAL_INDICATOR_START, REGIONAL_INDICATOR_END)\n            ) {\n                inc += 4;\n            } else if (betweenInclusive(nextPair, FITZPATRICK_MODIFIER_START, FITZPATRICK_MODIFIER_END)) {\n                inc += 4;\n            } else {\n                inc += 2;\n            }\n        } else {\n            inc += 1;\n        }\n\n        if (GRAPHEMS.has((input[idx + inc] + '').charCodeAt(0))) {\n            inc += 1;\n        }\n        if (betweenInclusive((input[idx + inc] + '').charCodeAt(0), VARIATION_MODIFIER_START, VARIATION_MODIFIER_END)) {\n            inc += 1;\n        }\n        if (betweenInclusive((input[idx + inc] + '').charCodeAt(0), DIACRITICAL_MARKS_START, DIACRITICAL_MARKS_END)) {\n            inc += 1;\n        }\n        if ((input[idx + inc] + '').charCodeAt(0) === ZWJ) {\n            inc += 1;\n            continue;\n        }\n\n        // Emoji/unicode character\n        if (inc > 1) {\n            if (tok != null) {\n                result.push(tok);\n                tok = null;\n            }\n            result.push({ position: idx, value: input.substring(idx, idx + inc) });\n            escaped = false;\n\n        // block-escape denoter\n        } else if (input.substring(idx, idx + 2) === '``') {\n            if (tok != null) {\n                result.push(tok);\n                tok = null;\n            }\n            if (escaped) {\n                result.push({ position: idx, value: '`'});\n                escaped = false;\n            } else {\n                result.push({ position: idx, value: '``'});\n                inc += 1;\n            }\n\n        // singular character escape denoter\n        } else if (input[idx] === '\\\\') {\n            if (tok != null) {\n                result.push(tok);\n                tok = null;\n            }\n            result.push({ position: idx, value: '\\\\'});\n            escaped = !escaped;\n\n        // All ascii punctuation and whitespace assumed to be potentially significant\n        } else if (asciiPunct.test(input[idx])) {\n            if (tok != null) {\n                result.push(tok);\n                tok = null;\n            }\n            result.push({ position: idx, value: input[idx] });\n            escaped = false;\n\n        // Non-emoji, non-punctuation, no-whitespace characters\n        } else if (escaped) {\n            result.push({ position: idx, value: input[idx] });\n            escaped = false;\n        } else if (tok == null) {\n            tok = { position: idx, value: input[idx] };\n        } else {\n            tok.value += input[idx];\n        }\n\n        idx += inc;\n        inc = 0;\n    }\n    if (tok != null) {\n        result.push(tok);\n    }\n\n    return result;\n};", "import { type EvaluateOptions } from '../types';\n\n/** Represents the base options for all Token instances */\nexport interface BaseTokenOptions {\n    position: number,\n    type?: string,\n    value?: unknown\n}\n\n/** Represents the base return value for all Token instance .toJSON() functions */\nexport interface BaseTokenJSON {\n    position: number,\n    type: string,\n    value?: unknown\n}\n\n/** The most basic token; should not be used externally */\nexport default class BaseToken {\n\n    /** Position in the expression where the token occurs */\n    position: number;\n\n    /** Token type */\n    type: string;\n\n    /** Token value */\n    value?: unknown;\n\n    constructor(options: BaseTokenOptions) {\n        this.position = options.position;\n        this.type = options.type || 'UNKNOWN';\n        this.value = options.value;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : BaseTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value\n        };\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions) : Promise<unknown> {\n        if (options.onlyValidate) {\n            return;\n        }\n        return this.value;\n    }\n}", "import type { EvaluateOptions } from '../types';\nimport type { LookupTokenJSON, IfTokenJSON, VariableTokenJSON, TextTokenJSON, SequenceTokenJSON } from '../tojson-types';\n\nimport type { default as TextToken } from './text/token';\nimport type { default as LookupToken } from './lookup/token';\nimport type { default as IfToken } from './if/token';\nimport type { default as VariableToken } from './variable/token';\n\nimport BaseToken from './base-token';\n\n/** Options used to create a new SequenceToken instance */\nexport interface SequenceTokenOptions {\n    /** Position in the expression where the sequence started */\n    position: number;\n}\n\n/** Represents a sequence of tokens from the expression */\nexport default class SequenceToken extends BaseToken {\n\n    /* List of tokens comprising the sequence */\n    value : Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;\n\n    constructor(options: SequenceTokenOptions) {\n        super({\n            ...options,\n            type: 'LIST'\n        });\n        this.value = [];\n    }\n\n    /** Adds a token to the end of sequence */\n    add(\n        /** Token instance to add to the sequence */\n        token: LookupToken | IfToken | VariableToken | TextToken | SequenceToken\n    ) {\n        if (\n            token.type !== 'TEXT' ||\n            !this.value.length ||\n            this.value[this.value.length - 1].type !== 'TEXT'\n        ) {\n            this.value.push(token);\n        } else {\n            this.value[this.value.length - 1].value += (token.value as string);\n        }\n    }\n\n    /** If the sequence contains a singular token it returns that token otherwise returns `this` */\n    get unwrap() : SequenceToken | TextToken | LookupToken | IfToken | VariableToken {\n        if (this.value.length === 1) {\n            return this.value[0];\n        }\n        return this;\n    }\n\n    /** Converts the sequence to a JSON.stringify()-able object */\n    toJSON() : SequenceTokenJSON | LookupTokenJSON | IfTokenJSON | VariableTokenJSON | TextTokenJSON {\n        const unwrapped = this.unwrap;\n        if (unwrapped !== this) {\n            return unwrapped.toJSON();\n        }\n\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value.map(token => token.toJSON())\n        }\n    }\n\n    /** Evaluates the sequence  */\n    async evaluate(options: EvaluateOptions) : Promise<unknown> {\n        if (this.value == null || this.value.length === 0) {\n            return;\n        }\n        if (this.value.length === 1) {\n            return this.value[0].evaluate(options || {});\n        }\n\n        return (await Promise.all(this.value.map(token => token.evaluate(options || {})))).reduce((prev: unknown, curr) => {\n            if (prev == null) {\n                return curr;\n            }\n            if (curr == null) {\n                return prev;\n            }\n            //eslint-disable-next-line @typescript-eslint/no-explicit-any\n            return (prev as any) + (curr as any);\n        })\n    }\n\n}", "import type { RootTokenJSON } from '../../tojson-types';\nimport type { TokenizeOptions, PreEval, EvaluateData, LookupMap, VariableMap, LogicOperatorMap, ComparisonOperatorMap } from '../../types';\n\nimport SequenceToken from '../sequence-token';\n\n/** Represents the options for a new RootToken instance */\nexport type RootTokenOptions = TokenizeOptions;\n\n/** Represents the options passed to a RootToken instance's `evaluate()` function */\nexport interface RootEvaluateOptions {\n\n    /** When true, only validation will occur. Logic Operators, Comparison Operators, Variable & Lookups will not be evaluated */\n    onlyValidate?: boolean;\n\n    /** Called just prior to evaluating each variable and/or lookup */\n    preeval?: PreEval;\n\n    /** Data to pass to Logic Operators, Comparison Operators, Variables and Lookup results' `evaluate()` functions */\n    data?: EvaluateData;\n}\n\n/** Wrapper token representing the `tokenized()` expression */\nexport default class RootToken extends SequenceToken {\n\n    /** Map of externally defined Lookup Handlers */\n    lookups: LookupMap;\n\n    /** Map of externally defined Variables */\n    variables: VariableMap;\n\n    /** Map of externally defined Logic Operators */\n    logicOperators: LogicOperatorMap;\n\n    /** Map of exernally defined Comparison Operators */\n    comparisonOperators: ComparisonOperatorMap;\n\n    /** Expression that is/was tokenized */\n    expression: string;\n\n    constructor(options: RootTokenOptions) {\n        super({\n            position: 0\n        });\n        this.type = 'ROOT'\n        this.lookups = options.lookups;\n        this.variables = options.variables;\n        this.logicOperators = options.logicalOperators || new Map();\n        this.comparisonOperators = options.comparisonOperators || new Map();\n        this.expression = options.expression;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON(): RootTokenJSON {\n        return super.toJSON();\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: RootEvaluateOptions = {}): Promise<unknown> {\n        return super.evaluate({\n            ...options,\n            lookups: this.lookups,\n            variables: this.variables,\n            logicalOperators: this.logicOperators,\n            comparisonOperators: this.comparisonOperators,\n            expression: this.expression\n        });\n    }\n}", "import BaseToken from '../base-token';\n\nimport type { TextTokenJSON } from '../../tojson-types';\n\n/** Represents the options for a new TextToken instance */\nexport interface TextTokenOptions {\n\n    /** Position of the variable within the expression */\n    position: number,\n\n    /** The text of the token */\n    value: string\n}\n\n/** Represents literal text */\nexport default class TextToken extends BaseToken {\n\n    /** The text of the token */\n    value: string;\n\n    constructor(options: TextTokenOptions) {\n        super({\n            ...options,\n            type: 'TEXT'\n        });\n        this.value = options.value || '';\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : TextTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value\n        };\n    }\n}", "/** Represents a generic error when attempting to parse an expression */\nexport class ExpressionError extends Error {\n    /** When defined: where the error was encountered within the expression text */\n    position?: number;\n\n    constructor(\n        /** Message to associate with the error */\n        message: string,\n\n        /** Where the error was encountered within the expression text */\n        position?: number\n    ) {\n        super(message);\n        Error.captureStackTrace(this, this.constructor);\n        this.name = 'ExpressionError';\n        this.message = message;\n        this.position = position;\n    }\n    static get name() {\n        return 'ExpressionError';\n    }\n}\n\n/** Represents an error related to the arguments list or a singular argument to be passed to a variable */\nexport class ExpressionArgumentsError extends ExpressionError {\n\n    /** The index of the argument in the arguments list */\n    index?: number;\n\n    /** The variable name the arguments list belongs to */\n    varname?: string;\n\n    constructor(\n        /** Message to associate with the error */\n        message: string,\n\n        /** Where the error was encountered within the expression text */\n        position?: number,\n\n        /** The index of the argument in the arguments list */\n        index?: number,\n\n        /** The variable name the arguments list belongs to */\n        varname?: string\n    ) {\n        super(message, position);\n        Error.captureStackTrace(this, this.constructor);\n        this.name = 'ExpressionArgumentsError';\n        this.index = index || -1;\n        this.varname = varname;\n    }\n\n    static get name() {\n        return 'ExpressionArgumentsError';\n    }\n}\n\n/** Represents an error related to parsing a variable */\nexport class ExpressionVariableError extends ExpressionError {\n\n    /** The associated variable name */\n    varname?: string;\n\n    constructor(\n        /** Message to associate with the error */\n        message: string,\n\n        /** Where the error was encountered within the expression text */\n        position?: number,\n\n        /** The variable name to associate with the error */\n        varname?: string\n    ) {\n        super(message, position);\n        Error.captureStackTrace(this, this.constructor);\n        this.name = 'ExpressionVariableError';\n        this.varname = varname;\n    }\n\n    static get name() {\n        return 'ExpressionVariableError';\n    }\n}\n\n/** Represents a syntax error within the given expression */\nexport class ExpressionSyntaxError extends ExpressionError {\n\n    /** The character associated with the error */\n    character?: string;\n\n    constructor(\n\n        /** Message to associate with the error */\n        message: string,\n\n        /** Where the error was encountered within the expression text */\n        position?: number,\n\n        /** The character associated with the error */\n        character?: string\n    ) {\n        super(message, position);\n        Error.captureStackTrace(this, this.constructor);\n        this.name = 'ExpressionSyntaxError';\n        this.character = character;\n    }\n\n    static get name() {\n        return 'ExpressionSyntaxError';\n    }\n}", "import type { EvaluateOptions } from '../../types';\nimport type { LookupTokenJSON } from '../../tojson-types';\n\nimport BaseToken from '../base-token';\nimport ArgumentsToken from '../arguments/token';\n\nimport { ExpressionVariableError } from '../../errors';\n\n/** Represents the options for a new LookupToken instance */\nexport interface LookupTokenOptions {\n\n    /** Position in the expression the token occurs */\n    position: number;\n\n    /** The lookup's prefix */\n    prefix: string;\n\n    /** The name following the prefix */\n    value: string;\n\n    /** Arguments to pass to the lookup result's `evaluate()` function */\n    arguments?: ArgumentsToken;\n}\n\nexport default class LookupToken extends BaseToken {\n\n    /** Lookup's prefix */\n    prefix: string;\n\n    /** The name - following the prefix - to be looked up */\n    value: string;\n\n    /** Arguments to pass to the lookup result's `evaluate()` function */\n    arguments?: ArgumentsToken;\n\n    constructor(options: LookupTokenOptions) {\n        super({\n            ...options,\n            type: 'LOOKUP'\n        });\n        this.value = options.value;\n        this.prefix = options.prefix;\n        this.arguments = options.arguments;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : LookupTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            prefix: this.prefix,\n            value: this.value,\n            arguments: this.arguments ? this.arguments.toJSON() : undefined\n        }\n    }\n\n    /* Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown> {\n        if (!options.lookups) {\n            throw new ExpressionVariableError(`lookup map invalid`, this.position, this.value);\n        }\n\n        const lookup = options.lookups.get(this.prefix);\n        if (lookup == null) {\n            throw new ExpressionVariableError(`unknown lookup prefix`, this.position, this.prefix);\n        }\n\n        const variable = await lookup(options.data || {}, this.value);\n\n        if (variable == null) {\n            return;\n        }\n\n        if (options.preeval) {\n            await options.preeval(options.data || {}, variable);\n        }\n        if (variable.preeval) {\n            await variable.preeval(options.data || {}, variable);\n        }\n\n        let args : unknown[] = [];\n        if (this.arguments) {\n            args = await this.arguments.evaluate(options);\n        }\n\n        if (options.onlyValidate) {\n            return;\n        }\n\n        if (variable.argsCheck) {\n            // Should throw an ExpressionArgumentsError if argsCheck fails\n            await variable.argsCheck(options.data || {}, ...args);\n        }\n\n        return variable.evaluate(options.data || {}, ...args);\n    }\n}", "import type { EvaluateOptions } from '../../types';\nimport type { ArgumentsTokenJSON } from '../../tojson-types';\nimport type ComparisonToken from '../comparison/token';\nimport type IfToken from '../if/token';\nimport type LogicToken from '../logic/token';\nimport type LookupToken from '../lookup/token';\nimport type TextToken from '../text/token';\nimport type VariableToken from '../variable/token';\n\nimport BaseToken from '../base-token';\nimport SequenceToken from '../sequence-token';\n\n/** Represents the options for a new ArgumentsToken instance */\nexport interface ArgumentsTokenOptions {\n\n    /** Position of the arguments-bloc within the expression */\n    position: number;\n\n    /** Tokens contained in the arguments-bloc */\n    value?: Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken | LogicToken | ComparisonToken>\n}\n\n/** Represents a list of arguments */\nexport default class ArgumentsToken extends BaseToken {\n\n    /** Tokens contained in the arguments-bloc */\n    value : Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken | LogicToken | ComparisonToken>;\n\n    constructor(options: ArgumentsTokenOptions) {\n        super({\n            ...options,\n            type: 'ARGUMENTS_LIST'\n        });\n        this.value = options.value || [];\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : ArgumentsTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value.map(item => item.toJSON())\n        }\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown[]> {\n        return Promise.all(this.value.map(item => item.evaluate(options)));\n    }\n}", "import type { GenericToken, TokenizeResult } from '../../types';\n\n/** Attempts to consume an escape-sequence from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Escapable character; defaults to \"$[,]\\\\rnt and double backticks */\n    escapeChars?: string\n) : TokenizeResult<GenericToken> => {\n    const count = tokens.length;\n\n    if ((cursor + 1) >= count || tokens[cursor].value != '\\\\') {\n        return [false];\n    }\n\n    if (escapeChars == null) {\n        escapeChars = '\"$[,]\\\\rnt`'\n    }\n\n    // block-escape indicator escaped\n    if (\n        escapeChars.includes('`') &&\n        tokens[cursor + 1].value === '`' &&\n        tokens[cursor + 2].value === '`'\n    ) {\n        return [ true, cursor + 3, { position: cursor, value: '``' } ];\n    }\n\n    // Escape Denoter followed by non-escape char\n    // Treat the Escape Denoter as the escaped char (e.g. '\\' -> '\\\\')\n    if (!escapeChars.includes(tokens[cursor + 1].value)) {\n        return [true, cursor + 1, { position: cursor, value: '\\\\' }];\n    }\n\n    cursor += 1;\n    const token = { ...tokens[cursor] };\n\n    switch (token.value) {\n        case 'n':\n            token.value = '\\n';\n            break;\n\n        case 'r':\n            token.value = '\\r';\n            break;\n\n        case 't':\n            token.value = '\\t';\n            break;\n    }\n\n    return [true, cursor + 1, token];\n};", "import type { GenericToken, TokenizeResult } from '../../types';\n\nimport tokenizeEscape from './escape';\nimport TextToken from './token';\n\nimport { ExpressionSyntaxError } from '../../errors';\n\n/** Attempts to consume quoted text from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number\n) : TokenizeResult<TextToken> => {\n    const count = tokens.length;\n\n    if (\n        cursor >= count ||\n        tokens[cursor] == null ||\n        tokens[cursor].value !== '\"'\n    ) {\n        return [false];\n    }\n\n    const start = cursor;\n    cursor += 1;\n\n    let text : string = '';\n    while (cursor < count) {\n        if (tokens[cursor].value === '\"') {\n            return [\n                true,\n                cursor + 1,\n                new TextToken({\n                    position: start,\n                    value: text\n                })\n            ]\n        }\n\n        const [tokenized, tokenizeCursor, tokenizeResult] = tokenizeEscape(tokens, cursor, '\\\\\"nrt');\n        if (tokenized) {\n            cursor = tokenizeCursor;\n            text += tokenizeResult.value;\n            continue;\n        }\n\n        text += tokens[cursor].value;\n        cursor += 1;\n    }\n\n    throw new ExpressionSyntaxError('End quote missing', tokens[start].position);\n}", "import type { EvaluateOptions } from '../../types';\nimport type { IfTokenJSON } from '../../tojson-types';\nimport type ComparisonToken from '../comparison/token';\nimport type LogicToken from '../logic/token';\nimport type LookupToken from '../lookup/token';\nimport type VariableToken from '../variable/token';\nimport type SequenceToken from '../sequence-token';\nimport type TextToken from '../text/token';\ntype ConditionToken = ComparisonToken | LogicToken;\ntype OperandToken = LookupToken | IfToken | VariableToken | TextToken | SequenceToken;\n\nimport BaseToken from '../base-token';\n\n/** Represents the options for a new IfToken instance */\nexport interface IfTokenOptions {\n    /** Position of the if-bloc within the expression*/\n    position: number;\n\n    /** The condition of the if-bloc */\n    value: ConditionToken;\n\n    /** Token to evaluate if the condition is truthy */\n    whenTrue: OperandToken;\n\n    /** Token to evaluate if the condition is not truthy */\n    whenFalse?: OperandToken;\n}\n\n/** Represents an if token */\nexport default class IfToken extends BaseToken {\n\n    /** The condition of the if-bloc */\n    value: ConditionToken;\n\n    /** Token to evaluate if the condition is truthy */\n    whenTrue: OperandToken\n\n    /** Token to evaluate if the condition is not truthy */\n    whenFalse?: OperandToken;\n\n    constructor(options: IfTokenOptions) {\n        super({\n            position: options.position,\n            type: 'IF'\n        });\n        this.value = options.value;\n        this.whenTrue = options.whenTrue;\n        this.whenFalse = options.whenFalse;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : IfTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value.toJSON(),\n            whenTrue: this.whenTrue.toJSON(),\n            whenFalse: this.whenFalse ? this.whenFalse.toJSON() : undefined\n        };\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown> {\n        const result = await this.value.evaluate(options);\n        if (options.onlyValidate) {\n            await this.whenTrue.evaluate(options);\n            if (this.whenFalse) {\n                await this.whenFalse.evaluate(options);\n            }\n        } else if (result) {\n            return this.whenTrue.evaluate(options);\n        }\n        if (this.whenFalse) {\n            return this.whenFalse.evaluate(options);\n        }\n    }\n}", "import type { ComparisonOperator, ComparisonOperatorMap, EvaluateData } from '../../types';\n\n/** Attempts to convert the two inputs into numeric values */\nconst toNumber = (data: EvaluateData, v1: unknown, v2: unknown) : [unknown, unknown]|[number, number]=> {\n    if (v1 === '' || v2 === '') {\n        return [v1, v2];\n    }\n\n    const v1Num = Number(v1);\n    if (!Number.isFinite(v1Num)) {\n        return [v1, v2];\n    }\n\n    const v2Num = Number(v2);\n    if (!Number.isFinite(v2Num)) {\n        return [v1, v2];\n    }\n    return [v1Num, v2Num];\n}\n\n/** Tests if inputs are strictly equal */\nconst isStrictEqual = (data: EvaluateData, v1: unknown, v2: unknown) => {\n    [v1, v2] = toNumber(data, v1, v2);\n    return v1 === v2;\n};\n\n/** Tests if input is not a nullish value */\nconst isTruthy = (data: EvaluateData, v1: unknown) => {\n    return v1 != null &&\n        v1 !== false &&\n        v1 !== 0 &&\n        v1 !== '';\n};\n\n/** Built-in Comparison Operators Map */\nexport default (new Map<string, ComparisonOperator>([\n\n    ['istruthy',  {\n        right: 'never',\n        evaluate: isTruthy\n    }],\n    ['!istruthy', {\n        right: 'never',\n        evaluate: (data: EvaluateData, v1: unknown) => !isTruthy(data, v1)\n    }],\n\n    ['===', {\n        right: 'required',\n        evaluate: isStrictEqual\n    }],\n    ['!==', {\n        right: 'required',\n        evaluate: (data: EvaluateData, v1: unknown, v2: unknown) => !isStrictEqual(data, v1, v2)\n    }],\n\n    ['<', {\n        right: 'required',\n        evaluate: (data: EvaluateData, v1: unknown, v2: unknown) => {\n            [v1, v2] = toNumber(data, v1, v2);\n            if (typeof v1 !== 'number' || typeof v2 !== 'number') {\n                return false;\n            }\n            return v1 < v2;\n        }\n    }],\n    ['<=', {\n        right: 'required',\n        evaluate: (data: EvaluateData, v1: unknown, v2: unknown) => {\n            [v1, v2] = toNumber(data, v1, v2);\n            if (typeof v1 !== 'number' || typeof v2 !== 'number') {\n                return false;\n            }\n            return v1 <= v2;\n        }\n    }],\n\n    ['>', {\n        right: 'required',\n        evaluate: (data: EvaluateData, v1: unknown, v2: unknown) => {\n            [v1, v2] = toNumber(data, v1, v2);\n            if (typeof v1 !== 'number' || typeof v2 !== 'number') {\n                return false;\n            }\n            return v1 > v2;\n        }\n    }],\n    ['>=', {\n        right: 'required',\n        evaluate: (data: EvaluateData, v1: unknown, v2: unknown) => {\n            [v1, v2] = toNumber(data, v1, v2);\n            if (typeof v1 !== 'number' || typeof v2 !== 'number') {\n                return false;\n            }\n            return v1 >= v2;\n        }\n    }]\n]) as ComparisonOperatorMap);", "import type { EvaluateOptions } from '../../types';\nimport type { ComparisonTokenJSON } from '../../tojson-types';\nimport type { default as TextToken } from '../text/token';\nimport type { default as LookupToken } from '../lookup/token';\nimport type { default as IfToken } from '../if/token';\nimport type { default as VariableToken } from '../variable/token';\nimport type { default as SequenceToken } from '../sequence-token';\ntype operand = LookupToken | IfToken | VariableToken | TextToken | SequenceToken;\n\nimport BaseToken from '../base-token';\n\nimport operators from './operators';\n\n/** Represents the options for a new ComparisonToken instance */\nexport interface ComparisonTokenOptions {\n\n    /** Position of the comparison within the expression */\n    position: number;\n\n    /** Comparison operator used */\n    value: string;\n\n    /** Left side of comparison */\n    left: operand;\n\n    /** Right side of comparison */\n    right?: operand;\n}\n\n/** Represents a Comparison Token */\nexport default class ComparisonToken extends BaseToken {\n\n    /** Comparison operator used */\n    value: string;\n\n    /** Left side of comparison */\n    left: operand;\n\n    /** Right side of comparison */\n    right?: operand;\n\n    constructor(options: ComparisonTokenOptions) {\n        super({\n            ...options,\n            type: 'COMPARISON'\n        });\n        this.value = options.value;\n        this.left = options.left;\n        this.right = options.right;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : ComparisonTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value,\n            left:  this.left.toJSON(),\n            right: this.right ? this.right.toJSON() : undefined\n        };\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown> {\n        if (!this.value || this.value === '') {\n            this.value = 'istruthy';\n        }\n\n        const operator = operators.get(this.value);\n        if (operator == null) {\n            return false;\n        }\n\n        const left = await this.left.evaluate(options);\n\n        let right : undefined | unknown;\n        if (this.right) {\n            right = await this.right.evaluate(options);\n        }\n\n        if (options.onlyValidate) {\n            return;\n        }\n        return operator.evaluate(options.data || {}, left, right);\n    }\n}", "import type { EvaluateOptions, Variable } from '../../types';\nimport type { VariableTokenJSON } from '../../tojson-types'\n\nimport type ArgumentsToken from '../arguments/token';\nimport BaseToken from '../base-token';\n\n/** Represents the options for a new VariableToken instance */\nexport interface VariableTokenOptions {\n\n    /** Position of the variable within the expression */\n    position: number;\n\n    /** The variable's name */\n    value: string;\n\n    /** Arguments to evaluate & pass to the variable's evaluate function */\n    arguments?: ArgumentsToken\n}\n\n/** Represents a Variable token */\nexport default class VariableToken extends BaseToken {\n\n    /** The variable name */\n    value: string;\n\n    /** Arguments to evaluate & pass to the variable's evaluate function */\n    arguments?: ArgumentsToken;\n\n    constructor(options: VariableTokenOptions) {\n        super({\n            ...options,\n            type: 'VARIABLE'\n        });\n        this.value = options.value || '';\n        this.arguments = options.arguments;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : VariableTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value,\n            arguments: this.arguments ? this.arguments.toJSON() : undefined\n        }\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown> {\n        if (!options.variables || !options.variables.has(this.value)) {\n            throw new Error('unknown variable');\n        }\n\n        const variable = options.variables.get(this.value) as Variable;\n\n        if (options.preeval) {\n            await options.preeval(options.data || {}, variable);\n        }\n\n        if (variable.preeval) {\n            await variable.preeval(options.data || {}, variable);\n        }\n\n        let args : unknown[] = [];\n        if (this.arguments) {\n            args = await this.arguments.evaluate(options);\n        }\n\n        if (variable.argsCheck) {\n            await variable.argsCheck(options.data || {}, ...args);\n        }\n\n        if (options.onlyValidate) {\n            return;\n        }\n\n        return variable.evaluate(options.data || {}, ...args);\n    }\n}", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\n\nimport VariableToken from './token';\n\nimport tokenizeArguments from '../arguments/tokenize';\n\nimport { ExpressionVariableError } from '../../errors';\n\n/** Attempts to consume a varaiable from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<VariableToken> => {\n\n    const count = tokens.length;\n    if (cursor + 1 >= count || tokens[cursor].value !== '$') {\n        return [false];\n    }\n\n    const start = cursor;\n    cursor += 1;\n\n    // parse name\n    const name = tokens[cursor].value;\n    if (!/^[a-z][a-z\\d]*/i.test(name)) {\n        return [false];\n    }\n    if (!options.variables.has(name)) {\n        throw new ExpressionVariableError('unknown variable', tokens[cursor].position, name);\n    }\n    cursor += 1;\n\n    // parse arguments\n    const [tokenized, tCursor, tResult] = tokenizeArguments(tokens, cursor, options);\n    if (tokenized) {\n        cursor = tCursor as number;\n    }\n\n    return [\n        true,\n        cursor,\n        new VariableToken({\n            position: start,\n            value: name,\n            arguments: tResult\n        })\n    ];\n\n}", "import type { GenericToken, TokenizeResult } from '../../types';\n\n/** Attempts to consume sequential whitespace from `tokens` beginning at `cursor` */\nexport default ((\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number\n) : TokenizeResult<string> => {\n    const count = tokens.length;\n    if (cursor >= count) {\n        return [false];\n    }\n\n    let ws = '';\n    let index = cursor;\n    while (index < count && (\n        tokens[index].value === ' '  ||\n        tokens[index].value === '\\n' ||\n        tokens[index].value === '\\r' ||\n        tokens[index].value === '\\t' ||\n        tokens[index].value === '\\b' ||\n        tokens[index].value === '\\f'\n    )) {\n        ws += tokens[index].value;\n        index += 1;\n    }\n\n    if (cursor === index) {\n        return [false];\n    }\n    return [true, index, ws];\n});", "import type { ComparisonOperatorMap, GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\nimport type IfToken from '../if/token';\nimport type LookupToken from '../lookup/token';\nimport type VariableToken from '../variable/token';\n\nimport ComparisonToken from './token';\nimport SequenceToken from '../sequence-token';\nimport TextToken from '../text/token';\n\nimport tokenizeEscape from '../text/escape';\nimport tokenizeIf from '../if/tokenize';\nimport tokenizeLookup from '../lookup/tokenize';\nimport tokenizeQuote from '../text/quote';\nimport tokenizeVariable from '../variable/tokenize';\nimport tokenizeWhitespace from '../whitespace/tokenize';\n\nimport operators from './operators';\nimport { ExpressionArgumentsError, ExpressionSyntaxError } from '../../errors';\n\n\ninterface TokenizeOperatorOptions extends TokenizeOptions {\n    comparisonOperators: ComparisonOperatorMap\n}\n\n/** Attempts to consume a comparison operator from `tokens` starting at `cursor` */\nconst tokenizeOperator = (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to initial tokenize() call */\n    options: TokenizeOperatorOptions\n) : [success: false ] | [success: true, cursor: number, result: string ]=> {\n    const count = tokens.length;\n    if (\n        cursor >= count ||\n        tokens[cursor].value === ',' ||\n        tokens[cursor].value === ']' ||\n        /^\\s/.test(tokens[cursor].value)\n    ) {\n        return [false];\n    }\n\n    let operator : string = '';\n    if (tokens[cursor].value === '!') {\n        operator = '!';\n        cursor += 1;\n        if (\n            cursor >= count ||\n            tokens[cursor].value === ',' ||\n            tokens[cursor].value === ']' ||\n            /^\\s/.test(tokens[cursor].value)\n        ) {\n            return [false];\n        }\n    }\n\n    const operators = options.comparisonOperators;\n\n    // text operator, such as 'isnumber'\n    if (/^[a-z]+$/i.test(tokens[cursor].value)) {\n        operator += tokens[cursor].value.toLowerCase();\n        cursor += 1;\n\n    // punctuation operator, such as ==\n    } else {\n        let operatorAccumulator = operator;\n        let tmpCursor = cursor;\n        while (tmpCursor < count) {\n            if (!/^[\\x21-\\x2F\\x3A-\\x40\\x5E-\\x60]$/.test(tokens[tmpCursor].value)) {\n                break;\n            }\n\n            operatorAccumulator += tokens[tmpCursor].value;\n            tmpCursor += 1;\n\n            if (operators.has(operatorAccumulator)) {\n                operator = operatorAccumulator;\n                cursor = tmpCursor;\n            }\n        }\n    }\n\n\n    if (\n        cursor >= count ||\n        !operators.has(operator) ||\n        (\n            tokens[cursor].value !== ',' &&\n            tokens[cursor].value !== ']' &&\n            !/^\\s+$/.test(tokens[cursor].value)\n        )\n    ) {\n        return [false];\n    }\n\n\n    const [wsRem, wsCursor] = tokenizeWhitespace(tokens, cursor);\n    if (wsRem) {\n        cursor = wsCursor as number;\n    }\n    return [true, cursor, operator];\n}\n\n/** Attempts to consume a comparison from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the initial `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<ComparisonToken> => {\n    const count = tokens.length;\n\n    // nothing to parse\n    if (\n        cursor >= count ||\n        tokens[cursor].value === ',' ||\n        tokens[cursor].value === ']'\n    ) {\n        return [false];\n    }\n\n    const mergedOperators : ComparisonOperatorMap = new Map(operators);\n    if (options.comparisonOperators) {\n        options.comparisonOperators.forEach((operator, key) => {\n            mergedOperators.set(key, operator);\n        });\n    }\n    const tokOpOptions : TokenizeOperatorOptions = { ...options, comparisonOperators: mergedOperators };\n\n    const start = tokens[cursor].position;\n\n    const consumeWS = () => {\n        const [wsRem, wsCursor, wsResult] = tokenizeWhitespace(tokens, cursor);\n        if (wsRem) {\n            cursor = wsCursor as number;\n            return wsResult as string;\n        }\n        return ''\n    }\n\n    const left = new SequenceToken({ position: start });\n    let operator : undefined | string;\n    let right : SequenceToken | undefined;\n    while (cursor < count) {\n        const position = cursor;\n        const ws = consumeWS();\n\n        // end of conditional sequence\n        if (\n            cursor >= count\n            || tokens[cursor].value === ','\n            || tokens[cursor].value === ']'\n        ) {\n            break;\n        }\n\n        if (left.value.length > 0 && operator == null && ws !== '') {\n            const [opTokenized, opCursor, opResult] = tokenizeOperator(tokens, cursor, tokOpOptions);\n            if (opTokenized) {\n                if (left.value.length === 0) {\n                    throw new ExpressionSyntaxError('left operand not specified', start);\n                }\n\n                cursor = opCursor as number;\n                operator = opResult as string;\n                right = new SequenceToken({ position: cursor });\n                continue;\n            }\n        }\n\n        const parts = right ? right : left;\n\n        if (ws !== '') {\n            parts.add(new TextToken({ position, value: ws }));\n        }\n\n        // Single-char escape\n        const [eTokenized, eCursor, eResult] = tokenizeEscape(tokens, cursor, '\"$,\\\\`]');\n        if (eTokenized) {\n            parts.add(new TextToken({ position, value: (eResult as GenericToken).value}));\n            cursor = eCursor as number;\n        }\n\n        // Quoted text\n        let [tokenized, tCursor, tResult] : [ tokenized: boolean, cursor?: number, result?: LookupToken | IfToken | VariableToken | TextToken ] = tokenizeQuote(tokens, cursor);\n        if (tokenized) {\n            parts.add(tResult as TextToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // Lookup\n        [tokenized, tCursor, tResult] = tokenizeLookup(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as LookupToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // $if\n        [tokenized, tCursor, tResult] = tokenizeIf(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as IfToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // Variable\n        [tokenized, tCursor, tResult] = tokenizeVariable(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as VariableToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // All other situations treat the generic token as plain text\n        parts.add(new TextToken(tokens[cursor]));\n        cursor += 1;\n\n    }\n\n    if (!left.value.length) {\n        return [false];\n    }\n    operator = operator || 'istruthy';\n\n    if (\n        operators.get(operator)?.right === 'never'\n        && right != null\n        && (\n            !(right instanceof SequenceToken) ||\n            right.value.length !== 0\n        )\n    ) {\n        throw new ExpressionArgumentsError(`comparison operator ${operator} must not have a right-hand-side value`);\n    }\n    if (\n        operators.get(operator)?.right === 'required'\n        && (\n            right == null ||\n            (right instanceof SequenceToken && right.value.length === 0)\n        )\n    ) {\n        throw new ExpressionArgumentsError(`comparison operator ${operator} requires a right-hand-side value`);\n    }\n    return [\n        true,\n        cursor,\n        new ComparisonToken({\n            position: start,\n            value: operator,\n            left: left.unwrap,\n            right: right ? right.unwrap : undefined\n        })\n    ]\n}", "import type { EvaluateData, LogicOperator, LogicOperatorMap } from '../../types';\n\n/** Tests if `arg` is falsy */\nconst not = (data: EvaluateData, arg: unknown) => (arg == null || arg === false || arg === 0 || arg === '');\n\n/** Built-in Logic Operators Map */\nexport default (new Map<string, LogicOperator>([\n    ['not', {\n        minArgumentsCount: 1,\n        maxArgumentsCount: 1,\n        evaluate: not\n    }],\n    ['and', {\n        minArgumentsCount: 1,\n        evaluate: (data: EvaluateData, ...args: unknown[]) => {\n            if (args == null || !args.length) {\n                return false;\n            }\n            return !args.some(item => not(data, item));\n        }\n    }],\n    ['or', {\n        minArgumentsCount: 1,\n        evaluate: (data: EvaluateData, ...args: unknown[]) => {\n            if (args == null || !args.length) {\n                return false;\n            }\n            return args.some(item => !not(data, item));\n        }\n    }],\n])) as LogicOperatorMap;", "import type { EvaluateOptions, LogicOperator } from '../../types';\nimport type { LogicTokenJSON } from '../../tojson-types';\nimport type ArgumentsToken from '../arguments/token';\n\nimport BaseToken from '../base-token';\n\nimport operators from './operators';\n\n/** Represents the options for a new LogicToken instance */\nexport interface LogicTokenOptions {\n\n    /** Position of the logic conditional within the expression */\n    position: number;\n\n    /** The operator used */\n    value: string;\n\n    /** Arguments to be passed to the operator's `evaluate()` function */\n    arguments: ArgumentsToken;\n}\n\n/** Represents a logical-conditional token */\nexport default class LogicToken extends BaseToken {\n\n    /** The operator used */\n    value: string;\n\n    /** Arguments to be passed to the operator's `evaluate()` function */\n    arguments: ArgumentsToken;\n\n    constructor(options: LogicTokenOptions) {\n        super({\n            ...options,\n            type: 'LOGIC'\n        });\n        this.value = options.value;\n        this.arguments = options.arguments;\n    }\n\n    /** Converts the token to a JSON.stringify()-able object */\n    toJSON() : LogicTokenJSON {\n        return {\n            position: this.position,\n            type: this.type,\n            value: this.value,\n            arguments: this.arguments.toJSON()\n        };\n    }\n\n    /** Evaluates the token */\n    async evaluate(options: EvaluateOptions): Promise<unknown> {\n        let operator : LogicOperator;\n        if (options.logicalOperators?.has(this.value)) {\n            operator = options.logicalOperators.get(this.value) as LogicOperator;\n        } else if (operators.has(this.value)) {\n            operator = operators.get(this.value) as LogicOperator;\n        } else {\n            return false;\n        }\n\n        const args = await this.arguments.evaluate(options);\n        if (operator.argsCheck) {\n            operator.argsCheck(options.data || {}, ...args);\n        }\n\n        if (options.onlyValidate) {\n            return;\n        }\n\n        return operator.evaluate(options.data || {}, ...args);\n    }\n}", "import type { GenericToken, LogicOperator, TokenizeOptions, TokenizeResult } from '../../types';\nimport type ComparisonToken from '../comparison/token';\nimport type IfToken from '../if/token';\nimport type LookupToken from '../lookup/token';\nimport type SequenceToken from '../sequence-token';\nimport type TextToken from '../text/token';\nimport type VariableToken from '../variable/token';\n\nimport ArgumentsToken from '../arguments/token';\nimport LogicToken from './token'\n\nimport tokenizeWhitespace from '../whitespace/tokenize';\nimport tokenizeComparison from '../comparison/tokenize';\n\nimport operators from './operators';\nimport { ExpressionArgumentsError, ExpressionSyntaxError } from '../../errors';\n\n/** Attempts to consume a Logic Operator from `tokens` starting at `cursor` */\nconst tokenizeLogicOperator = (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<LogicToken> => {\n    const count = tokens.length;\n\n\n    if (cursor + 1 >= count || tokens[cursor].value !== '$') {\n        return [false];\n    }\n    const start = tokens[cursor].position;\n    cursor += 1;\n\n    const mergedOperators = new Map(operators);\n    if (options.logicalOperators) {\n        options.logicalOperators.forEach((operator, key) => {\n            mergedOperators.set(key, operator);\n        });\n    }\n    let operator : string;\n    if (mergedOperators.has(tokens[cursor].value)) {\n        operator = tokens[cursor].value;\n        cursor += 1;\n        if (cursor >= count) {\n            return [false];\n        }\n    } else {\n        return [false];\n    }\n\n    if (tokens[cursor].value !== '[') {\n        throw new ExpressionSyntaxError('Logic Operators require atleast one argument', tokens[cursor].position);\n    }\n    const argsStart = tokens[cursor].position;\n    cursor += 1;\n\n    const consumeWS = (notEnd?: boolean) : undefined | string => {\n        const [tokenized, tCursor, ws] = tokenizeWhitespace(tokens, cursor);\n        if (tokenized) {\n            cursor = tCursor as number;\n        }\n        if (notEnd && cursor >= count) {\n            throw new ExpressionSyntaxError('unexpected end of expression');\n        }\n        return ws;\n    }\n    consumeWS(true);\n\n    const args : Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken> = [];\n    while (cursor < count) {\n\n        consumeWS();\n\n        if (cursor >= count) {\n            break;\n        }\n\n        let [tokenize, tCursor, tResult] : [tokenize: boolean, tCursor?: number, tResult?: LogicToken | ComparisonToken] = tokenizeLogicOperator(tokens, cursor, options);\n        if (!tokenize) {\n            [tokenize, tCursor, tResult] = tokenizeComparison(tokens, cursor, options);\n        }\n        if (!tokenize) {\n            throw new ExpressionArgumentsError('conditional expected', tokens[cursor].position, args.length);\n        }\n        args.push(tResult as (LogicToken | ComparisonToken));\n        cursor = tCursor as number;\n\n        if (tokens[cursor].value === ',') {\n            cursor += 1;\n            continue;\n        }\n\n        if (tokens[cursor].value === ']') {\n            const opDef = operators.get(operator) as LogicOperator;\n            if (opDef.minArgumentsCount != null && args.length < opDef.minArgumentsCount) {\n                throw new ExpressionArgumentsError(`$${operator} expects atleast ${opDef.minArgumentsCount} argument(s)`);\n            }\n            if (opDef.maxArgumentsCount != null && args.length > opDef.maxArgumentsCount) {\n                throw new ExpressionArgumentsError(`$${operator} expects at most ${opDef.maxArgumentsCount} argument(s)`);\n            }\n            return [\n                true,\n                cursor + 1,\n                new LogicToken({\n                    position: start,\n                    value: operator,\n                    arguments: new ArgumentsToken({\n                        position: argsStart,\n                        value: args\n                    })\n                })\n            ];\n        }\n\n        throw new ExpressionSyntaxError('unexpected token', tokens[cursor].position);\n    }\n\n    throw new ExpressionSyntaxError('unexpected end of expression', count);\n}\nexport default tokenizeLogicOperator;", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\nimport type ComparisonToken from '../comparison/token';\nimport type LogicToken from '../logic/token';\nimport type LookupToken from '../lookup/token';\nimport type SequenceToken from '../sequence-token';\nimport type TextToken from '../text/token';\nimport type VariableToken from '../variable/token';\ntype ConditionToken = ComparisonToken | LogicToken;\n\nimport IfToken from './token';\n\nimport tokenizeArgument from '../arguments/argument';\nimport tokenizeComparison from '../comparison/tokenize';\nimport tokenizeLogicOperator from '../logic/tokenize';\nimport tokenizeWhitespace from '../whitespace/tokenize';\n\nimport { ExpressionArgumentsError, ExpressionSyntaxError } from '../../errors';\n\n/** Attempts to consume an If Statement from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<IfToken> => {\n    const count = tokens.length;\n\n    if (\n        cursor + 1 >= count ||\n        tokens[cursor].value !== '$' ||\n        tokens[cursor + 1].value !== 'if'\n    ) {\n        return [false];\n    }\n\n    const start = tokens[cursor].position;\n    cursor += 2;\n\n    if (cursor >= count) {\n        throw new ExpressionArgumentsError('$if requires atleast 2 arguments', start, 0, 'if');\n    }\n\n    if (tokens[cursor].value !== '[') {\n        throw new ExpressionArgumentsError('$if requires atleast 2 arguments', tokens[cursor].position, 0, 'if');\n    }\n    cursor += 1;\n\n\n    const consumeWS = (notEnd?: boolean) : undefined | string => {\n        const [tokenized, tCursor, ws] = tokenizeWhitespace(tokens, cursor);\n        if (tokenized) {\n            cursor = tCursor as number;\n        }\n        if (notEnd && cursor >= count) {\n            throw new ExpressionSyntaxError('unexpected end of expression');\n        }\n        return ws;\n    }\n    consumeWS(true);\n\n    // condition\n    let [tokenize, tCursor, tResult] : [tokenize: boolean, tCursor?: number, tResult?: ConditionToken ] = tokenizeLogicOperator(tokens, cursor, options);\n    if (!tokenize) {\n        [tokenize, tCursor, tResult] = tokenizeComparison(tokens, cursor, options);\n        if (!tokenize) {\n            throw new ExpressionArgumentsError('$if requires the first argument to be a conditional', tokens[cursor].position, 0, 'if');\n        }\n    }\n    const condition = tResult as ConditionToken;\n    cursor = tCursor as number;\n\n    // , expected after condition\n    if (cursor >= count) {\n        throw new ExpressionSyntaxError('unexpected end of expression');\n    }\n    if (tokens[cursor].value === ']') {\n        throw new ExpressionArgumentsError('$if requires atleast 2 arguments', tokens[cursor].position, 2, 'if');\n    }\n    if (tokens[cursor].value !== ',') {\n        throw new ExpressionSyntaxError('expected end of conditional', tokens[cursor].position);\n    }\n    cursor += 1;\n    consumeWS(true);\n\n    // whenTrue\n    if (cursor >= count) {\n        throw new ExpressionSyntaxError('unexpected end of expression');\n    }\n    const [wtTokenize, wtCursor, whenTrue] = tokenizeArgument(tokens, cursor, options);\n    if (!wtTokenize) {\n        throw new ExpressionArgumentsError('$if must have atleast a condition and 1 parameter', tokens[cursor].position, 1, 'if');\n\n    } else {\n        cursor = wtCursor as number;\n        if (cursor >= count) {\n            throw new ExpressionSyntaxError('unexpected end of expression');\n        }\n    }\n\n    // when false\n    let wfTokenize : boolean,\n        wfCursor: undefined | number,\n        whenFalse: undefined | LookupToken | IfToken | VariableToken | TextToken | SequenceToken;\n    if (tokens[cursor].value === ',') {\n\n        // consume , and trailing whitespace\n        cursor += 1;\n        consumeWS(true);\n\n        if (tokens[cursor].value !== ']') {\n            [wfTokenize, wfCursor, whenFalse] = tokenizeArgument(tokens, cursor, options);\n            if (!wfTokenize) {\n                throw new ExpressionSyntaxError('expected 3rd parameter');\n            }\n            cursor = wfCursor as number;\n            if (cursor >= count) {\n                throw new ExpressionSyntaxError('unexpected end of expression');\n            }\n        }\n    }\n\n    // end of arguments\n    if (tokens[cursor].value !== ']') {\n        throw new ExpressionSyntaxError('expected end of arguments list', tokens[cursor].position);\n    }\n    return [\n        true,\n        cursor + 1,\n        new IfToken({\n            position: start,\n            value: condition,\n            whenTrue,\n            whenFalse\n        })\n    ];\n}", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\n\nimport IfToken from '../if/token';\nimport LookupToken from '../lookup/token';\nimport SequenceToken from '../sequence-token';\nimport TextToken from '../text/token';\nimport VariableToken from '../variable/token';\n\nimport tokenizeQuote from '../text/quote';\nimport tokenizeEscape from '../text/escape';\nimport tokenizeBlockEscape from '../text/block';\nimport tokenizeLookup from '../lookup/tokenize';\nimport tokenizeIf from '../if/tokenize';\nimport tokenizeVariable from '../variable/tokenize';\nimport tokenizeWhitespace from '../whitespace/tokenize';\n\nimport { ExpressionSyntaxError } from '../../errors';\n\n/** Attempts to tokenize a singular argument for a arguments-bloc from `tokens` starting at `cursor` */\nexport default (\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the initial `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken> => {\n    const count = tokens.length;\n\n    if (cursor >= count) {\n        return [false];\n    }\n\n    const start = tokens[cursor].position;\n\n    const consumeWS = (notEnd?: boolean) : string => {\n        const [tokenized, tCursor, ws] = tokenizeWhitespace(tokens, cursor);\n        if (tokenized) {\n            cursor = tCursor as number;\n        }\n        if (notEnd && cursor >= count) {\n            throw new ExpressionSyntaxError('unexpected end of expression');\n        }\n        return ws || '';\n    }\n    consumeWS();\n    if (cursor >= count) {\n        return [false];\n    }\n\n    const parts = new SequenceToken({ position: start });\n    while (cursor < count) {\n        const position = tokens[cursor].position;\n        const whitespace = consumeWS();\n        if (cursor >= count) {\n            break;\n        }\n\n        // End of argument\n        if (\n            tokens[cursor].value === ']' ||\n            tokens[cursor].value === ','\n        ) {\n            return [true, cursor, parts.unwrap];\n        }\n\n        // Whitespace is between 'parts' so must be kept\n        if (whitespace !== '') {\n            parts.add(new TextToken({ position, value: whitespace}));\n        }\n\n        // Single-char escape\n        const [eTokenized, eCursor, eResult] = tokenizeEscape(tokens, cursor, '\"$,\\\\`]');\n        if (eTokenized) {\n            parts.add(new TextToken({ position, value: (eResult as GenericToken).value}));\n            cursor = eCursor as number;\n        }\n\n        // Block escape\n        let [tokenized, tCursor, tResult] : [ tokenized: boolean, cursor?: number, result?: LookupToken | IfToken | VariableToken | TextToken | SequenceToken ] = tokenizeBlockEscape(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as SequenceToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // Quoted text\n        [tokenized, tCursor, tResult] = tokenizeQuote(tokens, cursor);\n        if (tokenized) {\n            parts.add(tResult as TextToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // Lookup\n        [tokenized, tCursor, tResult] = tokenizeLookup(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as LookupToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // $if\n        [tokenized, tCursor, tResult] = tokenizeIf(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as IfToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // Variable\n        [tokenized, tCursor, tResult] = tokenizeVariable(tokens, cursor, options);\n        if (tokenized) {\n            parts.add(tResult as VariableToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        // All other situations treat the generic token as plain text\n        parts.add(new TextToken(tokens[cursor]));\n        cursor += 1;\n    }\n\n    throw new ExpressionSyntaxError('unexpected end of arguments list')\n}", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\nimport type IfToken from '../if/token';\nimport type LookupToken from '../lookup/token';\nimport type SequenceToken from '../sequence-token';\nimport type TextToken from '../text/token';\nimport type VariableToken from '../variable/token';\n\nimport ArgumentsToken from './token'\n\nimport tokenizeArgument from './argument';\nimport tokenizeWhitespace from '../whitespace/tokenize';\n\nimport { ExpressionSyntaxError } from '../../errors';\n\n/** Attempts to consume an arguments-bloc from `tokens` starting at `cursor` */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the initial `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<ArgumentsToken> => {\n    const count = tokens.length;\n\n    if (cursor >= count || tokens[cursor].value !== '[') {\n        return [false];\n    }\n\n    const start = tokens[cursor].position;\n    cursor += 1;\n\n    const consumeWS = () => {\n        const [wsRem, wsCursor, wsResult] = tokenizeWhitespace(tokens, cursor);\n        if (wsRem) {\n            cursor = wsCursor as number;\n            return wsResult as string;\n        }\n        return ''\n    }\n    consumeWS();\n\n    const args : Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken> = [];\n    while (cursor < count) {\n        consumeWS();\n        if (cursor >= count) {\n            break;\n        }\n\n        // get next argument\n        const [aTokenized, aCursor, aResult] = tokenizeArgument(tokens, cursor, options);\n        if (!aTokenized) {\n            throw new ExpressionSyntaxError('encountered missing or invalid argument', tokens[cursor].position);\n        }\n        cursor = aCursor as number;\n        args.push(aResult as (LookupToken | IfToken | VariableToken | TextToken | SequenceToken));\n\n        if (cursor >= count) {\n            break;\n        }\n\n        // End of arguments list\n        if (tokens[cursor].value === ']') {\n            return [\n                true,\n                cursor + 1,\n                new ArgumentsToken({\n                    position: start,\n                    value: args\n                })\n            ];\n        }\n\n        if (tokens[cursor].value !== ',') {\n            throw new ExpressionSyntaxError('expected end of argument', tokens[cursor].position);\n        }\n        cursor += 1;\n    }\n\n\n    if (cursor >= count) {\n        throw new ExpressionSyntaxError('unexpected end of expression');\n    }\n\n    throw new ExpressionSyntaxError('unexpected end of arguments list', tokens[cursor].position);\n}", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\n\nimport LookupToken from './token';\n\nimport tokenizeArguments from '../arguments/tokenize';\n\n/** Attempts to tokenize a Lookup from `tokens` starting at `cursor */\nexport default (\n\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to the `tokenize()` call */\n    options: TokenizeOptions\n) : TokenizeResult<LookupToken> => {\n    const count = tokens.length;\n    if (\n        cursor + 1 >= count ||\n        tokens[cursor].value !== '$'\n    ) {\n        return [false];\n    }\n\n    const start = tokens[cursor].position;\n\n    cursor += 1;\n\n    // Determine prefix\n    let prefixAccumulator = ''\n    let prefix = '';\n    let tmpCursor = cursor;\n    while (tmpCursor < count) {\n        const val = tokens[tmpCursor].value;\n        if (!/[\\x21-\\x47\\x3A-\\x40\\x5B\\x5D-\\x60\\x7B-\\x7E]/.test(val)) {\n            break;\n        }\n        prefixAccumulator += val;\n        tmpCursor += 1;\n\n        if (options.lookups.has(prefixAccumulator)) {\n            prefix = prefixAccumulator;\n            cursor = tmpCursor;\n        }\n    }\n    if (cursor >= count || !prefix) {\n        return [false];\n    }\n\n    // Determine name\n    let name = '';\n    if (!/^[a-z]/i.test(tokens[cursor].value)) {\n        return [false];\n    }\n\n    while (\n        cursor < count && (\n            /^[a-z\\d]+$/i.test(tokens[cursor].value) ||\n            tokens[cursor].value === '_' ||\n            tokens[cursor].value === '-'\n        )\n    ) {\n        name += tokens[cursor].value;\n        cursor += 1;\n    }\n    if (!/^[a-z][a-z\\d_-]+/i.test(name)) {\n        return [false];\n    }\n\n    let args;\n    const [tokenized, tokenizedCursor, tokenizedResult] = tokenizeArguments(tokens, cursor, options);\n    if (tokenized) {\n        cursor = tokenizedCursor;\n        args = tokenizedResult;\n    }\n\n    return [\n        true,\n        cursor,\n        new LookupToken({\n            position: start,\n            prefix,\n            value: name,\n            arguments: args\n        })\n    ];\n}", "import type { GenericToken, TokenizeOptions, TokenizeResult } from '../../types';\nimport type IfToken from '../if/token';\nimport type LookupToken from '../lookup/token';\nimport type VariableToken from '../variable/token';\n\nimport SequenceToken from '../sequence-token';\nimport TextToken from './token';\n\nimport tokenizeLookup from '../lookup/tokenize';\nimport tokenizeIf from '../if/tokenize';\nimport tokenizeVariable from '../variable/tokenize';\n\n/** Attempts to consume a block-escape sequence from `tokens` starting at `cursor` */\nexport default (\n    /** List of generic tokens to be tokenized into Token instances */\n    tokens: GenericToken[],\n\n    /** Current position within the tokens list */\n    cursor: number,\n\n    /** Options passed to initial tokenize() call */\n    options: TokenizeOptions\n) : TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken> => {\n    const count = tokens.length;\n    if ((cursor + 1) >= count || tokens[cursor].value !== '``') {\n        return [false];\n    }\n\n    cursor += 1;\n    const result = new SequenceToken({ position: tokens[cursor].position });\n\n    while (cursor < count) {\n        if (tokens[cursor].value === '``') {\n            return [true, cursor + 1, result.unwrap];\n        }\n\n        let [tokenized, tCursor, tResult] : [success: boolean, cursor?: number, result?: LookupToken | IfToken | VariableToken] = tokenizeLookup(tokens, cursor,  options);\n        if (tokenized) {\n            result.add(tResult as LookupToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        [tokenized, tCursor, tResult] = tokenizeIf(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as IfToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        [tokenized, tCursor, tResult] = tokenizeVariable(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as VariableToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        result.add(new TextToken(tokens[cursor]));\n        cursor += 1;\n    }\n\n    return [false];\n}", "import type { GenericToken, TokenizeOptions } from '../../types';\nimport type IfToken from '../if/token';\nimport type LookupToken from '../lookup/token';\nimport type SequenceToken from '../sequence-token';\nimport type VariableToken from '../variable/token';\n\nimport { tokenize as split } from '../../misc/split';\n\nimport RootToken from './token';\nimport TextToken from '../text/token';\n\nimport tokenizeBlockEscape from '../text/block';\nimport tokenizeEscape from '../text/escape';\nimport tokenizeIf from '../if/tokenize';\nimport tokenizeLookup from '../lookup/tokenize';\nimport tokenizeVariable from '../variable/tokenize';\n\n/** Attempts to tokenize the given expression into Token instances */\nexport default (\n    /** Options passed to initial tokenize() call */\n    options: TokenizeOptions\n) : RootToken => {\n\n    const result = new RootToken(options);\n\n    const tokens = split(options.expression);\n    const count = tokens.length;\n    let cursor = 0;\n\n    while (cursor < count) {\n\n        const [eTokenized, eCursor, eResult] = tokenizeEscape(tokens, cursor);\n        if (eTokenized) {\n            result.add(new TextToken(eResult as GenericToken));\n            cursor = eCursor as number;\n            continue;\n        }\n\n        let [tokenized, tCursor, tResult] : [tokenized: boolean, cursor?: number, result?: LookupToken | IfToken | VariableToken | TextToken | SequenceToken] = tokenizeBlockEscape(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as LookupToken | IfToken | VariableToken | TextToken | SequenceToken);\n            cursor = tCursor as number;\n            continue;\n        }\n\n        [tokenized, tCursor, tResult] = tokenizeLookup(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as LookupToken);\n            cursor = tCursor as number;\n            continue\n        }\n\n        [tokenized, tCursor, tResult] = tokenizeIf(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as IfToken);\n            cursor = tCursor as number;\n            continue\n        }\n\n        [tokenized, tCursor, tResult] = tokenizeVariable(tokens, cursor, options);\n        if (tokenized) {\n            result.add(tResult as VariableToken);\n            cursor = tCursor as number;\n            continue\n        }\n        result.add(new TextToken(tokens[cursor]));\n        cursor += 1;\n    }\n\n    return result;\n};", "import tokenizeRoot from './parse/root/tokenize';\n\n// because typescript is dumb\nimport { TokenizeOptions, LookupMap, EvaluateOptions, LogicOperatorMap, ComparisonOperatorMap } from './types';\nexport { TokenizeOptions, LookupMap, EvaluateOptions, LogicOperatorMap, ComparisonOperatorMap };\n\n// because typescript is dumb\nimport { default as RootToken, RootTokenOptions, RootEvaluateOptions } from './parse/root/token'\nexport { RootToken, RootTokenOptions, RootEvaluateOptions };\n\nexport { default as ArgumentsToken, ArgumentsTokenOptions } from './parse/arguments/token';\nexport { default as BaseToken, BaseTokenOptions } from './parse/base-token';\nexport { default as ComparisonToken, ComparisonTokenOptions } from './parse/comparison/token';\nexport { default as IfToken, IfTokenOptions } from './parse/if/token';\nexport { default as LogicToken, LogicTokenOptions } from './parse/logic/token';\nexport { default as LookupToken, LookupTokenOptions } from './parse/lookup/token';\nexport { default as SequenceToken } from './parse/sequence-token';\nexport { default as TextToken, TextTokenOptions } from './parse/text/token';\nexport { default as VariableToken, VariableTokenOptions } from './parse/variable/token';\nexport { ExpressionError, ExpressionArgumentsError, ExpressionSyntaxError, ExpressionVariableError } from './errors';\n\n/** Parses a string expression into a usable Expressionish-Token instance */\nexport const tokenize = (\n    /** Options to use during tokenization */\n    options: TokenizeOptions\n) : RootToken => {\n    if (options == null) {\n        throw new TypeError('options not specified');\n    }\n\n    // Validate options.variables\n    if (options.variables == null) {\n        throw new TypeError('variables map is null');\n    }\n    if (!(options.variables instanceof Map)) {\n        throw new TypeError('variables map is not a Map instance');\n    }\n\n    // validate options.lookups\n    if (options.lookups == null) {\n        options.lookups = new Map() as LookupMap;\n    } else if (!(options.lookups instanceof Map)) {\n        throw new TypeError('lookups option specified but is not a Map instance');\n    }\n\n    // validate options.LogicalOperators\n    if (options.logicalOperators == null) {\n        options.logicalOperators = new Map() as LogicOperatorMap;\n    } else if (!(options.logicalOperators instanceof Map)) {\n        throw new TypeError('logical operators options specified but is not a Map instance');\n    }\n\n    if (options.comparisonOperators == null) {\n        options.comparisonOperators = new Map() as ComparisonOperatorMap;\n    } else if (!(options.comparisonOperators instanceof Map)) {\n        throw new TypeError('comparison operators options specified but is not a Map instance');\n    }\n\n    // validate options.expression\n    if (options.expression == null) {\n        throw new TypeError('expression not specified');\n    }\n    if (typeof options.expression !== 'string') {\n        throw new TypeError('expression must be a string');\n    }\n\n    // tokenize the expression\n    return tokenizeRoot(options);\n}\n\n/** Parses then evaluates expression text */\nexport const evaluate = async (\n    /** Options passed to the parser and evaluator */\n    options: EvaluateOptions\n) => tokenize(options).evaluate({\n    onlyValidate: options.onlyValidate,\n    preeval: options.preeval,\n    data: options.data\n});"],
+  "mappings": "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",
+  "names": ["HIGH_SURROGATE_START", "HIGH_SURROGATE_END", "LOW_SURROGATE_START", "REGIONAL_INDICATOR_START", "REGIONAL_INDICATOR_END", "FITZPATRICK_MODIFIER_START", "FITZPATRICK_MODIFIER_END", "VARIATION_MODIFIER_START", "VARIATION_MODIFIER_END", "DIACRITICAL_MARKS_START", "DIACRITICAL_MARKS_END", "ZWJ", "GRAPHEMS", "betweenInclusive", "value", "lower", "upper", "codePointFromSurrogatePair", "pair", "highOffset", "lowOffset", "tokenize", "input", "asciiPunct", "result", "idx", "inc", "tok", "escaped", "idxInc", "current", "betweenInclusive", "HIGH_SURROGATE_START", "HIGH_SURROGATE_END", "currPair", "codePointFromSurrogatePair", "nextPair", "REGIONAL_INDICATOR_START", "REGIONAL_INDICATOR_END", "FITZPATRICK_MODIFIER_START", "FITZPATRICK_MODIFIER_END", "GRAPHEMS", "VARIATION_MODIFIER_START", "VARIATION_MODIFIER_END", "DIACRITICAL_MARKS_START", "DIACRITICAL_MARKS_END", "ZWJ", "BaseToken", "options", "SequenceToken", "BaseToken", "options", "token", "unwrapped", "prev", "curr", "RootToken", "SequenceToken", "options", "TextToken", "BaseToken", "options", "ExpressionError", "message", "position", "ExpressionArgumentsError", "index", "varname", "ExpressionVariableError", "ExpressionSyntaxError", "character", "LookupToken", "BaseToken", "options", "ExpressionVariableError", "lookup", "variable", "args", "ArgumentsToken", "BaseToken", "options", "item", "escape_default", "tokens", "cursor", "escapeChars", "count", "token", "quote_default", "tokens", "cursor", "count", "start", "text", "TextToken", "tokenized", "tokenizeCursor", "tokenizeResult", "escape_default", "ExpressionSyntaxError", "IfToken", "BaseToken", "options", "result", "toNumber", "data", "v1", "v2", "v1Num", "v2Num", "isStrictEqual", "isTruthy", "operators_default", "ComparisonToken", "BaseToken", "options", "operator", "operators_default", "left", "right", "VariableToken", "BaseToken", "options", "variable", "args", "tokenize_default", "tokens", "cursor", "options", "count", "start", "name", "ExpressionVariableError", "tokenized", "tCursor", "tResult", "VariableToken", "tokenize_default", "tokens", "cursor", "count", "ws", "index", "tokenizeOperator", "tokens", "cursor", "options", "count", "operator", "operators", "operatorAccumulator", "tmpCursor", "wsRem", "wsCursor", "tokenize_default", "mergedOperators", "operators_default", "key", "tokOpOptions", "start", "consumeWS", "wsResult", "left", "SequenceToken", "right", "position", "ws", "opTokenized", "opCursor", "opResult", "ExpressionSyntaxError", "parts", "TextToken", "eTokenized", "eCursor", "eResult", "escape_default", "tokenized", "tCursor", "tResult", "quote_default", "ExpressionArgumentsError", "ComparisonToken", "not", "data", "arg", "operators_default", "args", "item", "LogicToken", "BaseToken", "options", "operator", "operators_default", "args", "tokenizeLogicOperator", "tokens", "cursor", "options", "count", "start", "mergedOperators", "operators_default", "operator", "key", "ExpressionSyntaxError", "argsStart", "consumeWS", "notEnd", "tokenized", "tCursor", "ws", "tokenize_default", "args", "tokenize", "tResult", "ExpressionArgumentsError", "opDef", "LogicToken", "ArgumentsToken", "tokenize_default", "tokens", "cursor", "options", "count", "start", "ExpressionArgumentsError", "consumeWS", "notEnd", "tokenized", "tCursor", "ws", "ExpressionSyntaxError", "tokenize", "tResult", "condition", "wtTokenize", "wtCursor", "whenTrue", "argument_default", "wfTokenize", "wfCursor", "whenFalse", "IfToken", "argument_default", "tokens", "cursor", "options", "count", "start", "consumeWS", "notEnd", "tokenized", "tCursor", "ws", "tokenize_default", "ExpressionSyntaxError", "parts", "SequenceToken", "position", "whitespace", "TextToken", "eTokenized", "eCursor", "eResult", "escape_default", "tResult", "block_default", "quote_default", "tokenize_default", "tokens", "cursor", "options", "count", "start", "consumeWS", "wsRem", "wsCursor", "wsResult", "args", "aTokenized", "aCursor", "aResult", "argument_default", "ExpressionSyntaxError", "ArgumentsToken", "tokenize_default", "tokens", "cursor", "options", "count", "start", "prefixAccumulator", "prefix", "tmpCursor", "val", "name", "args", "tokenized", "tokenizedCursor", "tokenizedResult", "LookupToken", "block_default", "tokens", "cursor", "options", "count", "result", "SequenceToken", "tokenized", "tCursor", "tResult", "tokenize_default", "TextToken", "tokenize_default", "options", "result", "RootToken", "tokens", "tokenize", "count", "cursor", "eTokenized", "eCursor", "eResult", "escape_default", "TextToken", "tokenized", "tCursor", "tResult", "block_default", "tokenize", "options", "tokenize_default", "evaluate"]
+}

package/package.json

@@ -1,15 +1,15 @@
 {
     "name": "expressionish",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "license": "ISC",
     "repository": {
         "type": "git",
         "url": "https://github.com/SReject/expressionish"
     },
     "files": [
-        "./dist/index.js",
-        "./dist/index.d.ts",
-        "./dist/index.js.map"
+        "./dist/expressionish.mjs",
+        "./dist/expressionish.d.ts",
+        "./dist/expressionish.mjs.map"
     ],
     "type": "module",
     "exports": {