@mojir/lits 2.2.2 → 2.2.4

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type CondNode = SpecialExpressionNode<[typeof specialExpressionTypes['cond'], [Node, Node][]]>;
+export type CondNode = SpecialExpressionNode<[typeof specialExpressionTypes['cond'], [AstNode, AstNode][]]>;
 export declare const condSpecialExpression: BuiltinSpecialExpression<Any, CondNode>;

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

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

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { BindingNode, Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type LoopNode = SpecialExpressionNode<[typeof specialExpressionTypes['loop'], BindingNode[], Node]>;
+export type LoopNode = SpecialExpressionNode<[typeof specialExpressionTypes['loop'], BindingNode[], AstNode]>;
 export declare const loopSpecialExpression: BuiltinSpecialExpression<Any, LoopNode>;

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

@@ -1,9 +1,9 @@
 import type { Any } from '../../interface';
-import type { BindingNode, Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type LoopBindingNode = [BindingNode, BindingNode[], Node?, Node?];
-export type ForNode = SpecialExpressionNode<[typeof specialExpressionTypes['for'], LoopBindingNode[], Node]>;
-export type DoSeqNode = SpecialExpressionNode<[typeof specialExpressionTypes['doseq'], LoopBindingNode[], Node]>;
+export type LoopBindingNode = [BindingNode, BindingNode[], AstNode?, AstNode?];
+export type ForNode = SpecialExpressionNode<[typeof specialExpressionTypes['for'], LoopBindingNode[], AstNode]>;
+export type DoSeqNode = SpecialExpressionNode<[typeof specialExpressionTypes['doseq'], LoopBindingNode[], AstNode]>;
 export declare const forSpecialExpression: BuiltinSpecialExpression<Any, ForNode>;
 export declare const doseqSpecialExpression: BuiltinSpecialExpression<null, DoSeqNode>;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type ObjectNode = SpecialExpressionNode<[typeof specialExpressionTypes['object'], Node[]]>;
+export type ObjectNode = SpecialExpressionNode<[typeof specialExpressionTypes['object'], AstNode[]]>;
 export declare const objectSpecialExpression: BuiltinSpecialExpression<Any, ObjectNode>;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type OrNode = SpecialExpressionNode<[typeof specialExpressionTypes['||'], Node[]]>;
+export type OrNode = SpecialExpressionNode<[typeof specialExpressionTypes['||'], AstNode[]]>;
 export declare const orSpecialExpression: BuiltinSpecialExpression<Any, OrNode>;

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

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

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

@@ -1,5 +1,5 @@
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type RecurNode = SpecialExpressionNode<[typeof specialExpressionTypes['recur'], Node[]]>;
+export type RecurNode = SpecialExpressionNode<[typeof specialExpressionTypes['recur'], AstNode[]]>;
 export declare const recurSpecialExpression: BuiltinSpecialExpression<null, RecurNode>;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type SwitchNode = SpecialExpressionNode<[typeof specialExpressionTypes['switch'], Node, [Node, Node][]]>;
+export type SwitchNode = SpecialExpressionNode<[typeof specialExpressionTypes['switch'], AstNode, [AstNode, AstNode][]]>;
 export declare const switchSpecialExpression: BuiltinSpecialExpression<Any, SwitchNode>;

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

@@ -1,5 +1,5 @@
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type ThrowNode = SpecialExpressionNode<[typeof specialExpressionTypes['throw'], Node]>;
+export type ThrowNode = SpecialExpressionNode<[typeof specialExpressionTypes['throw'], AstNode]>;
 export declare const throwSpecialExpression: BuiltinSpecialExpression<null, ThrowNode>;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode, SymbolNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type TryNode = SpecialExpressionNode<[typeof specialExpressionTypes['try'], Node, SymbolNode | undefined, Node]>;
+export type TryNode = SpecialExpressionNode<[typeof specialExpressionTypes['try'], AstNode, SymbolNode | undefined, AstNode]>;
 export declare const trySpecialExpression: BuiltinSpecialExpression<Any, TryNode>;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { AstNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type UnlessNode = SpecialExpressionNode<[typeof specialExpressionTypes['unless'], [Node, Node, Node?]]>;
+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

@@ -1,6 +1,6 @@
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { BindingTarget, Node } from '../parser/types';
+import type { AstNode, BindingTarget } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 import type { Builtin } from './interface';
-export type Function = [BindingTarget[], Node[]];
+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/evaluator/index.d.ts

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

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

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

@@ -1,7 +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';
+import type { Ast, AstNode } 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;
+export type GetUndefinedSymbols = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin, evaluateNode: EvaluateNode) => UndefinedSymbols;

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

@@ -6,12 +6,9 @@ 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 { SourceCodeInfo } from '../tokenizer/token';
 import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
-export interface ParseState {
-    position: number;
-}
-export type EvaluatedFunction = [BindingTarget[], Node[], Context];
+export type EvaluatedFunction = [BindingTarget[], AstNode[], Context];
 interface GenericLitsFunction {
     [FUNCTION_SYMBOL]: true;
     sourceCodeInfo?: SourceCodeInfo;
@@ -93,23 +90,19 @@ export interface ModuleFunction extends GenericLitsFunction {
 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 AstNode<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 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 = 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 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;
@@ -119,13 +112,13 @@ export declare const bindingTargetTypes: {
 };
 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 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 = Node<typeof NodeTypes.Binding, [BindingTarget, Node]>;
-type AstBody = Node[];
+export type BindingNode = AstNode<typeof NodeTypes.Binding, [BindingTarget, AstNode]>;
+type AstBody = AstNode[];
 export interface Ast {
     body: AstBody;
     hasDebugData: boolean;

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

@@ -1,8 +1,8 @@
-export interface RunTestParams {
+interface RunTestParams {
     testPath: string;
     testNamePattern?: RegExp;
 }
-export interface TestResult {
+interface TestResult {
     /**
      * Test report
      * http://testanything.org/
@@ -12,3 +12,4 @@ export interface TestResult {
 }
 export declare function runTest({ testPath: filePath, testNamePattern }: RunTestParams): TestResult;
 export declare function getErrorYaml(error: unknown): string;
+export {};

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

@@ -2,8 +2,6 @@ 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', '{'>;

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

@@ -1,8 +1,7 @@
 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>;
+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>;
@@ -12,3 +11,4 @@ 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>];
+export {};

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

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

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

@@ -1,6 +1,5 @@
 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>;

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

@@ -19,6 +19,5 @@ export declare function assertRegularExpression(value: unknown, sourceCodeInfo?:
 export declare function isStringOrRegularExpression(value: unknown): value is string | RegularExpression;
 export declare function asStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): string | RegularExpression;
 export declare function assertStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string | RegularExpression;
-export declare function isFunctionLike(value: unknown): value is FunctionLike;
 export declare function asFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): FunctionLike;
 export declare function assertFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is FunctionLike;