@mojir/lits 2.0.22 → 2.1.0

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

@@ -1,16 +1,15 @@
-import type { FindUnresolvedIdentifiers, UnresolvedIdentifiers } from '../analyze';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
 import type { ContextStack } from '../evaluator/ContextStack';
 import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
 import type { Any, Arr } from '../interface';
-import type { ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseState, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
-import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
-import type { Token } from '../tokenizer/tokens';
+import type { ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokensUntilClosingBracket } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { BuiltinSpecialExpressions, SpecialExpressionNode } from '.';
 export type Count = number | {
     min?: number;
     max?: number;
-    even?: boolean;
-    odd?: boolean;
+    even?: true;
+    odd?: true;
 };
 export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
@@ -18,6 +17,7 @@ export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceC
 interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
     paramCount: Count;
+    aliases?: string[];
 }
 export interface ParserHelpers {
     parseExpression: ParseExpression;
@@ -28,19 +28,19 @@ export interface ParserHelpers {
     parseArgument: ParseArgument;
 }
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
-interface EvaluateHelpers {
+export interface EvaluateHelpers {
     evaluateAstNode: EvaluateAstNode;
     builtin: Builtin;
+    getUndefinedSymbols: GetUndefinedSymbols;
 }
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
-    polishParse: (tokenStream: TokenStream, parseState: ParseState, firstToken: Token, parsers: ParserHelpers) => N;
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
     paramCount: Count;
-    findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {
-        findUnresolvedIdentifiers: FindUnresolvedIdentifiers;
+    getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
+        getUndefinedSymbols: GetUndefinedSymbols;
         builtin: Builtin;
         evaluateAstNode: EvaluateAstNode;
-    }) => UnresolvedIdentifiers;
+    }) => UndefinedSymbols;
 }
 export interface Builtin {
     normalExpressions: BuiltinNormalExpressions;

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface AndNode extends CommonSpecialExpressionNode<'&&'> {
 }

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+export interface ArrayNode extends CommonSpecialExpressionNode<'array'> {
+}
+export declare const arraySpecialExpression: BuiltinSpecialExpression<Any, ArrayNode>;

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface CondNode extends CommonSpecialExpressionNode<'cond'> {
 }

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

@@ -1,4 +1,4 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface DeclaredNode extends CommonSpecialExpressionNode<'defined?'> {
 }

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

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

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface DoNode extends CommonSpecialExpressionNode<'do'> {
 }

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

@@ -1,13 +1,18 @@
-import type { AstNode, CommonSpecialExpressionNode, LitsFunction, SymbolNode } from '../../parser/interface';
+import type { AstNode, CommonSpecialExpressionNode, LitsFunction, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-import type { FunctionOverload } from '../utils';
+import type { Function } from '../utils';
 export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
-    f: SymbolNode;
-    o: FunctionOverload[];
+    functionName: SymbolNode;
+    function: Function;
+}
+export interface FunctionNode extends CommonSpecialExpressionNode<'function'> {
+    functionName: SymbolNode;
+    function: Function;
 }
 export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
-    p: AstNode[];
-    o: FunctionOverload[];
+    params: AstNode[];
+    function: 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,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface IfNode extends CommonSpecialExpressionNode<'if'> {
 }

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

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

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

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

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { AstNode, BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
+import type { AstNode, BindingNode, CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface ForNode extends CommonSpecialExpressionNode<'for'> {
     l: LoopBindingNode[];

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+export interface ObjectNode extends CommonSpecialExpressionNode<'object'> {
+}
+export declare const objectSpecialExpression: BuiltinSpecialExpression<Any, ObjectNode>;

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface OrNode extends CommonSpecialExpressionNode<'||'> {
 }

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface QqNode extends CommonSpecialExpressionNode<'??'> {
 }

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

@@ -1,4 +1,4 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface RecurNode extends CommonSpecialExpressionNode<'recur'> {
 }

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface SwitchNode extends CommonSpecialExpressionNode<'switch'> {
 }

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

@@ -1,4 +1,4 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface ThrowNode extends CommonSpecialExpressionNode<'throw'> {
 }

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { AstNode, CommonSpecialExpressionNode, SymbolNode } from '../../parser/interface';
+import type { AstNode, CommonSpecialExpressionNode, SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface TryNode extends CommonSpecialExpressionNode<'try'> {
     e: SymbolNode | undefined;

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

@@ -1,5 +1,5 @@
 import type { Any } from '../../interface';
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface UnlessNode extends CommonSpecialExpressionNode<'unless'> {
 }

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

@@ -1,18 +1,9 @@
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { AstNode, BindingNode } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { AstNode, BindingTarget } 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 interface Function {
+    arguments: BindingTarget[];
+    body: AstNode[];
 }
 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,7 @@
-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 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 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>;
+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 } 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;
 }
-export declare function createContextStack(params?: LitsParams): ContextStack;
+export declare function createContextStack(params?: ContextParams): ContextStack;

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

@@ -1,8 +1,8 @@
 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 { EvaluateAstNode, ExecuteFunction } from './interface';
 type FunctionExecutors = Record<LitsFunctionType, (fn: any, params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, helpers: {
     evaluateAstNode: EvaluateAstNode;
     executeFunction: ExecuteFunction;

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

@@ -1,4 +1,4 @@
-import type { Ast, AstNode } from '../parser/interface';
+import type { Ast, AstNode } from '../parser/types';
 import type { Any } from '../interface';
 import type { ContextStack } from './ContextStack';
 export declare function evaluate(ast: Ast, contextStack: ContextStack): Any;

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

@@ -1,6 +1,6 @@
 import type { Any, Arr } from '../interface';
-import type { AstNode, BuiltinFunction } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { AstNode, BuiltinFunction } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { ContextStack } from './ContextStack';
 export interface ContextEntry {
     value: Any;
@@ -8,5 +8,5 @@ export interface ContextEntry {
 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 LookUpResult = ContextEntry | BuiltinFunction | 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 { EvaluateAstNode } from '../evaluator/interface';
+import type { Ast, AstNode } from '../parser/types';
+export type UndefinedSymbols = Set<string>;
+export declare const getUndefinedSymbols: GetUndefinedSymbols;
+export type GetUndefinedSymbols = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin, evaluateAstNode: EvaluateAstNode) => 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/{AlgebraicParser.d.ts → Parser.d.ts}

@@ -1,13 +1,12 @@
 import type { CondNode } from '../builtin/specialExpressions/cond';
+import type { FunctionNode } from '../builtin/specialExpressions/functions';
 import type { IfNode } from '../builtin/specialExpressions/if';
-import type { LetNode } from '../builtin/specialExpressions/let';
 import type { SwitchNode } from '../builtin/specialExpressions/switch';
 import type { UnlessNode } from '../builtin/specialExpressions/unless';
-import type { Arity, FunctionArguments } from '../builtin/utils';
-import type { A_ReservedSymbolToken, A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
-import type { TokenStream } from '../tokenizer/interface';
-import type { AstNode, ParseState } from './interface';
-export declare class AlgebraicParser {
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { ReservedSymbolToken, SymbolToken } from '../tokenizer/token';
+import type { AstNode, BindingTarget, ParseState } from './types';
+export declare class Parser {
     private readonly tokenStream;
     private parseState;
     constructor(tokenStream: TokenStream, parseState: ParseState);
@@ -22,11 +21,10 @@ export declare class AlgebraicParser {
     private parseArray;
     private parseFunctionCall;
     parseLambdaFunction(): AstNode | null;
-    parseFunctionArguments(): {
-        functionArguments: FunctionArguments;
-        arity: Arity;
-    };
+    parseFunctionArguments(): BindingTarget[];
     private parseShorthandLamdaFunction;
+    private parseOptionalDefaulValue;
+    private parseBindingTarget;
     private parseLet;
     private parseDo;
     private parseLoop;
@@ -34,11 +32,16 @@ export declare class AlgebraicParser {
     private parseForOrDoseq;
     private parseForLoopBinding;
     private parseBinding;
-    parseIfOrUnless(token: A_SymbolToken): IfNode | UnlessNode;
-    parseCond(token: A_SymbolToken): CondNode;
-    parseSwitch(token: A_SymbolToken): SwitchNode;
-    parseFunction(token: A_ReservedSymbolToken<'function'>): LetNode;
+    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 parseSymbol;
+    private parseReservedSymbol;
+    private parseNumber;
+    private parseString;
+    private parseRegexpShorthand;
 }