@mojir/lits 2.1.0 → 2.1.2

package/dist/cli/src/builtin/bindingNode.d.ts

@@ -1,4 +1,5 @@
 import type { Any } from '../interface';
-import type { AstNode, BindingNode, BindingTarget } from '../parser/types';
-export declare function evalueateBindingNodeValues(input: BindingNode | BindingTarget, value: Any, evaluate: (astNode: AstNode) => Any): Record<string, Any>;
+import { type BindingTarget, type Node } from '../parser/types';
+export declare function walkDefaults(bindingTarget: BindingTarget, onDefault: (Node: Node) => void): void;
+export declare function evalueateBindingNodeValues(target: BindingTarget, value: Any, evaluate: (Node: Node) => Any): Record<string, Any>;
 export declare function getAllBindingTargetNames(bindingTarget: BindingTarget): Record<string, true>;

package/dist/cli/src/builtin/index.d.ts

@@ -1,54 +1,14 @@
 import type { Builtin } from './interface';
-import type { AndNode } from './specialExpressions/and';
-import type { CondNode } from './specialExpressions/cond';
-import type { SwitchNode } from './specialExpressions/switch';
-import type { DeclaredNode } from './specialExpressions/declared';
-import type { DefNode } from './specialExpressions/def';
-import type { DoNode } from './specialExpressions/do';
-import type { DefnNode, FnNode, FunctionNode } from './specialExpressions/functions';
-import type { IfNode } from './specialExpressions/if';
-import type { UnlessNode } from './specialExpressions/unless';
-import type { LetNode } from './specialExpressions/let';
-import type { LoopNode } from './specialExpressions/loop';
-import type { DoSeqNode, ForNode } from './specialExpressions/loops';
-import type { OrNode } from './specialExpressions/or';
-import type { QqNode } from './specialExpressions/qq';
-import type { RecurNode } from './specialExpressions/recur';
-import type { ThrowNode } from './specialExpressions/throw';
-import type { TryNode } from './specialExpressions/try';
-import type { ArrayNode } from './specialExpressions/array';
-import type { ObjectNode } from './specialExpressions/object';
-declare const specialExpressions: {
-    readonly '&&': import("./interface").BuiltinSpecialExpression<import("../interface").Any, AndNode>;
-    readonly cond: import("./interface").BuiltinSpecialExpression<import("../interface").Any, CondNode>;
-    readonly switch: import("./interface").BuiltinSpecialExpression<import("../interface").Any, SwitchNode>;
-    readonly def: import("./interface").BuiltinSpecialExpression<null, DefNode>;
-    readonly defn: import("./interface").BuiltinSpecialExpression<null, DefnNode>;
-    readonly function: import("./interface").BuiltinSpecialExpression<null, FunctionNode>;
-    readonly do: import("./interface").BuiltinSpecialExpression<import("../interface").Any, DoNode>;
-    readonly doseq: import("./interface").BuiltinSpecialExpression<null, DoSeqNode>;
-    readonly for: import("./interface").BuiltinSpecialExpression<import("../interface").Any, ForNode>;
-    readonly fn: import("./interface").BuiltinSpecialExpression<import("../parser/types").LitsFunction, FnNode>;
-    readonly if: import("./interface").BuiltinSpecialExpression<import("../interface").Any, IfNode>;
-    readonly unless: import("./interface").BuiltinSpecialExpression<import("../interface").Any, UnlessNode>;
-    readonly let: import("./interface").BuiltinSpecialExpression<import("../interface").Any, LetNode>;
-    readonly loop: import("./interface").BuiltinSpecialExpression<import("../interface").Any, LoopNode>;
-    readonly '||': import("./interface").BuiltinSpecialExpression<import("../interface").Any, OrNode>;
-    readonly recur: import("./interface").BuiltinSpecialExpression<null, RecurNode>;
-    readonly throw: import("./interface").BuiltinSpecialExpression<null, ThrowNode>;
-    readonly try: import("./interface").BuiltinSpecialExpression<import("../interface").Any, TryNode>;
-    readonly 'defined?': import("./interface").BuiltinSpecialExpression<boolean, DeclaredNode>;
-    readonly '??': import("./interface").BuiltinSpecialExpression<import("../interface").Any, QqNode>;
-    readonly array: import("./interface").BuiltinSpecialExpression<import("../interface").Any, ArrayNode>;
-    readonly object: import("./interface").BuiltinSpecialExpression<import("../interface").Any, ObjectNode>;
-};
-export type SpecialExpressionName = keyof typeof specialExpressions;
-export type CommonSpecialExpressionName = keyof Pick<typeof specialExpressions, '??' | '&&' | 'cond' | 'switch' | 'defined?' | 'do' | 'if' | 'unless' | '||' | 'throw' | 'array' | 'object'>;
-export type BuiltinSpecialExpressions = typeof specialExpressions;
-export type BuiltinSpecialExpression = typeof specialExpressions[SpecialExpressionName];
-export type BuiltinCommonSpecialExpression = typeof specialExpressions[CommonSpecialExpressionName];
-export type SpecialExpressionNode = AndNode | CondNode | SwitchNode | DefNode | DefnNode | FunctionNode | DoNode | DoSeqNode | ForNode | FnNode | IfNode | UnlessNode | LetNode | LoopNode | OrNode | RecurNode | ThrowNode | TryNode | DeclaredNode | QqNode | ArrayNode | ObjectNode;
+import { specialExpressionTypes } from './specialExpressionTypes';
+export declare const specialExpressions: readonly [import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/qq").QqNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/array").ArrayNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/cond").CondNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/def").DefNode>, import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/defined").DefinedNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").DefnNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/do").DoNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/loops").DoSeqNode>, import("./interface").BuiltinSpecialExpression<import("../parser/types").LitsFunction, import("./specialExpressions/functions").FnNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loops").ForNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").FunctionNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if").IfNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/let").LetNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loop").LoopNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/object").ObjectNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/recur").RecurNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/switch").SwitchNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/throw").ThrowNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/try").TryNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/unless").UnlessNode>];
+export type SpecialExpressions = typeof specialExpressions;
+export type SpecialExpression = SpecialExpressions[number];
+export type SpecialExpressionName = keyof typeof specialExpressionTypes;
+export type CommonSpecialExpressionType = [
+    typeof specialExpressionTypes['??'] | typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['cond'] | typeof specialExpressionTypes['switch'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['do'] | typeof specialExpressionTypes['if'] | typeof specialExpressionTypes['unless'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object']
+];
+export type SpecialExpressionType = typeof specialExpressionTypes[SpecialExpressionName];
 export declare const builtin: Builtin;
 export declare const normalExpressionKeys: string[];
 export declare const specialExpressionKeys: string[];
-export {};
+export declare const specialExpressionNameSet: Set<string>;

package/dist/cli/src/builtin/interface.d.ts

@@ -1,10 +1,10 @@
-import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
+import type { EvaluateNode, ExecuteFunction } from '../evaluator/interface';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
 import type { Any, Arr } from '../interface';
-import type { ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokensUntilClosingBracket } from '../parser/types';
+import type { SpecialExpressionNode } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
-import type { BuiltinSpecialExpressions, SpecialExpressionNode } from '.';
+import type { SpecialExpressions } from '.';
 export type Count = number | {
     min?: number;
     max?: number;
@@ -14,22 +14,15 @@ export type Count = number | {
 export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
 }) => T;
-interface BuiltinNormalExpression<T> {
+export interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
     paramCount: Count;
     aliases?: string[];
 }
-export interface ParserHelpers {
-    parseExpression: ParseExpression;
-    parseTokensUntilClosingBracket: ParseTokensUntilClosingBracket;
-    parseToken: ParseToken;
-    parseBinding: ParseBinding;
-    parseBindings: ParseBindings;
-    parseArgument: ParseArgument;
-}
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+export type BuiltingAllNormalExpressions = BuiltinNormalExpression<Any>[];
 export interface EvaluateHelpers {
-    evaluateAstNode: EvaluateAstNode;
+    evaluateNode: EvaluateNode;
     builtin: Builtin;
     getUndefinedSymbols: GetUndefinedSymbols;
 }
@@ -39,11 +32,11 @@ export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
     getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
         getUndefinedSymbols: GetUndefinedSymbols;
         builtin: Builtin;
-        evaluateAstNode: EvaluateAstNode;
+        evaluateNode: EvaluateNode;
     }) => UndefinedSymbols;
 }
 export interface Builtin {
     normalExpressions: BuiltinNormalExpressions;
-    specialExpressions: BuiltinSpecialExpressions;
+    allNormalExpressions: BuiltingAllNormalExpressions;
+    specialExpressions: SpecialExpressions;
 }
-export {};

package/dist/cli/src/builtin/normalExpressions/index.d.ts

@@ -1,2 +1,5 @@
-import type { BuiltinNormalExpressions } from '../interface';
+import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../interface';
+import type { Any } from '../../interface';
 export declare const normalExpressions: BuiltinNormalExpressions;
+export declare const normalExpressionTypes: Record<string, number>;
+export declare const allNormalExpressions: BuiltinNormalExpression<Any>[];

package/dist/cli/src/builtin/specialExpressionTypes.d.ts

@@ -0,0 +1,25 @@
+export declare const specialExpressionTypes: {
+    readonly '??': 0;
+    readonly '&&': 1;
+    readonly '||': 2;
+    readonly array: 3;
+    readonly cond: 4;
+    readonly '0_def': 5;
+    readonly 'defined?': 6;
+    readonly '0_defn': 7;
+    readonly do: 8;
+    readonly doseq: 9;
+    readonly '0_fn': 10;
+    readonly for: 11;
+    readonly function: 12;
+    readonly if: 13;
+    readonly let: 14;
+    readonly loop: 15;
+    readonly object: 16;
+    readonly recur: 17;
+    readonly switch: 18;
+    readonly throw: 19;
+    readonly try: 20;
+    readonly unless: 21;
+};
+export type SpecialExpressionTypes = typeof specialExpressionTypes;

package/dist/cli/src/builtin/specialExpressions/and.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/types';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface AndNode extends CommonSpecialExpressionNode<'&&'> {
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type AndNode = SpecialExpressionNode<[typeof specialExpressionTypes['&&'], Node[]]>;
 export declare const andSpecialExpression: BuiltinSpecialExpression<Any, AndNode>;

package/dist/cli/src/builtin/specialExpressions/array.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/types';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface ArrayNode extends CommonSpecialExpressionNode<'array'> {
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type ArrayNode = SpecialExpressionNode<[typeof specialExpressionTypes['array'], Node[]]>;
 export declare const arraySpecialExpression: BuiltinSpecialExpression<Any, ArrayNode>;

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

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

package/dist/cli/src/builtin/specialExpressions/def.d.ts

@@ -1,8 +1,5 @@
-import type { BindingNode, GenericNode } from '../../parser/types';
+import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface DefNode extends GenericNode {
-    name: 'def';
-    type: 'SpecialExpression';
-    bindingNode: BindingNode;
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DefNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_def'], BindingNode]>;
 export declare const defSpecialExpression: BuiltinSpecialExpression<null, DefNode>;

package/dist/cli/src/builtin/specialExpressions/defined.d.ts

@@ -0,0 +1,5 @@
+import type { SpecialExpressionNode, SymbolNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DefinedNode = SpecialExpressionNode<[typeof specialExpressionTypes['defined?'], SymbolNode]>;
+export declare const definedSpecialExpression: BuiltinSpecialExpression<boolean, DefinedNode>;

package/dist/cli/src/builtin/specialExpressions/do.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/types';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface DoNode extends CommonSpecialExpressionNode<'do'> {
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DoNode = SpecialExpressionNode<[typeof specialExpressionTypes['do'], Node[]]>;
 export declare const doSpecialExpression: BuiltinSpecialExpression<Any, DoNode>;

package/dist/cli/src/builtin/specialExpressions/functions.d.ts

@@ -1,18 +1,10 @@
-import type { AstNode, CommonSpecialExpressionNode, LitsFunction, SymbolNode } from '../../parser/types';
+import type { LitsFunction, SpecialExpressionNode, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { Function } from '../utils';
-export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
-    functionName: SymbolNode;
-    function: Function;
-}
-export interface FunctionNode extends CommonSpecialExpressionNode<'function'> {
-    functionName: SymbolNode;
-    function: Function;
-}
-export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
-    params: AstNode[];
-    function: Function;
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_defn'], SymbolNode, Function]>;
+export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function]>;
+export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_fn'], Function]>;
 export declare const functionSpecialExpression: BuiltinSpecialExpression<null, FunctionNode>;
 export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
 export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;

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

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

package/dist/cli/src/builtin/specialExpressions/let.d.ts

@@ -1,9 +1,6 @@
 import type { Any } from '../../interface';
-import type { BindingNode, GenericNode } from '../../parser/types';
+import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface LetNode extends GenericNode {
-    type: 'SpecialExpression';
-    bindingNode: BindingNode;
-    name: 'let';
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LetNode = SpecialExpressionNode<[typeof specialExpressionTypes['let'], BindingNode]>;
 export declare const letSpecialExpression: BuiltinSpecialExpression<Any, LetNode>;

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

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

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

@@ -1,18 +1,9 @@
 import type { Any } from '../../interface';
-import type { AstNode, BindingNode, CommonSpecialExpressionNode } from '../../parser/types';
+import type { BindingNode, Node, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface ForNode extends CommonSpecialExpressionNode<'for'> {
-    l: LoopBindingNode[];
-}
-export interface DoSeqNode extends CommonSpecialExpressionNode<'doseq'> {
-    l: LoopBindingNode[];
-}
-export interface LoopBindingNode {
-    b: BindingNode;
-    m: Array<'&let' | '&when' | '&while'>;
-    l?: BindingNode[];
-    wn?: AstNode;
-    we?: AstNode;
-}
+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 declare const forSpecialExpression: BuiltinSpecialExpression<Any, ForNode>;
 export declare const doseqSpecialExpression: BuiltinSpecialExpression<null, DoSeqNode>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,18 @@
-export declare const astNodeTypeNames: readonly ["Number", "String", "NormalExpression", "SpecialExpression", "Symbol", "Modifier", "ReservedSymbol", "Binding", "Argument", "Partial", "Comment", "Spread"];
-export type AstNodeType = typeof astNodeTypeNames[number];
-export declare function isAstNodeType(type: unknown): type is AstNodeType;
+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", "NativeJsFunction"];
 export type FunctionType = typeof functionTypes[number];
 export declare function isFunctionType(type: unknown): type is FunctionType;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../interface';
 import type { ContextParams, LazyValue } from '../Lits/Lits';
-import type { NativeJsFunction, SymbolNode } from '../parser/types';
+import type { NativeJsFunction, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
 import type { Context, LookUpResult } from './interface';
 export type ContextStack = ContextStackImpl;
 export declare class ContextStackImpl {
@@ -20,7 +20,7 @@ export declare class ContextStackImpl {
     exportValues(values: Record<string, Any>): void;
     addValues(values: Record<string, Any>): void;
     getValue(name: string): unknown;
-    lookUp(node: SymbolNode): LookUpResult;
-    evaluateName(node: SymbolNode): Any;
+    lookUp(node: UserDefinedSymbolNode): LookUpResult;
+    evaluateSymbol(node: SymbolNode): Any;
 }
 export declare function createContextStack(params?: ContextParams): ContextStack;

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

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

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

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

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

@@ -1,12 +1,12 @@
 import type { Any, Arr } from '../interface';
-import type { AstNode, BuiltinFunction } from '../parser/types';
+import type { 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 EvaluateAstNode = (node: AstNode, contextStack: ContextStack) => Any;
+export type EvaluateNode = (node: Node, contextStack: ContextStack) => Any;
 export type ExecuteFunction = (fn: Any, params: Arr, contextStack: ContextStack, sourceCodeInfo?: SourceCodeInfo) => Any;
-export type LookUpResult = ContextEntry | BuiltinFunction | null;
+export type LookUpResult = ContextEntry | null;
 export declare function isContextEntry(value: unknown): value is ContextEntry;

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

@@ -1,7 +1,7 @@
 import type { Builtin } from '../builtin/interface';
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { EvaluateAstNode } from '../evaluator/interface';
-import type { Ast, AstNode } from '../parser/types';
+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 | AstNode[], contextStack: ContextStack, builtin: Builtin, evaluateAstNode: EvaluateAstNode) => UndefinedSymbols;
+export type GetUndefinedSymbols = (ast: Ast | Node[], contextStack: ContextStack, builtin: Builtin, evaluateNode: EvaluateNode) => UndefinedSymbols;

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

@@ -1,11 +1,11 @@
 import type { CondNode } from '../builtin/specialExpressions/cond';
-import type { FunctionNode } from '../builtin/specialExpressions/functions';
+import type { FnNode, FunctionNode } 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 { TokenStream } from '../tokenizer/tokenize';
 import type { ReservedSymbolToken, SymbolToken } from '../tokenizer/token';
-import type { AstNode, BindingTarget, ParseState } from './types';
+import type { TokenStream } from '../tokenizer/tokenize';
+import { type BindingTarget, type Node, type ParseState } from './types';
 export declare class Parser {
     private readonly tokenStream;
     private parseState;
@@ -13,14 +13,14 @@ export declare class Parser {
     private peek;
     private peekAhead;
     private advance;
-    parse(): AstNode[];
+    parse(): Node[];
     private parseExpression;
     private parseOperand;
     private parseOperandPart;
     private parseObject;
     private parseArray;
     private parseFunctionCall;
-    parseLambdaFunction(): AstNode | null;
+    parseLambdaFunction(): FnNode | null;
     parseFunctionArguments(): BindingTarget[];
     private parseShorthandLamdaFunction;
     private parseOptionalDefaulValue;
@@ -39,6 +39,8 @@ export declare class Parser {
     private isAtEnd;
     private isAtExpressionEnd;
     private parseExport;
+    private stringToSymbolNode;
+    stringFromQuotedSymbol(value: string): string;
     private parseSymbol;
     private parseReservedSymbol;
     private parseNumber;