meriyah 6.1.0 → 6.1.1

package/dist/types/common.d.ts

@@ -1,6 +1,7 @@
 import { Token } from './token';
 import { Errors } from './errors';
-import { type Node, type Decorator, type SourceLocation } from './estree';
+import type * as ESTree from './estree';
+import { type Parser } from './parser/parser';
 export declare const enum Context {
     None = 0,
     OptionsNext = 1,
@@ -133,9 +134,9 @@ export declare const enum ScopeKind {
     ArrowParams = 1024,
     CatchIdentifier = 2048
 }
-export type OnComment = (type: string, value: string, start: number, end: number, loc: SourceLocation) => any;
+export type OnComment = (type: ESTree.CommentType, value: string, start: number, end: number, loc: ESTree.SourceLocation) => any;
 export type OnInsertedSemicolon = (pos: number) => any;
-export type OnToken = (token: string, start: number, end: number, loc: SourceLocation) => any;
+export type OnToken = (token: string, start: number, end: number, loc: ESTree.SourceLocation) => any;
 export interface ScopeState {
     parent: ScopeState | undefined;
     type: ScopeKind;
@@ -154,72 +155,38 @@ export interface PrivateScopeState {
 export interface ScopeError {
     type: Errors;
     params: string[];
-    index: number;
-    line: number;
-    column: number;
-    tokenIndex: number;
-    tokenLine: number;
-    tokenColumn: number;
+    start: Location;
+    end: Location;
 }
-export interface ParserState {
-    source: string;
-    end: number;
-    flags: Flags;
-    index: number;
-    line: number;
-    column: number;
-    tokenIndex: number;
-    tokenColumn: number;
-    tokenLine: number;
-    startIndex: number;
-    startColumn: number;
-    startLine: number;
-    getToken(): Token;
-    setToken(token: Token, replaceLast?: boolean): Token;
-    onComment: OnComment | void;
-    onInsertedSemicolon: OnInsertedSemicolon | void;
-    onToken: OnToken | void;
-    tokenValue: any;
-    tokenRaw: string;
-    tokenRegExp: void | {
-        pattern: string;
-        flags: string;
-    };
-    sourceFile: string | void;
-    assignable: AssignmentKind | DestructuringKind;
-    destructible: AssignmentKind | DestructuringKind;
-    currentChar: number;
-    exportedNames: any;
-    exportedBindings: any;
-    leadingDecorators: Decorator[];
-}
-export declare function matchOrInsertSemicolon(parser: ParserState, context: Context): void;
-export declare function isValidStrictMode(parser: ParserState, index: number, tokenIndex: number, tokenValue: string): 0 | 1;
-export declare function optionalBit(parser: ParserState, context: Context, t: Token): 0 | 1;
-export declare function consumeOpt(parser: ParserState, context: Context, t: Token): boolean;
-export declare function consume(parser: ParserState, context: Context, t: Token): void;
-export declare function reinterpretToPattern(state: ParserState, node: any): void;
-export declare function validateBindingIdentifier(parser: ParserState, context: Context, kind: BindingKind, t: Token, skipEvalArgCheck: 0 | 1): void;
-export declare function validateFunctionName(parser: ParserState, context: Context, t: Token): void;
-export declare function isStrictReservedWord(parser: ParserState, context: Context, t: Token): boolean;
+export declare function matchOrInsertSemicolon(parser: Parser, context: Context): void;
+export declare function isValidStrictMode(parser: Parser, index: number, tokenIndex: number, tokenValue: string): 0 | 1;
+export declare function optionalBit(parser: Parser, context: Context, t: Token): 0 | 1;
+export declare function consumeOpt(parser: Parser, context: Context, t: Token): boolean;
+export declare function consume(parser: Parser, context: Context, t: Token): void;
+export declare function reinterpretToPattern(state: Parser, node: any): void;
+export declare function validateBindingIdentifier(parser: Parser, context: Context, kind: BindingKind, t: Token, skipEvalArgCheck: 0 | 1): void;
+export declare function validateFunctionName(parser: Parser, context: Context, t: Token): void;
+export declare function isStrictReservedWord(parser: Parser, context: Context, t: Token): boolean;
 export declare function isPropertyWithPrivateFieldKey(expr: any): boolean;
-export declare function isValidLabel(parser: ParserState, labels: any, name: string, isIterationStatement: 0 | 1): 0 | 1;
-export declare function validateAndDeclareLabel(parser: ParserState, labels: any, name: string): void;
-export declare function finishNode<T extends Node>(parser: ParserState, context: Context, start: number, line: number, column: number, node: T): T;
-export declare function createArrowHeadParsingScope(parser: ParserState, context: Context, value: string): ScopeState;
-export declare function recordScopeError(parser: ParserState, type: Errors, ...params: string[]): ScopeError;
+export declare function isValidLabel(parser: Parser, labels: any, name: string, isIterationStatement: 0 | 1): 0 | 1;
+export declare function validateAndDeclareLabel(parser: Parser, labels: any, name: string): void;
+export declare function createArrowHeadParsingScope(parser: Parser, context: Context, value: string): ScopeState;
+export declare function recordScopeError(parser: Parser, type: Errors, ...params: string[]): ScopeError;
 export declare function createScope(): ScopeState;
 export declare function addChildScope(parent: ScopeState | undefined, type: ScopeKind): ScopeState;
 export declare function addChildPrivateScope(parent: PrivateScopeState | undefined): PrivateScopeState;
-export declare function addVarOrBlock(parser: ParserState, context: Context, scope: ScopeState, name: string, kind: BindingKind, origin: Origin): void;
-export declare function addBlockName(parser: ParserState, context: Context, scope: any, name: string, kind: BindingKind, origin: Origin): void;
-export declare function addVarName(parser: ParserState, context: Context, scope: ScopeState, name: string, kind: BindingKind): void;
-export declare function addPrivateIdentifier(parser: ParserState, scope: PrivateScopeState, name: string, kind: PropertyKind): void;
-export declare function addPrivateIdentifierRef(parser: ParserState, scope: PrivateScopeState, name: string): void;
+export declare function addVarOrBlock(parser: Parser, context: Context, scope: ScopeState, name: string, kind: BindingKind, origin: Origin): void;
+export declare function addBlockName(parser: Parser, context: Context, scope: any, name: string, kind: BindingKind, origin: Origin): void;
+export declare function addVarName(parser: Parser, context: Context, scope: ScopeState, name: string, kind: BindingKind): void;
+export declare function addPrivateIdentifier(parser: Parser, scope: PrivateScopeState, name: string, kind: PropertyKind): void;
+export declare function addPrivateIdentifierRef(parser: Parser, scope: PrivateScopeState, name: string): void;
 export declare function validatePrivateIdentifierRefs(scope: PrivateScopeState): void;
-export declare function declareUnboundVariable(parser: ParserState, name: string): void;
-export declare function addBindingToExports(parser: ParserState, name: string): void;
-export declare function pushComment(context: Context, array: any[]): OnComment;
-export declare function pushToken(context: Context, array: any[]): OnToken;
+export declare function declareUnboundVariable(parser: Parser, name: string): void;
+export declare function addBindingToExports(parser: Parser, name: string): void;
 export declare function isValidIdentifier(context: Context, t: Token): boolean;
-export declare function classifyIdentifier(parser: ParserState, context: Context, t: Token): any;
+export declare function classifyIdentifier(parser: Parser, context: Context, t: Token): any;
+export type Location = {
+    index: number;
+    line: number;
+    column: number;
+};

package/dist/types/errors.d.ts

@@ -1,5 +1,6 @@
 import { type _Node, type SourceLocation } from './estree';
-import { type ParserState, type ScopeError } from './common';
+import { type ScopeError, type Location } from './common';
+import { type Parser } from './parser/parser';
 export declare const enum Errors {
     Unexpected = 0,
     StrictOctalEscape = 1,
@@ -189,9 +190,9 @@ export declare class ParseError extends SyntaxError implements _Node {
     range: [number, number];
     loc: SourceLocation;
     description: string;
-    constructor(start: number, startLine: number, startColumn: number, end: number, endLine: number, endColumn: number, type: Errors, ...params: string[]);
+    constructor(start: Location, end: Location, type: Errors, ...params: string[]);
 }
-export declare function report(parser: ParserState, type: Errors, ...params: string[]): never;
+export declare function report(parser: Parser, type: Errors, ...params: string[]): never;
 export declare function reportScopeError(scope: ScopeError): never;
-export declare function reportMessageAt(tokenIndex: number, tokenLine: number, tokenColumn: number, index: number, line: number, column: number, type: Errors, ...params: string[]): never;
-export declare function reportScannerError(tokenIndex: number, tokenLine: number, tokenColumn: number, index: number, line: number, column: number, type: Errors): never;
+export declare function reportMessageAt(start: Location, end: Location, type: Errors, ...params: string[]): never;
+export declare function reportScannerError(start: Location, end: Location, type: Errors): never;

package/dist/types/estree.d.ts

@@ -17,12 +17,9 @@ export type Labels = any;
 export type IdentifierOrExpression = Identifier | Expression | ArrowFunctionExpression;
 export type ArgumentExpression = ArrayExpression | AssignmentExpression | ConditionalExpression | Literal | SpreadElement | BinaryExpression | LogicalExpression | SequenceExpression;
 export type CommentType = 'SingleLine' | 'MultiLine' | 'HTMLOpen' | 'HTMLClose' | 'HashbangComment';
-export interface Comment {
+export interface Comment extends _Node {
     type: CommentType;
     value: string;
-    start?: number;
-    end?: number;
-    loc?: SourceLocation | null;
 }
 export type Node = ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | BinaryExpression | BlockStatement | BreakStatement | CallExpression | ChainExpression | ImportExpression | CatchClause | ClassBody | ClassDeclaration | ClassExpression | ConditionalExpression | ContinueStatement | DebuggerStatement | Decorator | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ExpressionStatement | PropertyDefinition | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | Import | ImportDeclaration | ImportDefaultSpecifier | ImportAttribute | ImportNamespaceSpecifier | ImportSpecifier | JSXNamespacedName | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXMemberExpression | JSXText | LabeledStatement | Literal | LogicalExpression | MemberExpression | MetaProperty | MethodDefinition | NewExpression | ObjectExpression | ObjectPattern | ParenthesizedExpression | PrivateIdentifier | Program | Property | RegExpLiteral | RestElement | ReturnStatement | SequenceExpression | SpreadElement | StaticBlock | Super | SwitchCase | SwitchStatement | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThrowStatement | TryStatement | UpdateExpression | UnaryExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | YieldExpression;
 export type BindingPattern = ArrayPattern | ObjectPattern | Identifier;
@@ -122,7 +119,7 @@ export interface CallExpression extends _Node {
     type: 'CallExpression';
     callee: any;
     arguments: (Expression | SpreadElement)[];
-    optional?: boolean;
+    optional: boolean;
 }
 export interface CatchClause extends _Node {
     type: 'CatchClause';
@@ -212,6 +209,7 @@ export interface ExportSpecifier extends _Node {
 export interface ExpressionStatement extends _Node {
     type: 'ExpressionStatement';
     expression: Expression;
+    directive?: string;
 }
 export interface ForInStatement extends _Node {
     type: 'ForInStatement';
@@ -364,8 +362,8 @@ export interface MemberExpression extends _Node {
     type: 'MemberExpression';
     object: Expression | Super;
     property: Expression | PrivateIdentifier;
-    computed?: boolean;
-    optional?: boolean;
+    computed: boolean;
+    optional: boolean;
 }
 export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
 export interface MetaProperty extends _Node {

package/dist/types/lexer/comments.d.ts

@@ -1,5 +1,7 @@
 import { LexerState } from './common';
-import { Context, type ParserState } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
+import type * as ESTree from '../estree';
 export declare const enum CommentType {
     Single = 0,
     Multi = 1,
@@ -7,8 +9,8 @@ export declare const enum CommentType {
     HTMLClose = 3,
     HashBang = 4
 }
-export declare const CommentTypes: string[];
-export declare function skipHashBang(parser: ParserState): void;
-export declare function skipSingleHTMLComment(parser: ParserState, source: string, state: LexerState, context: Context, type: CommentType, start: number, line: number, column: number): LexerState;
-export declare function skipSingleLineComment(parser: ParserState, source: string, state: LexerState, type: CommentType, start: number, line: number, column: number): LexerState;
-export declare function skipMultiLineComment(parser: ParserState, source: string, state: LexerState): LexerState | void;
+export declare const CommentTypes: ESTree.CommentType[];
+export declare function skipHashBang(parser: Parser): void;
+export declare function skipSingleHTMLComment(parser: Parser, source: string, state: LexerState, context: Context, type: CommentType, start: number, line: number, column: number): LexerState;
+export declare function skipSingleLineComment(parser: Parser, source: string, state: LexerState, type: CommentType, start: number, line: number, column: number): LexerState;
+export declare function skipMultiLineComment(parser: Parser, source: string, state: LexerState): LexerState | void;

package/dist/types/lexer/common.d.ts

@@ -1,5 +1,5 @@
 import { Token } from '../token';
-import { type ParserState } from '../common';
+import { type Parser } from '../parser/parser';
 export declare const enum LexerState {
     None = 0,
     NewLine = 1,
@@ -16,10 +16,10 @@ export declare const enum NumberKind {
     ValidBigIntKind = 128,
     DecimalNumberKind = 48
 }
-export declare function advanceChar(parser: ParserState): number;
-export declare function consumePossibleSurrogatePair(parser: ParserState): number;
-export declare function consumeLineFeed(parser: ParserState, state: LexerState): void;
-export declare function scanNewLine(parser: ParserState): void;
+export declare function advanceChar(parser: Parser): number;
+export declare function consumePossibleSurrogatePair(parser: Parser): number;
+export declare function consumeLineFeed(parser: Parser, state: LexerState): void;
+export declare function scanNewLine(parser: Parser): void;
 export declare function isExoticECMAScriptWhitespace(ch: number): boolean;
 export declare function toHex(code: number): number;
 export declare function convertTokenType(t: Token): string;

package/dist/types/lexer/identifier.d.ts

@@ -1,8 +1,9 @@
-import { type ParserState, Context } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { Token } from '../token';
-export declare function scanIdentifier(parser: ParserState, context: Context, isValidAsKeyword: 0 | 1): Token;
-export declare function scanUnicodeIdentifier(parser: ParserState, context: Context): Token;
-export declare function scanIdentifierSlowCase(parser: ParserState, context: Context, hasEscape: 0 | 1, isValidAsKeyword: number): Token;
-export declare function scanPrivateIdentifier(parser: ParserState): Token;
-export declare function scanIdentifierUnicodeEscape(parser: ParserState): number;
-export declare function scanUnicodeEscape(parser: ParserState): number;
+export declare function scanIdentifier(parser: Parser, context: Context, isValidAsKeyword: 0 | 1): Token;
+export declare function scanUnicodeIdentifier(parser: Parser, context: Context): Token;
+export declare function scanIdentifierSlowCase(parser: Parser, context: Context, hasEscape: 0 | 1, isValidAsKeyword: number): Token;
+export declare function scanPrivateIdentifier(parser: Parser): Token;
+export declare function scanIdentifierUnicodeEscape(parser: Parser): number;
+export declare function scanUnicodeEscape(parser: Parser): number;

package/dist/types/lexer/jsx.d.ts

@@ -1,6 +1,7 @@
 import { Token } from '../token';
-import { type ParserState, Context } from '../common';
-export declare function scanJSXAttributeValue(parser: ParserState, context: Context): Token;
-export declare function scanJSXString(parser: ParserState, context: Context): Token;
-export declare function nextJSXToken(parser: ParserState, context: Context): void;
-export declare function rescanJSXIdentifier(parser: ParserState): Token;
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
+export declare function scanJSXAttributeValue(parser: Parser, context: Context): Token;
+export declare function scanJSXString(parser: Parser, context: Context): Token;
+export declare function nextJSXToken(parser: Parser, context: Context): void;
+export declare function rescanJSXIdentifier(parser: Parser): Token;

package/dist/types/lexer/numeric.d.ts

@@ -1,5 +1,6 @@
-import { type ParserState, Context } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { Token } from '../token';
 import { NumberKind } from './common';
-export declare function scanNumber(parser: ParserState, context: Context, kind: NumberKind): Token;
-export declare function scanDecimalDigitsOrSeparator(parser: ParserState, char: number): string;
+export declare function scanNumber(parser: Parser, context: Context, kind: NumberKind): Token;
+export declare function scanDecimalDigitsOrSeparator(parser: Parser, char: number): string;

package/dist/types/lexer/regexp.d.ts

@@ -1,3 +1,4 @@
-import { Context, type ParserState } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { Token } from '../token';
-export declare function scanRegularExpression(parser: ParserState, context: Context): Token;
+export declare function scanRegularExpression(parser: Parser, context: Context): Token;

package/dist/types/lexer/scan.d.ts

@@ -1,6 +1,7 @@
 import { Token } from '../token';
-import { type ParserState, Context } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { LexerState } from './common';
 export declare const TokenLookup: Token[];
-export declare function nextToken(parser: ParserState, context: Context): void;
-export declare function scanSingleToken(parser: ParserState, context: Context, state: LexerState): Token;
+export declare function nextToken(parser: Parser, context: Context): void;
+export declare function scanSingleToken(parser: Parser, context: Context, state: LexerState): Token;

package/dist/types/lexer/string.d.ts

@@ -1,4 +1,5 @@
-import { type ParserState, Context } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { Token } from '../token';
 export declare const enum Escape {
     Empty = -1,
@@ -7,6 +8,6 @@ export declare const enum Escape {
     InvalidHex = -4,
     OutOfRange = -5
 }
-export declare function scanString(parser: ParserState, context: Context, quote: number): Token;
-export declare function parseEscape(parser: ParserState, context: Context, first: number, isTemplate?: 0 | 1): number;
-export declare function handleStringError(state: ParserState, code: Escape, isTemplate: 0 | 1): void;
+export declare function scanString(parser: Parser, context: Context, quote: number): Token;
+export declare function parseEscape(parser: Parser, context: Context, first: number, isTemplate?: 0 | 1): number;
+export declare function handleStringError(state: Parser, code: Escape, isTemplate: 0 | 1): void;

package/dist/types/lexer/template.d.ts

@@ -1,4 +1,5 @@
-import { type ParserState, Context } from '../common';
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
 import { Token } from '../token';
-export declare function scanTemplate(parser: ParserState, context: Context): Token;
-export declare function scanTemplateTail(parser: ParserState, context: Context): Token;
+export declare function scanTemplate(parser: Parser, context: Context): Token;
+export declare function scanTemplateTail(parser: Parser, context: Context): Token;

package/dist/types/parser/parser.d.ts

@@ -0,0 +1,51 @@
+import { Token } from '../token';
+import type * as ESTree from '../estree';
+import { type Location, Flags, type OnComment, type OnInsertedSemicolon, type OnToken, type AssignmentKind, type DestructuringKind } from '../common';
+export type ParserOptions = {
+    shouldAddLoc?: boolean;
+    shouldAddRanges?: boolean;
+    sourceFile?: string;
+    onComment?: OnComment;
+    onInsertedSemicolon?: OnInsertedSemicolon;
+    onToken?: OnToken;
+};
+export declare class Parser {
+    readonly source: string;
+    readonly options: ParserOptions;
+    private lastOnToken;
+    token: Token;
+    flags: Flags;
+    index: number;
+    line: number;
+    column: number;
+    startIndex: number;
+    end: number;
+    tokenIndex: number;
+    startColumn: number;
+    tokenColumn: number;
+    tokenLine: number;
+    startLine: number;
+    tokenValue: any;
+    tokenRaw: string;
+    tokenRegExp: void | {
+        pattern: string;
+        flags: string;
+    };
+    currentChar: number;
+    exportedNames: Record<string, number>;
+    exportedBindings: Record<string, number>;
+    assignable: AssignmentKind | DestructuringKind;
+    destructible: AssignmentKind | DestructuringKind;
+    leadingDecorators: {
+        start?: Location;
+        decorators: ESTree.Decorator[];
+    };
+    constructor(source: string, options?: ParserOptions);
+    getToken(): Token;
+    setToken(value: Token, replaceLast?: boolean): Token;
+    get tokenStart(): Location;
+    get currentLocation(): Location;
+    finishNode<T extends ESTree.Node>(node: T, start: Location, end: Location | void): T;
+}
+export declare function pushComment(comments: ESTree.Comment[], options: ParserOptions): OnComment;
+export declare function pushToken(tokens: any[], options: ParserOptions): OnToken;