@mojir/lits 2.2.2-alpha.6 → 2.2.2

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<'or'> {
-}
+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[]]>;
 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

@@ -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 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, NameNode } from '../../parser/interface';
+import type { Node, SpecialExpressionNode, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface TryNode extends CommonSpecialExpressionNode<'try'> {
-    e: NameNode;
-    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

@@ -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 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,45 +1,19 @@
-export declare enum AstNodeType {
-    Number = 201,
-    String = 202,
-    NormalExpression = 203,
-    SpecialExpression = 204,
-    Name = 205,
-    Modifier = 206,
-    ReservedName = 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 TokenType {
-    Bracket = 101,
-    Number = 102,
-    Name = 103,
-    String = 104,
-    ReservedName = 105,
-    Modifier = 106,
-    RegexpShorthand = 107,
-    FnShorthand = 108,
-    CollectionAccessor = 109,
-    Comment = 110,
-    NewLine = 111
-}
-export declare const tokenTypeName: Map<TokenType, string>;
-export declare function isTokenType(type: unknown): type is TokenType;
-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", "SpecialBuiltin", "NativeJsFunction", "Module"];
+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);
@@ -7,12 +7,9 @@ export declare class RecurSignal extends Error {
 export declare class LitsError extends Error {
     readonly sourceCodeInfo?: SourceCodeInfo;
     readonly shortMessage: string;
-    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+    constructor(err: unknown, sourceCodeInfo: SourceCodeInfo | undefined);
     getCodeMarker(): string | undefined;
 }
-export declare class NotAFunctionError extends LitsError {
-    constructor(fn: unknown, sourceCodeInfo?: SourceCodeInfo);
-}
 export declare class UserDefinedError extends LitsError {
     userMessage: string;
     constructor(message: string, sourceCodeInfo?: SourceCodeInfo);

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

@@ -1,24 +1,29 @@
-import type { ExtraData, NameNode, NativeJsFunction } from '../parser/interface';
 import type { Any } from '../interface';
-import type { LazyValue, LitsParams } from '../Lits/Lits';
+import type { ContextParams } from '../Lits/Lits';
+import type { LitsModule } from '../builtin/modules/interface';
+import { type NativeJsModule, type SymbolNode, type UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { Context, LookUpResult } from './interface';
 export type ContextStack = ContextStackImpl;
 export declare class ContextStackImpl {
     private contexts;
     globalContext: Context;
     private values?;
-    private lazyValues?;
     private nativeJsFunctions?;
-    constructor({ contexts, values: hostValues, lazyValues: lazyHostValues, nativeJsFunctions, }: {
+    private modules;
+    constructor({ contexts, values: hostValues, nativeJsFunctions, modules, }: {
         contexts: Context[];
         values?: Record<string, unknown>;
-        lazyValues?: Record<string, LazyValue>;
-        nativeJsFunctions?: Record<string, NativeJsFunction>;
+        nativeJsFunctions?: NativeJsModule;
+        modules?: Map<string, LitsModule>;
     });
-    create(context: Context, extraData?: ExtraData): ContextStack;
-    clone(): ContextStack;
+    getModule(name: string): LitsModule | undefined;
+    create(context: Context): ContextStack;
+    new(context: Context): ContextStack;
+    exportValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
+    addValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
     getValue(name: string): unknown;
-    lookUp(node: NameNode): LookUpResult;
-    evaluateName(node: NameNode): Any;
+    lookUp(node: UserDefinedSymbolNode): LookUpResult;
+    evaluateSymbol(node: SymbolNode): Any;
 }
-export declare function createContextStack(params?: LitsParams): ContextStack;
+export declare function createContextStack(params?: ContextParams, modules?: Map<string, LitsModule>): 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 { FunctionLike, Node } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { ContextStack } from './ContextStack';
 export interface ContextEntry {
     value: Any;
 }
 export type Context = Record<string, ContextEntry>;
-export type EvaluateAstNode = (node: AstNode, contextStack: ContextStack) => Any;
-export type ExecuteFunction = (fn: Any, params: Arr, contextStack: ContextStack, sourceCodeInfo?: SourceCodeInfo) => Any;
-export type LookUpResult = ContextEntry | BuiltinFunction | 'specialExpression' | null;
+export type EvaluateNode = (node: Node, contextStack: ContextStack) => Any;
+export type ExecuteFunction = (fn: FunctionLike, params: Arr, contextStack: ContextStack, sourceCodeInfo?: SourceCodeInfo) => Any;
+export type LookUpResult = ContextEntry | null;
 export declare function isContextEntry(value: unknown): value is ContextEntry;

package/dist/src/full.d.ts

@@ -0,0 +1,17 @@
+import './initReferenceData';
+export * from './index';
+export { allBuiltinModules } from './allModules';
+export { assertModule } from './builtin/modules/assert';
+export { gridModule } from './builtin/modules/grid';
+export { randomModule } from './builtin/modules/random';
+export { vectorModule } from './builtin/modules/vector';
+export { linearAlgebraModule } from './builtin/modules/linear-algebra';
+export { matrixModule } from './builtin/modules/matrix';
+export { numberTheoryModule } from './builtin/modules/number-theory';
+export { mathUtilsModule } from './builtin/modules/math';
+export { functionalUtilsModule } from './builtin/modules/functional';
+export { bitwiseUtilsModule } from './builtin/modules/bitwise';
+export { apiReference, isCustomReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
+export type { Argument, CommonReference, CustomReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
+export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
+export { isApiName, isDataType } from '../reference/api';

package/dist/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,17 +1,14 @@
-export { AstNodeType, TokenType, 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 Arity } from './builtin/interface';
+export { type LitsFunction, type NativeJsFunction } from './parser/types';
 export type { Context } from './evaluator/interface';
-export type { Ast } from './parser/interface';
-export type { Token, SourceCodeInfo } from './tokenizer/interface';
+export type { Ast } from './parser/types';
+export type { SourceCodeInfo } from './tokenizer/token';
+export type { Token, TokenType } from './tokenizer/token';
 export { normalExpressionKeys, specialExpressionKeys } from './builtin';
-export { reservedNames } from './reservedNames';
 export { Lits } from './Lits/Lits';
+export type { LitsModule } from './builtin/modules/interface';
 export { type LitsError, isLitsError } from './errors';
-export type { LitsParams, LitsRuntimeInfo, LazyValue, JsFunction } from './Lits/Lits';
-export { createNativeJsFunction } from './utils';
-export { apiReference, isDatatypeReference, isFunctionReference, isNormalExpressionArgument, isShorthandReference, isSpecialExpressionArgument, isTypedValue } 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 { type Identifier, assertIdentifier, isIdentifier } from './identifier';
+export type { ContextParams, FilePathParams, MinifyParams, LitsRuntimeInfo, JsFunction } from './Lits/Lits';
+export { isGrid, isMatrix, isVector } from './typeGuards/annotatedArrays';
+export type { AutoCompleter } from './AutoCompleter/AutoCompleter';

package/dist/src/initReferenceData.d.ts

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

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/modules/assert.d.ts

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

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

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

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

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

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

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

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

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

package/dist/src/modules/linear-algebra.d.ts

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

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

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

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

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

package/dist/src/modules/number-theory.d.ts

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

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

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

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

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

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

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

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

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

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

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