@mojir/lits 2.0.23 → 2.1.1

package/dist/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/src/builtin/specialExpressionTypes.d.ts

@@ -0,0 +1,27 @@
+import type { SpecialExpressionName, SpecialExpressionType } from '.';
+export declare const specialExpressionTypes: {
+    readonly '??': 0;
+    readonly '&&': 1;
+    readonly '||': 2;
+    readonly array: 3;
+    readonly cond: 4;
+    readonly def: 5;
+    readonly 'defined?': 6;
+    readonly defn: 7;
+    readonly do: 8;
+    readonly doseq: 9;
+    readonly 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;
+export declare function getNameFromSpecialExpressionType(type: SpecialExpressionType): SpecialExpressionName;

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/array.d.ts

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

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/def.d.ts

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

package/dist/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/src/builtin/specialExpressions/do.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/functions.d.ts

@@ -1,13 +1,10 @@
-import type { AstNode, CommonSpecialExpressionNode, LitsFunction, SymbolNode } from '../../parser/interface';
+import type { LitsFunction, SpecialExpressionNode, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-import type { FunctionOverload } from '../utils';
-export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
-    f: SymbolNode;
-    o: FunctionOverload[];
-}
-export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
-    p: AstNode[];
-    o: FunctionOverload[];
-}
+import type { Function } from '../utils';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['defn'], SymbolNode, Function]>;
+export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function]>;
+export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['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/src/builtin/specialExpressions/if.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/let.d.ts

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

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

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

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

@@ -1,18 +1,9 @@
 import type { Any } from '../../interface';
-import type { AstNode, BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/object.d.ts

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

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/qq.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/recur.d.ts

@@ -1,5 +1,5 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/switch.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/throw.d.ts

@@ -1,5 +1,5 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/try.d.ts

@@ -1,8 +1,6 @@
 import type { Any } from '../../interface';
-import type { AstNode, CommonSpecialExpressionNode, SymbolNode } from '../../parser/interface';
+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/src/builtin/specialExpressions/unless.d.ts

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+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/src/builtin/utils.d.ts

@@ -1,18 +1,6 @@
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { AstNode, BindingNode } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { BindingTarget, Node } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { Builtin } from './interface';
-export type Arity = number | {
-    min: number;
-};
-export interface FunctionOverload {
-    as: FunctionArguments;
-    a: Arity;
-    b: AstNode[];
-}
-export interface FunctionArguments {
-    m: string[];
-    r?: string;
-    b: BindingNode[];
-}
+export type Function = [BindingTarget[], Node[]];
 export declare function assertNameNotDefined<T>(name: T, contextStack: ContextStack, builtin: Builtin, sourceCodeInfo?: SourceCodeInfo): asserts name is T;

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

@@ -1,30 +1,19 @@
-export declare enum AstNodeType {
-    Number = 201,
-    String = 202,
-    NormalExpression = 203,
-    SpecialExpression = 204,
-    Symbol = 205,
-    Modifier = 206,
-    ReservedSymbol = 207,
-    Binding = 208,
-    Argument = 209,
-    Partial = 210,
-    Comment = 211
-}
-export declare const astNodeTypeName: Map<AstNodeType, string>;
-export declare function isAstNodeType(type: unknown): type is AstNodeType;
-export declare enum FunctionType {
-    UserDefined = 301,
-    Partial = 302,
-    Comp = 303,
-    Constantly = 304,
-    Juxt = 305,
-    Complement = 306,
-    EveryPred = 307,
-    SomePred = 308,
-    Fnil = 309,
-    Builtin = 310,
-    NativeJsFunction = 399
-}
-export declare const functionTypeName: Map<FunctionType, string>;
+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;
+export {};

package/dist/src/errors.d.ts

@@ -1,5 +1,5 @@
 import type { Arr } from './interface';
-import type { SourceCodeInfo } from './tokenizer/interface';
+import type { SourceCodeInfo } from './tokenizer/token';
 export declare class RecurSignal extends Error {
     params: Arr;
     constructor(params: Arr);

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

@@ -1,6 +1,6 @@
-import type { ExtraData, NativeJsFunction, SymbolNode } from '../parser/interface';
 import type { Any } from '../interface';
-import type { LazyValue, LitsParams } from '../Lits/Lits';
+import type { ContextParams, LazyValue } from '../Lits/Lits';
+import type { NativeJsFunction, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
 import type { Context, LookUpResult } from './interface';
 export type ContextStack = ContextStackImpl;
 export declare class ContextStackImpl {
@@ -15,12 +15,12 @@ export declare class ContextStackImpl {
         lazyValues?: Record<string, LazyValue>;
         nativeJsFunctions?: Record<string, NativeJsFunction>;
     });
-    create(context: Context, extraData?: ExtraData): ContextStack;
-    exportValue(name: string, value: Any): void;
-    addValue(name: string, value: Any): void;
-    clone(): ContextStack;
+    create(context: Context): ContextStack;
+    new(context: Context): ContextStack;
+    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?: LitsParams): ContextStack;
+export declare function createContextStack(params?: ContextParams): ContextStack;

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

@@ -1,10 +1,10 @@
 import type { Any, Arr } from '../interface';
-import type { LitsFunctionType } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
-import type { EvaluateAstNode, ExecuteFunction } 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: {
-    evaluateAstNode: EvaluateAstNode;
+    evaluateNode: EvaluateNode;
     executeFunction: ExecuteFunction;
 }) => Any>;
 export declare const functionExecutors: FunctionExecutors;

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

@@ -1,5 +1,5 @@
-import type { Ast, AstNode } from '../parser/interface';
 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/src/evaluator/interface.d.ts

@@ -1,12 +1,12 @@
 import type { Any, Arr } from '../interface';
-import type { AstNode, BuiltinFunction } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+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 | 'specialExpression' | null;
+export type LookUpResult = ContextEntry | null;
 export declare function isContextEntry(value: unknown): value is ContextEntry;

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

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

package/dist/src/index.d.ts

@@ -1,18 +1,15 @@
-export { AstNodeType, FunctionType } from './constants/constants';
 export { isBuiltinFunction, isLitsFunction, asLitsFunction, assertLitsFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/litsFunction';
-export { type LitsFunction, type NativeJsFunction, type ExtraData } from './parser/interface';
+export { type LitsFunction, type NativeJsFunction } from './parser/types';
 export type { Context } from './evaluator/interface';
-export type { Ast } from './parser/interface';
-export type { SourceCodeInfo } from './tokenizer/interface';
-export type { Token } from './tokenizer/tokens';
+export type { Ast } from './parser/types';
+export type { SourceCodeInfo } from './tokenizer/token';
+export type { Token } from './tokenizer/token';
 export { normalExpressionKeys, specialExpressionKeys } from './builtin';
-export { polishReservedNames } from './tokenizer/polish/polishReservedNames';
 export { Lits } from './Lits/Lits';
 export { type LitsError, isLitsError } from './errors';
-export type { LitsParams, LitsRuntimeInfo, LazyValue, JsFunction } from './Lits/Lits';
+export type { ContextParams, FilePathParams, MinifyParams, LitsRuntimeInfo, LazyValue, JsFunction } from './Lits/Lits';
 export { createNativeJsFunction } from './utils';
-export { apiReference, isDatatypeReference, isFunctionReference, isNormalExpressionArgument, isShorthandReference, isSpecialExpressionArgument, isTypedValue } from '../reference';
+export { apiReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
 export type { Argument, CommonReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
 export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
 export { isApiName, isDataType } from '../reference/api';
-export { polishIdentifierCharacterClass as identifierCharacterClass, polishIdentifierFirstCharacterClass as identifierFirstCharacterClass } from './identifier';

package/dist/src/interface.d.ts

@@ -1,5 +1,4 @@
-import type { RegularExpression } from './parser/interface';
-import type { LitsFunction } from '.';
+import type { LitsFunction, RegularExpression } from './parser/types';
 export type Arr = unknown[];
 export type Seq = string | Arr;
 export type Obj = Record<string, unknown>;

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

@@ -0,0 +1,49 @@
+import type { CondNode } from '../builtin/specialExpressions/cond';
+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 { ReservedSymbolToken, SymbolToken } from '../tokenizer/token';
+import type { TokenStream } from '../tokenizer/tokenize';
+import { type BindingTarget, type Node, type ParseState } from './types';
+export declare class Parser {
+    private readonly tokenStream;
+    private parseState;
+    constructor(tokenStream: TokenStream, parseState: ParseState);
+    private peek;
+    private peekAhead;
+    private advance;
+    parse(): Node[];
+    private parseExpression;
+    private parseOperand;
+    private parseOperandPart;
+    private parseObject;
+    private parseArray;
+    private parseFunctionCall;
+    parseLambdaFunction(): FnNode | null;
+    parseFunctionArguments(): BindingTarget[];
+    private parseShorthandLamdaFunction;
+    private parseOptionalDefaulValue;
+    private parseBindingTarget;
+    private parseLet;
+    private parseDo;
+    private parseLoop;
+    private parseTry;
+    private parseForOrDoseq;
+    private parseForLoopBinding;
+    private parseBinding;
+    parseIfOrUnless(token: SymbolToken): IfNode | UnlessNode;
+    parseCond(token: SymbolToken): CondNode;
+    parseSwitch(token: SymbolToken): SwitchNode;
+    parseFunction(token: ReservedSymbolToken<'function'>): FunctionNode;
+    private isAtEnd;
+    private isAtExpressionEnd;
+    private parseExport;
+    private stringToSymbolNode;
+    stringFromQuotedSymbol(value: string): string;
+    private parseSymbol;
+    private parseReservedSymbol;
+    private parseNumber;
+    private parseString;
+    private parseRegexpShorthand;
+}