@mojir/lits 2.2.2-alpha.6 → 2.2.3

package/dist/modules/src/builtin/specialExpressions/unless.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type UnlessNode = SpecialExpressionNode<[typeof specialExpressionTypes['unless'], [AstNode, AstNode, AstNode?]]>;
+export declare const unlessSpecialExpression: BuiltinSpecialExpression<Any, UnlessNode>;

package/dist/modules/src/builtin/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { AstNode, BindingTarget } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { Builtin } from './interface';
+export type Function = [BindingTarget[], AstNode[]];
+export declare function assertNameNotDefined<T>(name: T, contextStack: ContextStack, builtin: Builtin, sourceCodeInfo?: SourceCodeInfo): asserts name is T;

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

@@ -0,0 +1,19 @@
+export declare const NodeTypes: {
+    readonly Number: 1;
+    readonly String: 2;
+    readonly NormalExpression: 3;
+    readonly SpecialExpression: 4;
+    readonly UserDefinedSymbol: 5;
+    readonly NormalBuiltinSymbol: 6;
+    readonly SpecialBuiltinSymbol: 7;
+    readonly ReservedSymbol: 8;
+    readonly Binding: 9;
+    readonly Spread: 10;
+};
+export type NodeType = typeof NodeTypes[keyof typeof NodeTypes];
+export declare function getNodeTypeName(type: NodeType): keyof typeof NodeTypes;
+export declare function isNodeType(type: unknown): type is NodeType;
+declare const functionTypes: readonly ["UserDefined", "Partial", "Comp", "Constantly", "Juxt", "Complement", "EveryPred", "SomePred", "Fnull", "Builtin", "SpecialBuiltin", "NativeJsFunction", "Module"];
+export type FunctionType = typeof functionTypes[number];
+export declare function isFunctionType(type: unknown): type is FunctionType;
+export {};

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

@@ -0,0 +1,24 @@
+import type { Arr } from './interface';
+import type { SourceCodeInfo } from './tokenizer/token';
+export declare class RecurSignal extends Error {
+    params: Arr;
+    constructor(params: Arr);
+}
+export declare class LitsError extends Error {
+    readonly sourceCodeInfo?: SourceCodeInfo;
+    readonly shortMessage: string;
+    constructor(err: unknown, sourceCodeInfo: SourceCodeInfo | undefined);
+    getCodeMarker(): string | undefined;
+}
+export declare class UserDefinedError extends LitsError {
+    userMessage: string;
+    constructor(message: string, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class AssertionError extends LitsError {
+    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class UndefinedSymbolError extends LitsError {
+    symbol: string;
+    constructor(symbolName: string, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare function isLitsError(error: unknown): error is LitsError;

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, AstNode } from '../parser/types';
+import type { ContextStack } from './ContextStack';
+export declare function evaluate(ast: Ast, contextStack: ContextStack): Any;
+export declare function evaluateNode(node: AstNode, contextStack: ContextStack): Any;

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

@@ -0,0 +1,13 @@
+import type { Any, Arr } from '../interface';
+import type { AstNode, FunctionLike } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { ContextStack } from './ContextStack';
+interface ContextEntry {
+    value: Any;
+}
+export type Context = Record<string, ContextEntry>;
+export type EvaluateNode = (node: AstNode, 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;
+export {};

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

@@ -0,0 +1,17 @@
+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/linear-algebra';
+export { matrixModule } from './builtin/modules/matrix';
+export { numberTheoryModule } from './builtin/modules/number-theory';
+export { mathUtilsModule } from './builtin/modules/math';
+export { functionalUtilsModule } from './builtin/modules/functional';
+export { bitwiseUtilsModule } from './builtin/modules/bitwise';
+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, AstNode } from '../parser/types';
+export type UndefinedSymbols = Set<string>;
+export declare const getUndefinedSymbols: GetUndefinedSymbols;
+export type GetUndefinedSymbols = (ast: Ast | AstNode[], 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/bitwise.d.ts

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

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

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

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

@@ -0,0 +1,2 @@
+export { functionalUtilsModule } from '../builtin/modules/functional';
+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/linear-algebra.d.ts

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

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

@@ -0,0 +1,2 @@
+export { mathUtilsModule } from '../builtin/modules/math';
+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/number-theory.d.ts

@@ -0,0 +1,2 @@
+export { numberTheoryModule } from '../builtin/modules/number-theory';
+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/sequence.d.ts

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

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

@@ -0,0 +1,2 @@
+export { stringUtilsModule } from '../builtin/modules/string';
+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/ParserContext.d.ts

@@ -0,0 +1,20 @@
+import type { SourceCodeInfo, Token } from '../tokenizer/token';
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { AstNode } from './types';
+export declare class ParserContext {
+    private readonly tokens;
+    private position;
+    private storedPosition;
+    parseExpression: (precedence?: number, moduleScope?: boolean) => AstNode;
+    constructor(tokenStream: TokenStream);
+    advance(): void;
+    tryPeek(): Token | undefined;
+    peek(): Token;
+    isAtEnd(): boolean;
+    peekSourceCodeInfo(): SourceCodeInfo | undefined;
+    storePosition(): number;
+    restorePosition(): void;
+    peekAhead(count: number): Token | undefined;
+    getPosition(): number;
+    getTokenAt(pos: number): Token | undefined;
+}

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

@@ -0,0 +1,19 @@
+import type { OperatorToken, SourceCodeInfo } from '../tokenizer/token';
+import type { AstNode, BindingTarget, NormalBuiltinSymbolNode, NormalExpressionNodeWithName, SymbolNode, UserDefinedSymbolNode } from './types';
+import type { ParserContext } from './ParserContext';
+export declare const exponentiationPrecedence = 12;
+export declare const binaryFunctionalOperatorPrecedence = 3;
+export declare const conditionalOperatorPrecedence = 1;
+export declare function withSourceCodeInfo<T extends AstNode | BindingTarget>(node: T, sourceCodeInfo: SourceCodeInfo | undefined): T;
+export declare function stringToSymbolNode(value: string, sourceCodeInfo: SourceCodeInfo | undefined): SymbolNode;
+export declare function stringFromQuotedSymbol(value: string): string;
+/**
+ * Extract the symbol name from any symbol node type.
+ * UserDefinedSymbolNode: node[1] is the string name
+ * NormalBuiltinSymbolNode: node[1] is an index, need reverse lookup
+ * SpecialBuiltinSymbolNode: node[1] is an index, need reverse lookup
+ */
+export declare function getSymbolName(symbol: SymbolNode): string;
+export declare function createNamedNormalExpressionNode(symbolNode: NormalBuiltinSymbolNode | UserDefinedSymbolNode, params: AstNode[], sourceCodeInfo: SourceCodeInfo | undefined): NormalExpressionNodeWithName;
+export declare function isAtExpressionEnd(ctx: ParserContext): boolean;
+export declare function fromBinaryOperatorToNode(operator: OperatorToken, symbolNode: SymbolNode, left: AstNode, right: AstNode, sourceCodeInfo: SourceCodeInfo | undefined): AstNode;

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

@@ -0,0 +1,3 @@
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { AstNode } from './types';
+export declare function parse(tokenStream: TokenStream): AstNode[];

package/dist/modules/src/parser/subParsers/getPrecedence.d.ts

@@ -0,0 +1,3 @@
+import type { SourceCodeInfo } from '../../tokenizer/token';
+import type { SymbolicBinaryOperator } from '../../tokenizer/operators';
+export declare function getPrecedence(operatorSign: SymbolicBinaryOperator, sourceCodeInfo: SourceCodeInfo | undefined): number;

package/dist/modules/src/parser/subParsers/parseArray.d.ts

@@ -0,0 +1,3 @@
+import type { ArrayNode } from '../../builtin/specialExpressions/array';
+import type { ParserContext } from '../ParserContext';
+export declare function parseArray(ctx: ParserContext): ArrayNode;

package/dist/modules/src/parser/subParsers/parseBindingTarget.d.ts

@@ -0,0 +1,6 @@
+import type { BindingTarget } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseBindingTarget(ctx: ParserContext, { requireDefaultValue, noRest }?: {
+    requireDefaultValue?: true;
+    noRest?: true;
+}): BindingTarget;

package/dist/modules/src/parser/subParsers/parseCond.d.ts

@@ -0,0 +1,4 @@
+import type { CondNode } from '../../builtin/specialExpressions/cond';
+import { type SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseCond(ctx: ParserContext, token: SymbolToken): CondNode;

package/dist/modules/src/parser/subParsers/parseDo.d.ts

@@ -0,0 +1,3 @@
+import type { DoNode } from '../../builtin/specialExpressions/block';
+import type { ParserContext } from '../ParserContext';
+export declare function parseDo(ctx: ParserContext, allowDocString?: boolean): [DoNode, string];

package/dist/modules/src/parser/subParsers/parseForOrDoseq.d.ts

@@ -0,0 +1,4 @@
+import type { DoSeqNode, ForNode } from '../../builtin/specialExpressions/loops';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseForOrDoseq(ctx: ParserContext, firstToken: SymbolToken): ForNode | DoSeqNode;

package/dist/modules/src/parser/subParsers/parseFunction.d.ts

@@ -0,0 +1,4 @@
+import type { LambdaNode } from '../../builtin/specialExpressions/functions';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLambdaFunction(ctx: ParserContext): LambdaNode | null;
+export declare function parseShorthandLambdaFunction(ctx: ParserContext): LambdaNode;

package/dist/modules/src/parser/subParsers/parseFunctionCall.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseFunctionCall(ctx: ParserContext, symbol: AstNode): AstNode;

package/dist/modules/src/parser/subParsers/parseIfOrUnless.d.ts

@@ -0,0 +1,5 @@
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { UnlessNode } from '../../builtin/specialExpressions/unless';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseIfOrUnless(ctx: ParserContext, token: SymbolToken): IfNode | UnlessNode;

package/dist/modules/src/parser/subParsers/parseImplicitBlock.d.ts

@@ -0,0 +1,5 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+type ImplicitBlockEnd = 'end' | 'else' | 'catch' | 'case';
+export declare function parseImplicitBlock(ctx: ParserContext, ends: ImplicitBlockEnd[]): AstNode;
+export {};

package/dist/modules/src/parser/subParsers/parseLet.d.ts

@@ -0,0 +1,4 @@
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLet(ctx: ParserContext, token: SymbolToken): LetNode;

package/dist/modules/src/parser/subParsers/parseLoop.d.ts

@@ -0,0 +1,4 @@
+import type { LoopNode } from '../../builtin/specialExpressions/loop';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLoop(ctx: ParserContext, firstToken: SymbolToken): LoopNode;

package/dist/modules/src/parser/subParsers/parseNumber.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseNumber(ctx: ParserContext): NumberNode;

package/dist/modules/src/parser/subParsers/parseObject.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectNode } from '../../builtin/specialExpressions/object';
+import type { ParserContext } from '../ParserContext';
+export declare function parseObject(ctx: ParserContext): ObjectNode;

package/dist/modules/src/parser/subParsers/parseOperand.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseOperand(ctx: ParserContext): AstNode;

package/dist/modules/src/parser/subParsers/parseRegexpShorthand.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNodeWithName } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseRegexpShorthand(ctx: ParserContext): NormalExpressionNodeWithName;

package/dist/modules/src/parser/subParsers/parseReservedSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode, ReservedSymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseReservedSymbol(ctx: ParserContext): ReservedSymbolNode | NumberNode;

package/dist/modules/src/parser/subParsers/parseString.d.ts

@@ -0,0 +1,4 @@
+import type { StringNode } from '../types';
+import type { StringToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseString(ctx: ParserContext, token: StringToken): StringNode;

package/dist/modules/src/parser/subParsers/parseSwitch.d.ts

@@ -0,0 +1,4 @@
+import type { SwitchNode } from '../../builtin/specialExpressions/switch';
+import { type SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseSwitch(ctx: ParserContext, token: SymbolToken): SwitchNode;

package/dist/modules/src/parser/subParsers/parseSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NormalBuiltinSymbolNode, SpecialBuiltinSymbolNode, SymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseSymbol(ctx: ParserContext): SymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;

package/dist/modules/src/parser/subParsers/parseTry.d.ts

@@ -0,0 +1,4 @@
+import type { TryNode } from '../../builtin/specialExpressions/try';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseTry(ctx: ParserContext, token: SymbolToken): TryNode;

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

@@ -0,0 +1,126 @@
+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 } from '../tokenizer/token';
+import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+export type EvaluatedFunction = [BindingTarget[], AstNode[], 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 AstNode<T extends NodeType = NodeType, Payload = unknown> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
+export type SpreadNode = AstNode<typeof NodeTypes.Spread, AstNode>;
+export type NumberNode = AstNode<typeof NodeTypes.Number, number>;
+export type StringNode = AstNode<typeof NodeTypes.String, string>;
+export type UserDefinedSymbolNode = AstNode<typeof NodeTypes.UserDefinedSymbol, string>;
+export type NormalBuiltinSymbolNode = AstNode<typeof NodeTypes.NormalBuiltinSymbol, number>;
+export type SpecialBuiltinSymbolNode = AstNode<typeof NodeTypes.SpecialBuiltinSymbol, SpecialExpressionType>;
+export type SymbolNode = UserDefinedSymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;
+export type ReservedSymbolNode = AstNode<typeof NodeTypes.ReservedSymbol, ReservedSymbol>;
+export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = AstNode<typeof NodeTypes.SpecialExpression, T>;
+export type NormalExpressionNodeWithName = AstNode<typeof NodeTypes.NormalExpression, [NormalBuiltinSymbolNode | UserDefinedSymbolNode, AstNode[]]>;
+export type NormalExpressionNodeExpression = AstNode<typeof NodeTypes.NormalExpression, [AstNode, AstNode[]]>;
+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, AstNode | undefined]>;
+export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, AstNode | undefined]>;
+export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, AstNode | undefined]>;
+export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], AstNode | undefined]>;
+export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget;
+export type BindingNode = AstNode<typeof NodeTypes.Binding, [BindingTarget, AstNode]>;
+type AstBody = AstNode[];
+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,15 @@
+interface RunTestParams {
+    testPath: string;
+    testNamePattern?: RegExp;
+}
+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;
+export {};

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 {};