@ibyar/expressions 0.5.4 → 0.5.6

package/v8/inline.d.ts

@@ -0,0 +1,177 @@
+import type { ExpressionNode } from '../api/expression.js';
+import { Token, TokenExpression } from './token.js';
+import { TokenStream } from './stream.js';
+import { Identifier, TaggedTemplateExpression, TemplateLiteral } from '../api/definition/values.js';
+import { EmptyStatement } from '../api/statement/control/empty.js';
+import { BlockStatement } from '../api/statement/control/block.js';
+import { Param, FunctionExpression, FunctionDeclaration } from '../api/definition/function.js';
+import { NewExpression } from '../api/computing/new.js';
+import { MemberExpression } from '../api/definition/member.js';
+import { ObjectExpression, Property } from '../api/definition/object.js';
+import { ArrayExpression, ArrayPattern } from '../api/definition/array.js';
+import { CallExpression } from '../api/computing/call.js';
+import { VariableDeclarationNode } from '../api/statement/declarations/declares.js';
+import { ForNode, ForOfNode, ForInNode, ForAwaitOfNode } from '../api/statement/iterations/for.js';
+import { ClassDeclaration, ClassExpression } from '../api/class/class.js';
+import { AllowLabelledFunctionStatement, FunctionBodyType, FunctionInfo, FunctionKind, FunctionSyntaxKind, LanguageMode, ParseFunctionFlag, ParsingArrowHeadFlag, PropertyKindInfo, VariableDeclarationContext } from './enums.js';
+import { DebuggerStatement } from '../api/computing/debugger.js';
+export declare type InlineParserOptions = {
+    mode?: LanguageMode;
+    acceptIN?: boolean;
+};
+export declare abstract class AbstractParser {
+    protected scanner: TokenStream;
+    protected acceptIN: boolean;
+    protected previousAcceptIN: boolean[];
+    protected functionKind: FunctionKind;
+    protected previousFunctionKind: FunctionKind[];
+    get languageMode(): LanguageMode;
+    set languageMode(mode: LanguageMode);
+    constructor(scanner: TokenStream, acceptIN?: boolean);
+    abstract scan(): ExpressionNode;
+    protected position(): number;
+    protected setAcceptIN(acceptIN: boolean): void;
+    protected restoreAcceptIN(): void;
+    protected getLastFunctionKind(): FunctionKind;
+    protected setFunctionKind(functionKind: FunctionKind): void;
+    protected restoreFunctionKind(): void;
+    protected setStatue(acceptIN: boolean, functionKind: FunctionKind): void;
+    protected restoreStatue(): void;
+    protected current(): TokenExpression;
+    protected next(): TokenExpression;
+    protected peek(): TokenExpression;
+    protected peekAhead(): TokenExpression;
+    protected peekAheadPosition(): number;
+    protected peekPosition(): number;
+    protected consume(token: Token): void;
+    protected check(token: Token): boolean;
+    protected checkAndGetValue(token: Token): ExpressionNode | undefined;
+    protected checkValue(value: ExpressionNode): boolean;
+    protected expect(token: Token): void;
+    protected expectAndGetValue(token: Token): ExpressionNode;
+    protected checkInOrOf(): 'IN' | 'OF' | false;
+    protected peekInOrOf(): 'IN' | 'OF' | false;
+    protected isArguments(name: ExpressionNode): boolean;
+    protected isEval(name: ExpressionNode): boolean;
+    protected isEvalOrArguments(name: ExpressionNode): boolean;
+    protected isNextLetKeyword(): boolean;
+    protected isIdentifier(expression: ExpressionNode): expression is Identifier;
+    protected markParenthesized(expression: ExpressionNode): void;
+    protected clearParenthesized(expression: ExpressionNode): void;
+    protected isParenthesized(expression: ExpressionNode): boolean;
+    protected isAssignableIdentifier(expression: ExpressionNode): boolean;
+    protected isPattern(expression: ExpressionNode): expression is (ObjectExpression | ArrayExpression);
+    protected isProperty(expression: ExpressionNode): expression is Property | MemberExpression;
+    protected isCallNew(expression: ExpressionNode): expression is NewExpression;
+    protected isCall(expression: ExpressionNode): expression is CallExpression;
+    protected isEmptyStatement(expression: ExpressionNode): expression is EmptyStatement;
+    protected isValidReferenceExpression(expression: ExpressionNode): boolean;
+    protected expectSemicolon(): void;
+    protected peekAnyIdentifier(): boolean;
+    protected expectContextualKeyword(keyword: string): boolean;
+    protected checkContextualKeyword(keyword: string): boolean;
+    protected peekContextualKeyword(keyword: string): boolean;
+    protected methodKindFor(isStatic: boolean, flag: ParseFunctionFlag): FunctionKind;
+    protected isGenerator(): boolean;
+    protected isAsyncFunction(): boolean;
+    protected is_async_function(): boolean;
+    protected is_async_generator(): boolean;
+    protected is_resumable(): boolean;
+    protected isAwaitAllowed(): boolean;
+    protected isAwaitAsIdentifierDisallowed(): boolean;
+    protected shouldBanArguments(): boolean;
+    protected errorMessage(message: string): string;
+    protected reportErrorMessage(message: string): void;
+}
+export declare class JavaScriptInlineParser extends AbstractParser {
+    static parse(source: string | TokenExpression[] | TokenStream, { mode, acceptIN }?: InlineParserOptions): ExpressionNode;
+    constructor(scanner: TokenStream, acceptIN?: boolean);
+    scan(): ExpressionNode;
+    protected parseStatement(allowFunction?: AllowLabelledFunctionStatement): ExpressionNode;
+    protected parseDebuggerStatement(): DebuggerStatement;
+    protected parseTryStatement(): ExpressionNode;
+    protected parseNonRestrictedIdentifier(): Identifier;
+    protected parseBlock(): BlockStatement;
+    protected parseStatementListItem(): ExpressionNode | undefined;
+    protected parseFunctionExpression(): FunctionExpression | FunctionDeclaration;
+    protected parseAsyncFunctionDeclaration(names: string[] | undefined, defaultExport: boolean): FunctionDeclaration;
+    protected parseIfStatement(): ExpressionNode;
+    protected parseScopedStatement(): ExpressionNode;
+    protected parseDoWhileStatement(): ExpressionNode;
+    protected parseWhileStatement(): ExpressionNode;
+    protected parseThrowStatement(): ExpressionNode;
+    protected parseSwitchStatement(): ExpressionNode;
+    protected parseForStatement(): ForNode | ForOfNode | ForInNode;
+    protected parseStandardForLoopWithLexicalDeclarations(initializer: VariableDeclarationNode): ForNode;
+    protected parseForEachStatementWithDeclarations(initializer: VariableDeclarationNode, forMode: 'IN' | 'OF'): ForOfNode | ForInNode;
+    protected parseForEachStatementWithoutDeclarations(initializer: ExpressionNode, forMode: 'IN' | 'OF'): ForOfNode | ForInNode;
+    protected parseStandardForLoop(initializer: ExpressionNode): ForNode;
+    protected parseForAwaitStatement(): ForAwaitOfNode;
+    protected parseVariableDeclarations(varContext: VariableDeclarationContext): VariableDeclarationNode;
+    protected parseBindingPattern(isPattern: boolean): ExpressionNode;
+    protected parseAndClassifyIdentifier(next: TokenExpression): ExpressionNode;
+    protected parseContinueStatement(): ExpressionNode;
+    protected parseBreakStatement(): ExpressionNode;
+    protected parseReturnStatement(): ExpressionNode;
+    protected parseExpressionOrLabelledStatement(allowFunction: AllowLabelledFunctionStatement): ExpressionNode;
+    protected parseExpression(): ExpressionNode;
+    protected parseFunctionDeclaration(): FunctionDeclaration;
+    protected parseAsyncFunctionLiteral(): FunctionExpression | FunctionDeclaration;
+    protected parseHoistableDeclaration(names: string[] | undefined, defaultExport: boolean): FunctionExpression | FunctionDeclaration;
+    protected parseHoistableDeclaration01(flag: FunctionKind, names: string[] | undefined, defaultExport: boolean): FunctionExpression | FunctionDeclaration;
+    protected parseIdentifier(kind?: FunctionKind): Identifier;
+    protected getIdentifier(): Identifier;
+    protected parseFunctionLiteral(flag: FunctionKind, functionSyntaxKind: FunctionSyntaxKind, name?: Identifier): FunctionDeclaration | FunctionExpression;
+    protected parseFunctionBody(kind: FunctionKind, bodyType: FunctionBodyType.BLOCK, functionSyntaxKind: FunctionSyntaxKind): ExpressionNode[];
+    protected parseFunctionBody(kind: FunctionKind, bodyType: FunctionBodyType.EXPRESSION, functionSyntaxKind: FunctionSyntaxKind): ExpressionNode;
+    protected parseAndRewriteAsyncGeneratorFunctionBody(kind: FunctionKind): ExpressionNode[];
+    protected parseAndRewriteGeneratorFunctionBody(kind: FunctionKind): ExpressionNode[];
+    protected parseAsyncFunctionBody(): ExpressionNode[];
+    protected parseStatementList(endToken: Token): ExpressionNode[];
+    protected parseFormalParameterList(functionInfo: FunctionInfo): ExpressionNode[];
+    protected parseFormalParameter(functionInfo: FunctionInfo): ExpressionNode;
+    protected parseExpressionCoverGrammar(): ExpressionNode;
+    protected parseArrowParametersWithRest(list: ExpressionNode[]): ExpressionNode;
+    protected expressionListToExpression(list: ExpressionNode[]): ExpressionNode;
+    protected parseMemberExpression(): ExpressionNode;
+    protected toParamNode(expression: ExpressionNode): Param;
+    protected parsePrimaryExpression(): ExpressionNode;
+    protected parseTemplateLiteral(tag?: ExpressionNode): ExpressionNode;
+    protected createTemplateLiteralExpressionNode(strings: string[], expressions: ExpressionNode[], tag?: ExpressionNode): TaggedTemplateExpression | TemplateLiteral;
+    protected parseMemberWithPresentNewPrefixesExpression(): ExpressionNode;
+    protected parseArguments(maybeArrow?: ParsingArrowHeadFlag): ExpressionNode[];
+    protected parseAssignmentExpressionCoverGrammar(): ExpressionNode;
+    protected parseAssignmentExpression(): ExpressionNode;
+    protected parseArrowFunctionLiteral(parameters: ExpressionNode[], kind: FunctionKind): ExpressionNode;
+    protected parseRegExpLiteral(): ExpressionNode;
+    protected parseArrayLiteral(isPattern: boolean): ArrayExpression | ArrayPattern;
+    protected parsePossibleDestructuringSubPattern(): ExpressionNode;
+    protected parseObjectLiteral(isPattern: boolean): ExpressionNode;
+    protected parseObjectPropertyDefinition(isPattern: boolean): ExpressionNode;
+    protected parseProperty(propInfo: PropertyKindInfo): ExpressionNode;
+    protected parseMemberExpressionContinuation(expression: ExpressionNode): ExpressionNode;
+    protected doParseMemberExpressionContinuation(expression: ExpressionNode): ExpressionNode;
+    protected parsePropertyOrPrivatePropertyName(): ExpressionNode;
+    protected parsePipelineExpression(expression: ExpressionNode): ExpressionNode;
+    protected parsePipelineBody(lhs: ExpressionNode): ExpressionNode;
+    protected parseConditionalExpression(): ExpressionNode;
+    protected parseLogicalExpression(): ExpressionNode;
+    protected parseBinaryContinuation(x: ExpressionNode, prec: number, prec1: number): ExpressionNode;
+    protected parseBinaryExpression(precedence: number): ExpressionNode;
+    protected parseUnaryExpression(): ExpressionNode;
+    protected parseUnaryOrPrefixExpression(): ExpressionNode;
+    protected parsePostfixExpression(): ExpressionNode;
+    protected parsePostfixContinuation(expression: ExpressionNode): ExpressionNode;
+    protected parseLeftHandSideExpression(): ExpressionNode;
+    protected parseLeftHandSideContinuation(result: ExpressionNode): ExpressionNode;
+    protected parseAwaitExpression(): ExpressionNode;
+    protected parseNullishExpression(expression: ExpressionNode): ExpressionNode;
+    protected parseConditionalContinuation(expression: ExpressionNode): ExpressionNode;
+    protected parseYieldExpression(): ExpressionNode;
+    protected parseNewTargetExpression(): ExpressionNode;
+    protected parseClassExpression(): ClassExpression;
+    protected parseClassDeclaration(names: string[] | undefined, defaultExport: boolean): ClassDeclaration;
+    protected parseClassLiteral(name: ExpressionNode | undefined, isStrictReserved: boolean): ExpressionNode;
+    protected parseSuperExpression(): ExpressionNode;
+    protected parseImportExpressions(): ExpressionNode;
+}