@mojir/lits 2.1.38 → 2.1.41

package/dist/modules/src/evaluator/ContextStack.d.ts

@@ -0,0 +1,29 @@
+import type { Any } from '../interface';
+import type { ContextParams } from '../Lits/Lits';
+import type { LitsModule } from '../builtin/modules/interface';
+import { type NativeJsModule, type SymbolNode, type UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { Context, LookUpResult } from './interface';
+export type ContextStack = ContextStackImpl;
+export declare class ContextStackImpl {
+    private contexts;
+    globalContext: Context;
+    private values?;
+    private nativeJsFunctions?;
+    private modules;
+    constructor({ contexts, values: hostValues, nativeJsFunctions, modules, }: {
+        contexts: Context[];
+        values?: Record<string, unknown>;
+        nativeJsFunctions?: NativeJsModule;
+        modules?: Map<string, LitsModule>;
+    });
+    getModule(name: string): LitsModule | undefined;
+    create(context: Context): ContextStack;
+    new(context: Context): ContextStack;
+    exportValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
+    addValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
+    getValue(name: string): unknown;
+    lookUp(node: UserDefinedSymbolNode): LookUpResult;
+    evaluateSymbol(node: SymbolNode): Any;
+}
+export declare function createContextStack(params?: ContextParams, modules?: Map<string, LitsModule>): ContextStack;

package/dist/modules/src/evaluator/functionExecutors.d.ts

@@ -0,0 +1,11 @@
+import type { Any, Arr } from '../interface';
+import type { LitsFunctionType } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { ContextStack } from './ContextStack';
+import type { EvaluateNode, ExecuteFunction } from './interface';
+type FunctionExecutors = Record<LitsFunctionType, (fn: any, params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, helpers: {
+    evaluateNode: EvaluateNode;
+    executeFunction: ExecuteFunction;
+}) => Any>;
+export declare const functionExecutors: FunctionExecutors;
+export {};

package/dist/modules/src/evaluator/index.d.ts

@@ -0,0 +1,5 @@
+import type { Any } from '../interface';
+import type { Ast, Node } from '../parser/types';
+import type { ContextStack } from './ContextStack';
+export declare function evaluate(ast: Ast, contextStack: ContextStack): Any;
+export declare function evaluateNode(node: Node, contextStack: ContextStack): Any;

package/dist/modules/src/evaluator/interface.d.ts

@@ -0,0 +1,12 @@
+import type { Any, Arr } from '../interface';
+import type { FunctionLike, Node } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { ContextStack } from './ContextStack';
+export interface ContextEntry {
+    value: Any;
+}
+export type Context = Record<string, ContextEntry>;
+export type EvaluateNode = (node: Node, contextStack: ContextStack) => Any;
+export type ExecuteFunction = (fn: FunctionLike, params: Arr, contextStack: ContextStack, sourceCodeInfo?: SourceCodeInfo) => Any;
+export type LookUpResult = ContextEntry | null;
+export declare function isContextEntry(value: unknown): value is ContextEntry;

package/dist/modules/src/full.d.ts

@@ -0,0 +1,14 @@
+import './initReferenceData';
+export * from './index';
+export { allBuiltinModules } from './allModules';
+export { assertModule } from './builtin/modules/assert';
+export { gridModule } from './builtin/modules/grid';
+export { randomModule } from './builtin/modules/random';
+export { vectorModule } from './builtin/modules/vector';
+export { linearAlgebraModule } from './builtin/modules/linearAlgebra';
+export { matrixModule } from './builtin/modules/matrix';
+export { numberTheoryModule } from './builtin/modules/numberTheory';
+export { apiReference, isCustomReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
+export type { Argument, CommonReference, CustomReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
+export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
+export { isApiName, isDataType } from '../reference/api';

package/dist/modules/src/getUndefinedSymbols/index.d.ts

@@ -0,0 +1,7 @@
+import type { Builtin } from '../builtin/interface';
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { EvaluateNode } from '../evaluator/interface';
+import type { Ast, Node } from '../parser/types';
+export type UndefinedSymbols = Set<string>;
+export declare const getUndefinedSymbols: GetUndefinedSymbols;
+export type GetUndefinedSymbols = (ast: Ast | Node[], contextStack: ContextStack, builtin: Builtin, evaluateNode: EvaluateNode) => UndefinedSymbols;

package/dist/modules/src/index.d.ts

@@ -0,0 +1,14 @@
+export { isBuiltinFunction, isLitsFunction, asLitsFunction, assertLitsFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/litsFunction';
+export { type Arity } from './builtin/interface';
+export { type LitsFunction, type NativeJsFunction } from './parser/types';
+export type { Context } from './evaluator/interface';
+export type { Ast } from './parser/types';
+export type { SourceCodeInfo } from './tokenizer/token';
+export type { Token, TokenType } from './tokenizer/token';
+export { normalExpressionKeys, specialExpressionKeys } from './builtin';
+export { Lits } from './Lits/Lits';
+export type { LitsModule } from './builtin/modules/interface';
+export { type LitsError, isLitsError } from './errors';
+export type { ContextParams, FilePathParams, MinifyParams, LitsRuntimeInfo, JsFunction } from './Lits/Lits';
+export { isGrid, isMatrix, isVector } from './typeGuards/annotatedArrays';
+export type { AutoCompleter } from './AutoCompleter/AutoCompleter';

package/dist/modules/src/initReferenceData.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/src/interface.d.ts

@@ -0,0 +1,7 @@
+import type { LitsFunction, RegularExpression } from './parser/types';
+export type Arr = unknown[];
+export type Seq = string | Arr;
+export type Obj = Record<string, unknown>;
+export type Coll = Seq | Obj;
+export type Any = Coll | string | number | boolean | null | LitsFunction | RegularExpression;
+export type UnknownRecord = Record<string, unknown>;

package/dist/modules/src/modules/assert.d.ts

@@ -0,0 +1,2 @@
+export { assertModule } from '../builtin/modules/assert';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/grid.d.ts

@@ -0,0 +1,2 @@
+export { gridModule } from '../builtin/modules/grid';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/linearAlgebra.d.ts

@@ -0,0 +1,2 @@
+export { linearAlgebraModule } from '../builtin/modules/linearAlgebra';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/matrix.d.ts

@@ -0,0 +1,2 @@
+export { matrixModule } from '../builtin/modules/matrix';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/numberTheory.d.ts

@@ -0,0 +1,2 @@
+export { numberTheoryModule } from '../builtin/modules/numberTheory';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/random.d.ts

@@ -0,0 +1,2 @@
+export { randomModule } from '../builtin/modules/random';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/modules/vector.d.ts

@@ -0,0 +1,2 @@
+export { vectorModule } from '../builtin/modules/vector';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/modules/src/parser/Parser.d.ts

@@ -0,0 +1,58 @@
+import type { CondNode } from '../builtin/specialExpressions/cond';
+import type { LambdaNode } from '../builtin/specialExpressions/functions';
+import type { IfNode } from '../builtin/specialExpressions/if';
+import type { SwitchNode } from '../builtin/specialExpressions/switch';
+import type { UnlessNode } from '../builtin/specialExpressions/unless';
+import type { SymbolToken, Token } from '../tokenizer/token';
+import type { TokenStream } from '../tokenizer/tokenize';
+import { type BindingTarget, type Node, type ParseState } from './types';
+type InternalLoopBindingDelimiter = 'let' | 'when' | 'while';
+export declare class Parser {
+    private readonly tokenStream;
+    private parseState;
+    constructor(tokenStream: TokenStream, parseState: ParseState);
+    private peek;
+    private peekSourceCodeInfo;
+    private peekAhead;
+    private advance;
+    parse(): Node[];
+    private parseExpression;
+    asToken(token: Token | undefined): Token;
+    private parseOperand;
+    private parseOperandPart;
+    private parseObject;
+    private parseArray;
+    private parseFunctionCall;
+    parseLambdaFunction(): LambdaNode | null;
+    parseFunctionArguments(): BindingTarget[];
+    private parseShorthandLambdaFunction;
+    private parseOptionalDefaulValue;
+    private parseBindingTarget;
+    private parseLet;
+    private parseBlock;
+    private parseImplicitBlock;
+    private assertImplicitBlockEnd;
+    private isImplicitBlockEnd;
+    private parseLoop;
+    private parseTry;
+    private parseForOrDoseq;
+    private parseForLoopBinding;
+    assertInternalLoopBindingDelimiter(token: Token, symbols: InternalLoopBindingDelimiter[]): void;
+    isInternalLoopBindingDelimiter(token: Token, symbols: InternalLoopBindingDelimiter[]): boolean;
+    private parseBinding;
+    parseIfOrUnless(token: SymbolToken): IfNode | UnlessNode;
+    parseCond(token: SymbolToken): CondNode;
+    parseSwitch(token: SymbolToken): SwitchNode;
+    private isAtEnd;
+    private isAtExpressionEnd;
+    private parseExport;
+    private stringToSymbolNode;
+    stringFromQuotedSymbol(value: string): string;
+    private parseSymbol;
+    private parseReservedSymbol;
+    private parseNumber;
+    private parseDocString;
+    private parseString;
+    private parseRegexpShorthand;
+}
+export {};

package/dist/modules/src/parser/types.d.ts

@@ -0,0 +1,133 @@
+import type { JsFunction } from '../Lits/Lits';
+import type { SpecialExpressionType } from '../builtin';
+import type { Arity } from '../builtin/interface';
+import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
+import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
+import type { Context } from '../evaluator/interface';
+import type { Any, Arr, Coll } from '../interface';
+import type { ReservedSymbol } from '../tokenizer/reservedNames';
+import type { SourceCodeInfo, Token } from '../tokenizer/token';
+import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+export interface ParseState {
+    position: number;
+}
+export type EvaluatedFunction = [BindingTarget[], Node[], Context];
+interface GenericLitsFunction {
+    [FUNCTION_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    functionType: FunctionType;
+    arity: Arity;
+}
+export interface RegularExpression {
+    [REGEXP_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    s: string;
+    f: string;
+}
+export interface NativeJsFunction extends GenericLitsFunction {
+    functionType: 'NativeJsFunction';
+    name: string | undefined;
+    nativeFn: JsFunction;
+    docString: string;
+}
+export declare function isJsFunction(fn: unknown): fn is JsFunction;
+export declare function assertJsFunction(fn: unknown): asserts fn is JsFunction;
+export interface NativeJsModule {
+    [key: string]: NativeJsFunction | NativeJsModule;
+}
+export interface UserDefinedFunction extends GenericLitsFunction {
+    functionType: 'UserDefined';
+    name: string | undefined;
+    evaluatedfunction: EvaluatedFunction;
+    docString: string;
+}
+export interface PartialFunction extends GenericLitsFunction {
+    functionType: 'Partial';
+    function: FunctionLike;
+    params: Arr;
+    placeholders: number[];
+}
+export interface CompFunction extends GenericLitsFunction {
+    functionType: 'Comp';
+    params: Arr;
+}
+export interface ConstantlyFunction extends GenericLitsFunction {
+    functionType: 'Constantly';
+    value: Any;
+}
+export interface JuxtFunction extends GenericLitsFunction {
+    functionType: 'Juxt';
+    params: Arr;
+}
+export interface ComplementFunction extends GenericLitsFunction {
+    functionType: 'Complement';
+    function: FunctionLike;
+}
+export interface EveryPredFunction extends GenericLitsFunction {
+    functionType: 'EveryPred';
+    params: Arr;
+}
+export interface SomePredFunction extends GenericLitsFunction {
+    functionType: 'SomePred';
+    params: Arr;
+}
+export interface FNullFunction extends GenericLitsFunction {
+    functionType: 'Fnull';
+    function: FunctionLike;
+    params: Arr;
+}
+export interface NormalBuiltinFunction extends GenericLitsFunction {
+    functionType: 'Builtin';
+    normalBuiltinSymbolType: number;
+    name: string;
+}
+export interface SpecialBuiltinFunction extends GenericLitsFunction {
+    functionType: 'SpecialBuiltin';
+    specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['??'];
+}
+export interface ModuleFunction extends GenericLitsFunction {
+    functionType: 'Module';
+    moduleName: string;
+    functionName: string;
+}
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | ModuleFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export type LitsFunctionType = LitsFunction['functionType'];
+export type FunctionLike = LitsFunction | Coll | number;
+export type DebugData = {
+    token: Token;
+    nameToken?: Token;
+};
+export type Node<T extends NodeType = NodeType, Payload = unknown> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
+export type SpreadNode = Node<typeof NodeTypes.Spread, Node>;
+export type NumberNode = Node<typeof NodeTypes.Number, number>;
+export type StringNode = Node<typeof NodeTypes.String, string>;
+export type UserDefinedSymbolNode = Node<typeof NodeTypes.UserDefinedSymbol, string>;
+export type NormalBuiltinSymbolNode = Node<typeof NodeTypes.NormalBuiltinSymbol, number>;
+export type SpecialBuiltinSymbolNode = Node<typeof NodeTypes.SpecialBuiltinSymbol, SpecialExpressionType>;
+export type SymbolNode = UserDefinedSymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;
+export type ReservedSymbolNode = Node<typeof NodeTypes.ReservedSymbol, ReservedSymbol>;
+export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = Node<typeof NodeTypes.SpecialExpression, T>;
+export type NormalExpressionNodeWithName = Node<typeof NodeTypes.NormalExpression, [NormalBuiltinSymbolNode | UserDefinedSymbolNode, Node[]]>;
+export type NormalExpressionNodeExpression = Node<typeof NodeTypes.NormalExpression, [Node, Node[]]>;
+export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
+export declare const bindingTargetTypes: {
+    readonly symbol: 11;
+    readonly rest: 12;
+    readonly object: 13;
+    readonly array: 14;
+};
+export type BindingTargetType = typeof bindingTargetTypes[keyof typeof bindingTargetTypes];
+type GenericTarget<T extends BindingTargetType, Payload extends unknown[]> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type SymbolBindingTarget = GenericTarget<typeof bindingTargetTypes.symbol, [SymbolNode, Node | undefined]>;
+export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, Node | undefined]>;
+export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, Node | undefined]>;
+export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], Node | undefined]>;
+export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget;
+export type BindingNode = Node<typeof NodeTypes.Binding, [BindingTarget, Node]>;
+type AstBody = Node[];
+export interface Ast {
+    body: AstBody;
+    hasDebugData: boolean;
+}
+export {};

package/dist/modules/src/symbolPatterns.d.ts

@@ -0,0 +1,2 @@
+export declare const polishSymbolCharacterClass = "[\\w@%^?=!$<>+*/:&|~-]";
+export declare const polishSymbolFirstCharacterClass = "[a-zA-Z_@%^?=!$<>+*/&|~-]";

package/dist/modules/src/testFramework/index.d.ts

@@ -0,0 +1,14 @@
+export interface RunTestParams {
+    testPath: string;
+    testNamePattern?: RegExp;
+}
+export interface TestResult {
+    /**
+     * Test report
+     * http://testanything.org/
+     */
+    tap: string;
+    success: boolean;
+}
+export declare function runTest({ testPath: filePath, testNamePattern }: RunTestParams): TestResult;
+export declare function getErrorYaml(error: unknown): string;

package/dist/modules/src/tokenizer/minifyTokenStream.d.ts

@@ -0,0 +1,4 @@
+import type { TokenStream } from './tokenize';
+export declare function minifyTokenStream(tokenStream: TokenStream, { removeWhiteSpace }: {
+    removeWhiteSpace: boolean;
+}): TokenStream;

package/dist/modules/src/tokenizer/operators.d.ts

@@ -0,0 +1,12 @@
+declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>"];
+declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>", "?", ":", "->", "...", ".", ",", "=", ":", ";"];
+export declare function isFunctionOperator(operator: string): boolean;
+export type SymbolicBinaryOperator = typeof binaryOperators[number];
+export type SymbolicOperator = typeof symbolicOperators[number];
+export declare function isBinaryOperator(operator: string): operator is SymbolicBinaryOperator;
+export declare function assertBinaryOperator(operator: string): asserts operator is SymbolicBinaryOperator;
+export declare function asBinaryOperator(operator: string): SymbolicBinaryOperator;
+export declare function isSymbolicOperator(operator: string): operator is SymbolicOperator;
+export declare function assertSymbolicOperator(operator: string): asserts operator is SymbolicOperator;
+export declare function asSymbolicOperator(operator: string): SymbolicOperator;
+export {};

package/dist/modules/src/tokenizer/reservedNames.d.ts

@@ -0,0 +1,66 @@
+export declare const numberReservedSymbolRecord: {
+    readonly E: number;
+    readonly '-E': number;
+    readonly ε: number;
+    readonly '-\u03B5': number;
+    readonly PI: number;
+    readonly '-PI': number;
+    readonly π: number;
+    readonly '-\u03C0': number;
+    readonly PHI: number;
+    readonly '-PHI': number;
+    readonly φ: number;
+    readonly '-\u03C6': number;
+    readonly POSITIVE_INFINITY: number;
+    readonly '\u221E': number;
+    readonly NEGATIVE_INFINITY: number;
+    readonly '-\u221E': number;
+    readonly MAX_SAFE_INTEGER: number;
+    readonly MIN_SAFE_INTEGER: number;
+    readonly MAX_VALUE: number;
+    readonly MIN_VALUE: number;
+    readonly NaN: number;
+};
+export declare const reservedSymbolRecord: {
+    readonly E: number;
+    readonly '-E': number;
+    readonly ε: number;
+    readonly '-\u03B5': number;
+    readonly PI: number;
+    readonly '-PI': number;
+    readonly π: number;
+    readonly '-\u03C0': number;
+    readonly PHI: number;
+    readonly '-PHI': number;
+    readonly φ: number;
+    readonly '-\u03C6': number;
+    readonly POSITIVE_INFINITY: number;
+    readonly '\u221E': number;
+    readonly NEGATIVE_INFINITY: number;
+    readonly '-\u221E': number;
+    readonly MAX_SAFE_INTEGER: number;
+    readonly MIN_SAFE_INTEGER: number;
+    readonly MAX_VALUE: number;
+    readonly MIN_VALUE: number;
+    readonly NaN: number;
+    readonly true: true;
+    readonly false: false;
+    readonly null: null;
+    readonly do: null;
+    readonly else: null;
+    readonly case: null;
+    readonly each: null;
+    readonly in: null;
+    readonly when: null;
+    readonly while: null;
+    readonly catch: null;
+    readonly function: null;
+    readonly export: null;
+    readonly as: null;
+    readonly then: null;
+    readonly end: null;
+    readonly _: null;
+};
+export type ReservedSymbol = keyof typeof reservedSymbolRecord;
+export declare function isReservedSymbol(symbol: string): symbol is keyof typeof reservedSymbolRecord;
+export declare function isNumberReservedSymbol(symbol: string): symbol is keyof typeof numberReservedSymbolRecord;

package/dist/modules/src/tokenizer/token.d.ts

@@ -0,0 +1,86 @@
+import type { ReservedSymbol } from './reservedNames';
+import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "Error", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "Shebang", "String", "Symbol", "Whitespace"];
+export type TokenType = typeof tokenTypes[number];
+declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
+export type ModifierName = typeof modifierNames[number];
+type GenericToken<T extends TokenType, V extends string = string> = [T, V] | [T, V, SourceCodeInfo];
+export type ErrorToken = ['Error', string, SourceCodeInfo | undefined, string];
+export type LBraceToken = GenericToken<'LBrace', '{'>;
+export type LBracketToken = GenericToken<'LBracket', '['>;
+export type LParenToken = GenericToken<'LParen', '('>;
+export type RBraceToken = GenericToken<'RBrace', '}'>;
+export type RBracketToken = GenericToken<'RBracket', ']'>;
+export type RParenToken = GenericToken<'RParen', ')'>;
+export type BasePrefixedNumberToken = GenericToken<'BasePrefixedNumber'>;
+export type MultiLineCommentToken = GenericToken<'MultiLineComment'>;
+export type NumberToken = GenericToken<'Number'>;
+export type OperatorToken<T extends SymbolicOperator = SymbolicOperator> = GenericToken<'Operator', T>;
+export type RegexpShorthandToken = GenericToken<'RegexpShorthand'>;
+export type ReservedSymbolToken<T extends ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
+export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
+export type ShebangToken = GenericToken<'Shebang'>;
+export type StringToken = GenericToken<'String'>;
+export type DocStringToken = GenericToken<'DocString'>;
+export type SymbolToken<T extends string = string> = GenericToken<'Symbol', T>;
+export type WhitespaceToken = GenericToken<'Whitespace'>;
+export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | DocStringToken | ErrorToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | ShebangToken | StringToken | SymbolToken | WhitespaceToken;
+export type TokenDescriptor<T extends Token> = [length: number, token?: T];
+export interface SourceCodeInfo {
+    position: {
+        line: number;
+        column: number;
+    };
+    code: string;
+    filePath?: string;
+}
+export declare function isSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): token is SymbolToken<T>;
+export declare function assertSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): asserts token is SymbolToken<T>;
+export declare function asSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): SymbolToken<T>;
+export declare function isReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): token is ReservedSymbolToken<T>;
+export declare function assertReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): asserts token is ReservedSymbolToken<T>;
+export declare function asReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): ReservedSymbolToken<T>;
+export declare function isShebangToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isSingleLineCommentToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isMultiLineCommentToken(token: Token | undefined): token is MultiLineCommentToken;
+export declare function isOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): token is OperatorToken<T>;
+export declare function assertOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): asserts token is OperatorToken<T>;
+export declare function asOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): OperatorToken<T>;
+export declare function isWhitespaceToken(token: Token | undefined): token is WhitespaceToken;
+export declare function assertWhitespaceToken(token: Token | undefined): asserts token is WhitespaceToken;
+export declare function asWhitespaceToken(token: Token | undefined): WhitespaceToken;
+export declare function isNumberToken(token: Token | undefined): token is NumberToken;
+export declare function assertNumberToken(token: Token | undefined): asserts token is NumberToken;
+export declare function asNumberToken(token: Token | undefined): NumberToken;
+export declare function isBasePrefixedNumberToken(token: Token | undefined): token is BasePrefixedNumberToken;
+export declare function assertBasePrefixedNumberToken(token: Token | undefined): asserts token is BasePrefixedNumberToken;
+export declare function asBasePrefixedNumberToken(token: Token | undefined): BasePrefixedNumberToken;
+export declare function isLParenToken(token: Token | undefined): token is LParenToken;
+export declare function assertLParenToken(token: Token | undefined): asserts token is LParenToken;
+export declare function asLParenToken(token: Token | undefined): LParenToken;
+export declare function isRParenToken(token: Token | undefined): token is RParenToken;
+export declare function assertRParenToken(token: Token | undefined): asserts token is RParenToken;
+export declare function asRParenToken(token: Token | undefined): RParenToken;
+export declare function isLBracketToken(token: Token | undefined): token is LBracketToken;
+export declare function assertLBracketToken(token: Token | undefined): asserts token is LBracketToken;
+export declare function asLBracketToken(token: Token | undefined): LBracketToken;
+export declare function isRBracketToken(token: Token | undefined): token is RBracketToken;
+export declare function assertRBracketToken(token: Token | undefined): asserts token is RBracketToken;
+export declare function asRBracketToken(token: Token | undefined): RBracketToken;
+export declare function isLBraceToken(token: Token | undefined): token is LBraceToken;
+export declare function assertLBraceToken(token: Token | undefined): asserts token is LBraceToken;
+export declare function asLBraceToken(token: Token | undefined): LBraceToken;
+export declare function isRBraceToken(token: Token | undefined): token is RBraceToken;
+export declare function assertRBraceToken(token: Token | undefined): asserts token is RBraceToken;
+export declare function asRBraceToken(token: Token | undefined): RBraceToken;
+export declare function isStringToken(token: Token | undefined): token is StringToken;
+export declare function assertStringToken(token: Token | undefined): asserts token is StringToken;
+export declare function asStringToken(token: Token | undefined): StringToken;
+export declare function isDocStringToken(token: Token | undefined): token is DocStringToken;
+export declare function isRegexpShorthandToken(token: Token | undefined): token is RegexpShorthandToken;
+export declare function assertRegexpShorthandToken(token: Token | undefined): asserts token is RegexpShorthandToken;
+export declare function asRegexpShorthandToken(token: Token | undefined): RegexpShorthandToken;
+export declare function isA_BinaryOperatorToken(token: Token | undefined): token is OperatorToken<SymbolicBinaryOperator>;
+export declare function assertA_BinaryOperatorToken(token: Token | undefined): asserts token is OperatorToken<SymbolicBinaryOperator>;
+export declare function asA_BinaryOperatorToken(token: Token | undefined): OperatorToken<SymbolicBinaryOperator>;
+export {};

package/dist/modules/src/tokenizer/tokenize.d.ts

@@ -0,0 +1,8 @@
+import type { FilePathParams } from '../Lits/Lits';
+import type { Token } from './token';
+export interface TokenStream {
+    tokens: Token[];
+    hasDebugData: boolean;
+    filePath?: string;
+}
+export declare function tokenize(input: string, debug: boolean, filePath: FilePathParams['filePath']): TokenStream;

package/dist/modules/src/tokenizer/tokenizers.d.ts

@@ -0,0 +1,14 @@
+import type { BasePrefixedNumberToken, DocStringToken, ErrorToken, LBraceToken, LBracketToken, LParenToken, MultiLineCommentToken, NumberToken, OperatorToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, ReservedSymbolToken, SingleLineCommentToken, StringToken, SymbolToken, Token, TokenDescriptor, WhitespaceToken } from './token';
+export type Tokenizer<T extends Token> = (input: string, position: number) => TokenDescriptor<T | ErrorToken>;
+export declare const NO_MATCH: TokenDescriptor<never>;
+export declare const tokenizeDocString: Tokenizer<DocStringToken>;
+export declare const tokenizeWhitespace: Tokenizer<WhitespaceToken>;
+export declare const tokenizeNumber: Tokenizer<NumberToken>;
+export declare const tokenizeBasePrefixedNumber: Tokenizer<BasePrefixedNumberToken>;
+export declare const tokenizeSymbol: Tokenizer<SymbolToken>;
+export declare const tokenizeReservedSymbolToken: Tokenizer<ReservedSymbolToken>;
+export declare const tokenizeOperator: Tokenizer<OperatorToken>;
+export declare const tokenizeMultiLineComment: Tokenizer<MultiLineCommentToken>;
+export declare const tokenizeShebang: Tokenizer<SingleLineCommentToken>;
+export declare const tokenizeSingleLineComment: Tokenizer<SingleLineCommentToken>;
+export declare const tokenizers: [Tokenizer<WhitespaceToken>, Tokenizer<MultiLineCommentToken>, Tokenizer<SingleLineCommentToken>, Tokenizer<ReservedSymbolToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<DocStringToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];

package/dist/modules/src/transformer/index.d.ts

@@ -0,0 +1,2 @@
+import type { TokenStream } from '../tokenizer/tokenize';
+export declare function transformSymbolTokens(tokenStram: TokenStream, transformer: (symbol: string) => string): TokenStream;

package/dist/modules/src/typeGuards/annotatedArrays.d.ts

@@ -0,0 +1,16 @@
+import type { Any } from '../interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function annotate<T>(value: T): T;
+export declare function isVector(vector: unknown): vector is number[];
+export declare function assertVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function is2dVector(vector: unknown): vector is [number, number];
+export declare function assert2dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number];
+export declare function is3dVector(vector: unknown): vector is [number, number, number];
+export declare function assert3dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number, number];
+export declare function assertNonEmptyVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function isGrid(grid: unknown): grid is unknown[][];
+export declare function assertGrid(grid: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts grid is Any[][];
+export declare function isMatrix(matrix: unknown): matrix is number[][];
+export declare function assertMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function assertSquareMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function isSquareMatrix(matrix: unknown): matrix is number[][];

package/dist/modules/src/typeGuards/array.d.ts

@@ -0,0 +1,9 @@
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function asArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): unknown[];
+export declare function assertArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is unknown[];
+export declare function isStringArray(value: unknown): value is string[];
+export declare function asStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];
+export declare function isCharArray(value: unknown): value is string[];
+export declare function asCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];

package/dist/modules/src/typeGuards/astNode.d.ts

@@ -0,0 +1,20 @@
+import type { ExpressionNode, Node, NormalBuiltinSymbolNode, NormalExpressionNode, NormalExpressionNodeWithName, SpecialBuiltinSymbolNode, SpreadNode, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isSymbolNode(node: Node): node is SymbolNode;
+export declare function asSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): SymbolNode;
+export declare function assertSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is SymbolNode;
+export declare function isUserDefinedSymbolNode(node: Node): node is UserDefinedSymbolNode;
+export declare function asUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): UserDefinedSymbolNode;
+export declare function assertUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is UserDefinedSymbolNode;
+export declare function isNormalBuiltinSymbolNode(node: Node): node is NormalBuiltinSymbolNode;
+export declare function isSpecialBuiltinSymbolNode(node: Node): node is SpecialBuiltinSymbolNode;
+export declare function isNormalExpressionNode(node: Node): node is NormalExpressionNode;
+export declare function asNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
+export declare function assertNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNode;
+export declare function isNormalExpressionNodeWithName(node: Node): node is NormalExpressionNodeWithName;
+export declare function asNormalExpressionNodeWithName(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNodeWithName;
+export declare function assertNormalExpressionNodeWithName(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNodeWithName;
+export declare function isExpressionNode(node: Node): node is ExpressionNode;
+export declare function asExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): ExpressionNode;
+export declare function assertExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is ExpressionNode;
+export declare function isSpreadNode(node: Node): node is SpreadNode;

package/dist/modules/src/typeGuards/index.d.ts

@@ -0,0 +1,8 @@
+import type { UnknownRecord } from '../interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isNonUndefined<T>(value: T | undefined): value is T;
+export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;
+export declare function assertNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): asserts value is T;
+export declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
+export declare function assertUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UnknownRecord;
+export declare function asUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): UnknownRecord;