meriyah 6.1.2 → 6.1.4

package/dist/types/common.d.ts

@@ -1,38 +1,27 @@
 import { Token } from './token';
-import { Errors } from './errors';
-import type * as ESTree from './estree';
 import { type Parser } from './parser/parser';
 export declare const enum Context {
     None = 0,
-    OptionsNext = 1,
-    OptionsRanges = 2,
-    OptionsLoc = 4,
-    OptionsJSX = 8,
-    OptionsLexical = 16,
-    OptionsPreserveParens = 32,
-    OptionsWebCompat = 64,
-    OptionsRaw = 128,
-    Strict = 256,
-    Module = 512,
-    InSwitch = 1024,
-    InGlobal = 2048,
-    InClass = 4096,
-    AllowRegExp = 8192,
-    TaggedTemplate = 16384,
-    InIteration = 32768,
-    SuperProperty = 65536,
-    SuperCall = 131072,
-    InYieldContext = 262144,
-    InAwaitContext = 524288,
-    InReturnContext = 1048576,
-    InArgumentList = 2097152,
-    InConstructor = 4194304,
-    InMethodOrFunction = 8388608,
-    AllowNewTarget = 16777216,
-    DisallowIn = 33554432,
-    AllowEscapedKeyword = 67108864,
-    OptionsUniqueKeyInPattern = 134217728,
-    InStaticBlock = 268435456
+    Strict = 1,
+    Module = 2,
+    InSwitch = 4,
+    InGlobal = 8,
+    InClass = 16,
+    AllowRegExp = 32,
+    TaggedTemplate = 64,
+    InIteration = 128,
+    SuperProperty = 256,
+    SuperCall = 512,
+    InYieldContext = 1024,
+    InAwaitContext = 2048,
+    InReturnContext = 4096,
+    InArgumentList = 8192,
+    InConstructor = 16384,
+    InMethodOrFunction = 32768,
+    AllowNewTarget = 65536,
+    DisallowIn = 131072,
+    AllowEscapedKeyword = 262144,
+    InStaticBlock = 524288
 }
 export declare const enum PropertyKind {
     None = 0,
@@ -119,74 +108,23 @@ export declare const enum HoistedFunctionFlags {
     Hoisted = 1,
     Export = 2
 }
-export declare const enum ScopeKind {
-    None = 0,
-    ForStatement = 1,
-    Block = 2,
-    CatchStatement = 4,
-    SwitchStatement = 8,
-    ArgList = 16,
-    TryStatement = 32,
-    CatchBlock = 64,
-    FunctionBody = 128,
-    FunctionRoot = 256,
-    FunctionParams = 512,
-    ArrowParams = 1024,
-    CatchIdentifier = 2048
-}
-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: ESTree.SourceLocation) => any;
-export interface ScopeState {
-    parent: ScopeState | undefined;
-    type: ScopeKind;
-    scopeError?: ScopeError | null;
-}
-export interface PrivateScopeState {
-    parent: PrivateScopeState | undefined;
-    refs: {
-        [name: string]: {
-            index: number;
-            line: number;
-            column: number;
-        }[];
-    };
-}
-export interface ScopeError {
-    type: Errors;
-    params: string[];
-    start: Location;
-    end: Location;
-}
 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 reinterpretToPattern(parser: 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: 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: 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: 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: Parser, context: Context, t: Token): any;
 export type Location = {
-    index: number;
-    line: number;
-    column: number;
+    readonly index: number;
+    readonly line: number;
+    readonly column: number;
 };
+export declare function getOwnProperty<T>(object: Record<string | number, T>, key: string | number): T | undefined;

package/dist/types/errors.d.ts

@@ -1,6 +1,5 @@
 import { type _Node, type SourceLocation } from './estree';
-import { type ScopeError, type Location } from './common';
-import { type Parser } from './parser/parser';
+import { type Location } from './common';
 export declare const enum Errors {
     Unexpected = 0,
     StrictOctalEscape = 1,
@@ -181,9 +180,6 @@ export declare const enum Errors {
     InvalidAwaitAsIdentifier = 176,
     InvalidAwaitInStaticBlock = 177
 }
-export declare const errorMessages: {
-    [key: string]: string;
-};
 export declare class ParseError extends SyntaxError implements _Node {
     start: number;
     end: number;
@@ -192,7 +188,3 @@ export declare class ParseError extends SyntaxError implements _Node {
     description: string;
     constructor(start: Location, end: Location, type: Errors, ...params: string[]);
 }
-export declare function report(parser: Parser, type: Errors, ...params: string[]): never;
-export declare function reportScopeError(scope: ScopeError): 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

@@ -21,7 +21,7 @@ export interface Comment extends _Node {
     type: CommentType;
     value: string;
 }
-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 Node = AccessorProperty | 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 | 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;
 export type ClassElement = FunctionExpression | MethodDefinition;
 export type DeclarationStatement = ClassDeclaration | ClassExpression | ExportDefaultDeclaration | ExportAllDeclaration | ExportNamedDeclaration | FunctionDeclaration;
@@ -39,8 +39,8 @@ export type LeftHandSideExpression = CallExpression | ChainExpression | ImportEx
 export type LiteralExpression = Literal | TemplateLiteral;
 export type ObjectLiteralElementLike = MethodDefinition | Property | RestElement | SpreadElement;
 export type Parameter = AssignmentPattern | RestElement | ArrayPattern | ObjectPattern | Identifier;
-export type PrimaryExpression = ArrayExpression | ArrayPattern | ClassExpression | FunctionExpression | Identifier | Import | JSXElement | JSXFragment | JSXOpeningElement | Literal | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | Super | TemplateLiteral | ThisExpression;
-export type PrimaryExpressionExtended = ArrayExpression | ArrowFunctionExpression | ArrayPattern | AwaitExpression | Expression | ClassExpression | FunctionExpression | Identifier | Import | JSXElement | JSXFragment | JSXOpeningElement | Literal | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | PrivateIdentifier | NewExpression | Super | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression;
+export type PrimaryExpression = ArrayExpression | ArrayPattern | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | JSXOpeningElement | Literal | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | Super | TemplateLiteral | ThisExpression;
+export type PrimaryExpressionExtended = ArrayExpression | ArrowFunctionExpression | ArrayPattern | AwaitExpression | Expression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | JSXOpeningElement | Literal | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | PrivateIdentifier | NewExpression | Super | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression;
 export type PropertyName = Identifier | Literal;
 export type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DeclarationStatement | EmptyStatement | ExpressionStatement | IfStatement | IterationStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WithStatement;
 interface ClassDeclarationBase extends _Node {
@@ -247,9 +247,6 @@ export interface IfStatement extends _Node {
     consequent: Statement;
     alternate: Statement | null;
 }
-export interface Import extends _Node {
-    type: 'Import';
-}
 export interface ImportDeclaration extends _Node {
     type: 'ImportDeclaration';
     source: Literal;

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

@@ -18,7 +18,6 @@ export declare const enum CharFlags {
     Hyphen = 32768
 }
 export declare const CharTypes: number[];
-export declare const isIdStart: number[];
 export declare const isIdPart: number[];
 export declare function isIdentifierStart(code: number): boolean;
 export declare function isIdentifierPart(code: number): boolean;

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

@@ -1,7 +1,6 @@
 import { LexerState } from './common';
-import { Context } from '../common';
+import { Context, type Location } from '../common';
 import { type Parser } from '../parser/parser';
-import type * as ESTree from '../estree';
 export declare const enum CommentType {
     Single = 0,
     Multi = 1,
@@ -9,8 +8,7 @@ export declare const enum CommentType {
     HTMLClose = 3,
     HashBang = 4
 }
-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 skipSingleHTMLComment(parser: Parser, source: string, state: LexerState, context: Context, type: CommentType, start: Location): LexerState;
+export declare function skipSingleLineComment(parser: Parser, source: string, state: LexerState, type: CommentType, start: Location): LexerState;
 export declare function skipMultiLineComment(parser: Parser, source: string, state: LexerState): LexerState | void;

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

@@ -1,9 +1,7 @@
+import { Token } from './../token';
 import { Context } from '../common';
 import { type Parser } from '../parser/parser';
-import { Token } from '../token';
 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/index.d.ts

@@ -1,9 +1,3 @@
-export { scanSingleToken, nextToken, TokenLookup } from './scan';
-export { skipMultiLineComment, skipSingleLineComment, skipHashBang, skipSingleHTMLComment, CommentType, } from './comments';
-export { advanceChar, consumePossibleSurrogatePair, isExoticECMAScriptWhitespace, toHex, consumeLineFeed, scanNewLine, LexerState, NumberKind, convertTokenType, } from './common';
-export { CharTypes, CharFlags, isIdentifierStart, isIdentifierPart } from './charClassifier';
-export { scanIdentifier, scanIdentifierSlowCase, scanUnicodeIdentifier, scanPrivateIdentifier, scanUnicodeEscape, } from './identifier';
-export { scanString } from './string';
-export { scanNumber } from './numeric';
-export { scanTemplate, scanTemplateTail } from './template';
-export { scanRegularExpression } from './regexp';
+export { scanSingleToken, nextToken } from './scan';
+export { skipHashBang } from './comments';
+export { advanceChar, consumeLineFeed, scanNewLine, LexerState, convertTokenType } from './common';

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

@@ -1,7 +1,6 @@
 import { Token } from '../token';
-import { Context } from '../common';
+import { type 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 nextJSXToken(parser: Parser): void;
 export declare function rescanJSXIdentifier(parser: Parser): Token;

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

@@ -3,4 +3,3 @@ import { type Parser } from '../parser/parser';
 import { Token } from '../token';
 import { NumberKind } from './common';
 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,4 +1,3 @@
-import { Context } from '../common';
 import { type Parser } from '../parser/parser';
 import { Token } from '../token';
-export declare function scanRegularExpression(parser: Parser, context: Context): Token;
+export declare function scanRegularExpression(parser: Parser): Token;

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

@@ -2,6 +2,5 @@ import { Token } from '../token';
 import { Context } from '../common';
 import { type Parser } from '../parser/parser';
 import { LexerState } from './common';
-export declare const TokenLookup: 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

@@ -10,4 +10,4 @@ export declare const enum Escape {
 }
 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;
+export declare function handleStringError(parser: Parser, code: Escape, isTemplate: 0 | 1): void;

package/dist/types/meriyah.d.ts

@@ -1,8 +1,8 @@
-import { Options } from './parser';
 import { type Program } from './estree';
+import { type Options } from './options';
 declare const version: string;
 export declare function parseScript(source: string, options?: Options): Program;
 export declare function parseModule(source: string, options?: Options): Program;
 export declare function parse(source: string, options?: Options): Program;
-export { Options, version };
+export { type Options, version };
 export type * as ESTree from './estree';

package/dist/types/options.d.ts

@@ -0,0 +1,29 @@
+import type * as ESTree from './estree';
+import { type Token } from './token';
+type OnInsertedSemicolon = (pos: number) => any;
+export type OnToken = (token: string, start: number, end: number, loc: ESTree.SourceLocation) => any;
+export type OnComment = (type: ESTree.CommentType, value: string, start: number, end: number, loc: ESTree.SourceLocation) => any;
+export interface Options {
+    module?: boolean;
+    next?: boolean;
+    ranges?: boolean;
+    webcompat?: boolean;
+    loc?: boolean;
+    raw?: boolean;
+    globalReturn?: boolean;
+    impliedStrict?: boolean;
+    preserveParens?: boolean;
+    lexical?: boolean;
+    source?: string;
+    jsx?: boolean;
+    onComment?: ESTree.Comment[] | OnComment;
+    onInsertedSemicolon?: OnInsertedSemicolon;
+    onToken?: Token[] | OnToken;
+    uniqueKeyInPattern?: boolean;
+}
+export type NormalizedOptions = Omit<Options, 'onComment' | 'onToken'> & {
+    onComment?: OnComment;
+    onToken?: OnToken;
+};
+export declare function normalizeOptions(rawOptions: Options): NormalizedOptions;
+export {};

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

@@ -1,17 +1,13 @@
 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;
-};
+import { type Location, Flags, type AssignmentKind, type DestructuringKind } from '../common';
+import { Errors } from '../errors';
+import { type NormalizedOptions, type OnComment, type OnToken } from '../options';
+import { Scope, type ScopeKind } from './scope';
+import { PrivateScope } from './private-scope';
 export declare class Parser {
     readonly source: string;
-    readonly options: ParserOptions;
+    readonly options: NormalizedOptions;
     private lastOnToken;
     token: Token;
     flags: Flags;
@@ -32,20 +28,26 @@ export declare class Parser {
         flags: string;
     };
     currentChar: number;
-    exportedNames: Record<string, number>;
-    exportedBindings: Record<string, number>;
+    exportedNames: Set<string>;
+    exportedBindings: Set<string>;
     assignable: AssignmentKind | DestructuringKind;
     destructible: AssignmentKind | DestructuringKind;
     leadingDecorators: {
         start?: Location;
         decorators: ESTree.Decorator[];
     };
-    constructor(source: string, options?: ParserOptions);
+    constructor(source: string, options?: NormalizedOptions);
     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;
+    addBindingToExports(name: string): void;
+    declareUnboundVariable(name: string): void;
+    report(type: Errors, ...params: string[]): never;
+    createScopeIfLexical(type?: ScopeKind, parent?: Scope): Scope | undefined;
+    createScope(type?: ScopeKind, parent?: Scope): Scope;
+    createPrivateScopeIfLexical(parent?: PrivateScope): PrivateScope | undefined;
 }
-export declare function pushComment(comments: ESTree.Comment[], options: ParserOptions): OnComment;
-export declare function pushToken(tokens: any[], options: ParserOptions): OnToken;
+export declare function pushComment(comments: ESTree.Comment[], options: NormalizedOptions): OnComment;
+export declare function pushToken(tokens: Token[], options: NormalizedOptions): OnToken;

package/dist/types/parser/private-scope.d.ts

@@ -0,0 +1,16 @@
+import { PropertyKind, type Location } from '../common';
+import { type Parser } from './parser';
+export declare class PrivateScope {
+    readonly parser: Parser;
+    readonly parent?: PrivateScope | undefined;
+    refs: {
+        [name: string]: Location[];
+    };
+    privateIdentifiers: Map<string, PropertyKind>;
+    constructor(parser: Parser, parent?: PrivateScope | undefined);
+    addPrivateIdentifier(name: string, kind: PropertyKind): void;
+    addPrivateIdentifierRef(name: string): void;
+    isPrivateIdentifierDefined(name: string): boolean;
+    validatePrivateIdentifierRefs(): void;
+    hasPrivateIdentifier(name: string): boolean;
+}

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

@@ -0,0 +1,38 @@
+import { Errors } from '../errors';
+import { type Location, Context, BindingKind, Origin } from '../common';
+import { type Parser } from './parser';
+export declare const enum ScopeKind {
+    ForStatement = 1,
+    Block = 2,
+    CatchStatement = 4,
+    SwitchStatement = 8,
+    TryStatement = 16,
+    CatchBlock = 32,
+    FunctionBody = 64,
+    FunctionRoot = 128,
+    FunctionParams = 256,
+    ArrowParams = 512
+}
+interface ScopeError {
+    type: Errors;
+    params: string[];
+    start: Location;
+    end: Location;
+}
+export declare class Scope {
+    readonly parser: Parser;
+    readonly type: ScopeKind;
+    readonly parent?: Scope | undefined;
+    scopeError?: ScopeError;
+    variableBindings: Map<string, BindingKind>;
+    constructor(parser: Parser, type?: ScopeKind, parent?: Scope | undefined);
+    createChildScope(type?: ScopeKind): Scope;
+    addVarOrBlock(context: Context, name: string, kind: BindingKind, origin: Origin): void;
+    addVarName(context: Context, name: string, kind: BindingKind): void;
+    hasVariable(name: string): boolean;
+    addBlockName(context: Context, name: string, kind: BindingKind, origin: Origin): void;
+    recordScopeError(type: Errors, ...params: string[]): void;
+    reportScopeError(): void;
+}
+export declare function createArrowHeadParsingScope(parser: Parser, context: Context, value: string): Scope;
+export {};

package/dist/types/parser.d.ts

@@ -1,119 +1,9 @@
 import { Token } from './token';
 import type * as ESTree from './estree';
-import { Context, PropertyKind, Origin, Flags, type OnComment, type OnInsertedSemicolon, type OnToken, BindingKind, HoistedClassFlags, HoistedFunctionFlags, type ScopeState, type PrivateScopeState, type Location } from './common';
+import { Context, type Location } from './common';
 import { Parser } from './parser/parser';
-export interface Options {
-    module?: boolean;
-    next?: boolean;
-    ranges?: boolean;
-    webcompat?: boolean;
-    loc?: boolean;
-    raw?: boolean;
-    globalReturn?: boolean;
-    impliedStrict?: boolean;
-    preserveParens?: boolean;
-    lexical?: boolean;
-    source?: string;
-    jsx?: boolean;
-    onComment?: ESTree.Comment[] | OnComment;
-    onInsertedSemicolon?: OnInsertedSemicolon;
-    onToken?: Token[] | OnToken;
-    uniqueKeyInPattern?: boolean;
-}
-export declare function parseSource(source: string, options: Options | void, context: Context): ESTree.Program;
-export declare function parseStatementList(parser: Parser, context: Context, scope: ScopeState | undefined): ESTree.Statement[];
-export declare function parseModuleItemList(parser: Parser, context: Context, scope: ScopeState | undefined): ReturnType<typeof parseDirective | typeof parseModuleItem>[];
-export declare function parseModuleItem(parser: Parser, context: Context, scope: ScopeState | undefined): any;
-export declare function parseStatementListItem(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, labels: ESTree.Labels): ESTree.Statement | ESTree.Decorator[];
-export declare function parseStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, labels: ESTree.Labels, allowFuncDecl: 0 | 1): ESTree.Statement;
-export declare function parseExpressionOrLabelledStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, labels: ESTree.Labels, allowFuncDecl: 0 | 1): ESTree.ExpressionStatement | ESTree.LabeledStatement;
-export declare function parseBlock<T extends ESTree.BlockStatement | ESTree.StaticBlock = ESTree.BlockStatement>(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels, start: Location, type?: T['type']): T;
-export declare function parseReturnStatement(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.ReturnStatement;
-export declare function parseExpressionStatement(parser: Parser, context: Context, expression: ESTree.Expression, start: Location): ESTree.ExpressionStatement;
-export declare function parseLabelledStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, labels: ESTree.Labels, value: string, expr: ESTree.Identifier | ESTree.Expression, token: Token, allowFuncDecl: 0 | 1, start: Location): ESTree.LabeledStatement;
-export declare function parseAsyncArrowOrAsyncFunctionDeclaration(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, labels: ESTree.Labels, allowFuncDecl: 0 | 1): ESTree.ExpressionStatement | ESTree.LabeledStatement | ESTree.FunctionDeclaration;
+import { type Options } from './options';
+import { type Scope } from './parser/scope';
+export declare function parseSource(source: string, rawOptions?: Options, context?: Context): ESTree.Program;
+export declare function parseModuleItem(parser: Parser, context: Context, scope: Scope | undefined): any;
 export declare function parseDirective(parser: Parser, context: Context, expression: ESTree.ArgumentExpression | ESTree.SequenceExpression | ESTree.Expression, token: Token, start: Location): ESTree.ExpressionStatement;
-export declare function parseEmptyStatement(parser: Parser, context: Context): ESTree.EmptyStatement;
-export declare function parseThrowStatement(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.ThrowStatement;
-export declare function parseIfStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.IfStatement;
-export declare function parseConsequentOrAlternative(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.Statement | ESTree.FunctionDeclaration;
-export declare function parseSwitchStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.SwitchStatement;
-export declare function parseWhileStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.WhileStatement;
-export declare function parseIterationStatementBody(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.Statement;
-export declare function parseContinueStatement(parser: Parser, context: Context, labels: ESTree.Labels): ESTree.ContinueStatement;
-export declare function parseBreakStatement(parser: Parser, context: Context, labels: ESTree.Labels): ESTree.BreakStatement;
-export declare function parseWithStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.WithStatement;
-export declare function parseDebuggerStatement(parser: Parser, context: Context): ESTree.DebuggerStatement;
-export declare function parseTryStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.TryStatement;
-export declare function parseCatchBlock(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels, start: Location): ESTree.CatchClause;
-export declare function parseStaticBlock(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, start: Location): ESTree.StaticBlock;
-export declare function parseDoWhileStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.DoWhileStatement;
-export declare function parseLetIdentOrVarDeclarationStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin): ESTree.VariableDeclaration | ESTree.LabeledStatement | ESTree.ExpressionStatement;
-export declare function parseVariableStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin): ESTree.VariableDeclaration;
-export declare function parseVariableDeclarationList(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, kind: BindingKind, origin: Origin): ESTree.VariableDeclarator[];
-export declare function parseForStatement(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, labels: ESTree.Labels): ESTree.ForStatement | ESTree.ForInStatement | ESTree.ForOfStatement;
-export declare function parseRestrictedIdentifier(parser: Parser, context: Context, scope: ScopeState | undefined): ESTree.Identifier;
-export declare function parseImportMetaDeclaration(parser: Parser, context: Context, start: Location): ESTree.ExpressionStatement;
-export declare function parseExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, canAssign: 0 | 1, inGroup: 0 | 1, start: Location): ESTree.Expression;
-export declare function parseSequenceExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, start: Location, expr: ESTree.AssignmentExpression | ESTree.Expression): ESTree.SequenceExpression;
-export declare function parseExpressions(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, canAssign: 0 | 1, start: Location): ESTree.SequenceExpression | ESTree.Expression;
-export declare function parseAssignmentExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, isPattern: 0 | 1, start: Location, left: ESTree.ArgumentExpression | ESTree.Expression | null): ESTree.ArgumentExpression | ESTree.Expression;
-export declare function parseAssignmentExpressionOrPattern(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, isPattern: 0 | 1, start: Location, left: any): any;
-export declare function parseConditionalExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, test: ESTree.Expression, start: Location): ESTree.ConditionalExpression;
-export declare function parseBinaryExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, start: Location, minPrecedence: number, operator: Token, left: ESTree.ArgumentExpression | ESTree.Expression): ESTree.ArgumentExpression | ESTree.Expression;
-export declare function parseUnaryExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, isLHS: 0 | 1, inGroup: 0 | 1): ESTree.UnaryExpression;
-export declare function parseAsyncExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, isLHS: 0 | 1, canAssign: 0 | 1, inNew: 0 | 1, start: Location): ESTree.FunctionExpression | ESTree.ArrowFunctionExpression | ESTree.CallExpression | ESTree.Identifier;
-export declare function parseYieldExpressionOrIdentifier(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, canAssign: 0 | 1, start: Location): ESTree.YieldExpression | ESTree.Identifier | ESTree.ArrowFunctionExpression;
-export declare function parseAwaitExpressionOrIdentifier(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inNew: 0 | 1, inGroup: 0 | 1, start: Location): ESTree.IdentifierOrExpression | ESTree.AwaitExpression;
-export declare function parseFunctionBody(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, funcNameToken: Token | undefined, scopeError: any): ESTree.BlockStatement;
-export declare function parseSuperExpression(parser: Parser, context: Context): ESTree.Super;
-export declare function parseLeftHandSideExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, canAssign: 0 | 1, inGroup: 0 | 1, isLHS: 0 | 1): ESTree.Expression;
-export declare function parseMemberOrUpdateExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, expr: ESTree.Expression, inGroup: 0 | 1, inChain: 0 | 1, start: Location): any;
-export declare function parseOptionalChain(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, expr: ESTree.Expression, start: Location): ESTree.MemberExpression | ESTree.CallExpression;
-export declare function parsePropertyOrPrivatePropertyName(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): any;
-export declare function parseUpdateExpressionPrefixed(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inNew: 0 | 1, isLHS: 0 | 1, start: Location): ESTree.UpdateExpression;
-export declare function parsePrimaryExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, kind: BindingKind, inNew: 0 | 1, canAssign: 0 | 1, inGroup: 0 | 1, isLHS: 0 | 1, start: Location): any;
-export declare function parseImportMetaExpression(parser: Parser, context: Context, meta: ESTree.Identifier, start: Location): ESTree.MetaProperty;
-export declare function parseImportExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, start: Location): ESTree.ImportExpression;
-export declare function parseImportAttributes(parser: Parser, context: Context, specifiers?: (ESTree.ImportClause | ESTree.ExportSpecifier)[] | null): ESTree.ImportAttribute[];
-export declare function parseBigIntLiteral(parser: Parser, context: Context): ESTree.BigIntLiteral;
-export declare function parseTemplateLiteral(parser: Parser, context: Context, start: Location): ESTree.TemplateLiteral;
-export declare function parseTemplate(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.TemplateLiteral;
-export declare function parseTemplateElement(parser: Parser, context: Context, cooked: string | null, raw: string, start: Location, tail: boolean): ESTree.TemplateElement;
-export declare function parseArguments(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1): (ESTree.SpreadElement | ESTree.Expression)[];
-export declare function parseIdentifier(parser: Parser, context: Context): ESTree.Identifier;
-export declare function parseLiteral(parser: Parser, context: Context): ESTree.Literal;
-export declare function parseNullOrTrueOrFalseLiteral(parser: Parser, context: Context): ESTree.Literal;
-export declare function parseThisExpression(parser: Parser, context: Context): ESTree.ThisExpression;
-export declare function parseFunctionDeclaration(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, origin: Origin, allowGen: 0 | 1, flags: HoistedFunctionFlags, isAsync: 0 | 1, start: Location): ESTree.FunctionDeclaration;
-export declare function parseFunctionExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, isAsync: 0 | 1, inGroup: 0 | 1, start: Location): ESTree.FunctionExpression;
-export declare function parseArrayExpressionOrPattern(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, skipInitializer: 0 | 1, inGroup: 0 | 1, isPattern: 0 | 1, kind: BindingKind, origin: Origin): ESTree.ArrayExpression | ESTree.ArrayPattern | ESTree.AssignmentExpression;
-export declare function parseMethodDefinition(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, kind: PropertyKind, inGroup: 0 | 1, start: Location): ESTree.FunctionExpression;
-export declare function parseObjectLiteralOrPattern(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, skipInitializer: 0 | 1, inGroup: 0 | 1, isPattern: 0 | 1, kind: BindingKind, origin: Origin): ESTree.ObjectExpression | ESTree.ObjectPattern | ESTree.AssignmentExpression;
-export declare function parseMethodFormals(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, kind: PropertyKind, type: BindingKind, inGroup: 0 | 1): ESTree.Parameter[];
-export declare function parseComputedPropertyName(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1): ESTree.Expression;
-export declare function parseParenthesizedExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, canAssign: 0 | 1, kind: BindingKind, origin: Origin, start: Location): any;
-export declare function parseIdentifierOrArrow(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.Identifier | ESTree.ArrowFunctionExpression;
-export declare function parseArrowFunctionExpression(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, params: any, isAsync: 0 | 1, start: Location): ESTree.ArrowFunctionExpression;
-export declare function parseFormalParametersOrFormalList(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, kind: BindingKind): ESTree.Parameter[];
-export declare function parseMemberExpressionNoCall(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, expr: ESTree.Expression, inGroup: 0 | 1, start: Location): any;
-export declare function parseNewExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1): ESTree.NewExpression | ESTree.Expression | ESTree.MetaProperty;
-export declare function parseMetaProperty(parser: Parser, context: Context, meta: ESTree.Identifier, start: Location): ESTree.MetaProperty;
-export declare function parseAsyncArrowOrCallExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, callee: ESTree.Identifier | void, canAssign: 0 | 1, kind: BindingKind, origin: Origin, flags: Flags, start: Location): ESTree.CallExpression | ESTree.ArrowFunctionExpression;
-export declare function parseRegExpLiteral(parser: Parser, context: Context): ESTree.RegExpLiteral;
-export declare function parseClassDeclaration(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, flags: HoistedClassFlags): ESTree.ClassDeclaration;
-export declare function parseClassExpression(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inGroup: 0 | 1, start: Location): ESTree.ClassExpression;
-export declare function parseDecorators(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.Decorator[];
-export declare function parseDecoratorList(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, start: Location): ESTree.Decorator;
-export declare function parseClassBody(parser: Parser, context: Context, inheritedContext: Context, scope: ScopeState | undefined, parentScope: PrivateScopeState | undefined, kind: BindingKind, origin: Origin, inGroup: 0 | 1): ESTree.ClassBody;
-export declare function parsePropertyDefinition(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, key: ESTree.PrivateIdentifier | ESTree.Expression | null, state: PropertyKind, decorators: ESTree.Decorator[], start: Location): ESTree.PropertyDefinition | ESTree.AccessorProperty;
-export declare function parseBindingPattern(parser: Parser, context: Context, scope: ScopeState | undefined, privateScope: PrivateScopeState | undefined, type: BindingKind, origin: Origin): ESTree.BindingPattern;
-export declare function parseJSXOpeningFragment(parser: Parser, context: Context, start: Location): ESTree.JSXOpeningFragment;
-export declare function parseJSXClosingFragment(parser: Parser, context: Context, inJSXChild: 0 | 1, start: Location): ESTree.JSXClosingFragment;
-export declare function parseJSXChildrenAndClosingElement(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inJSXChild: 0 | 1): [ESTree.JSXChild[], ESTree.JSXClosingElement];
-export declare function parseJSXChildrenAndClosingFragment(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined, inJSXChild: 0 | 1): [ESTree.JSXChild[], ESTree.JSXClosingFragment];
-export declare function parseJSXText(parser: Parser, context: Context): ESTree.JSXText;
-export declare function parseJSXMemberExpression(parser: Parser, context: Context, object: ESTree.JSXIdentifier | ESTree.JSXMemberExpression, start: Location): ESTree.JSXMemberExpression;
-export declare function parseJSXAttributes(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): (ESTree.JSXAttribute | ESTree.JSXSpreadAttribute)[];
-export declare function parseJSXSpreadAttribute(parser: Parser, context: Context, privateScope: PrivateScopeState | undefined): ESTree.JSXSpreadAttribute;
-export declare function parseJSXIdentifier(parser: Parser, context: Context): ESTree.JSXIdentifier;

package/dist/types/unicode.d.ts

@@ -1,3 +1,2 @@
 export declare const isIDContinue: (code: number) => boolean;
 export declare const isIDStart: (code: number) => boolean;
-export declare const mustEscape: (code: number) => boolean;