meriyah 6.1.3 → 7.0.0

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';
+import { Token } from './token';
 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,22 @@ 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;
 };

package/dist/types/errors.d.ts

@@ -1,6 +1,5 @@
+import { type Location } from './common';
 import { type _Node, type SourceLocation } from './estree';
-import { type ScopeError, type Location } from './common';
-import { type Parser } from './parser/parser';
 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 | 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 | 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;
@@ -29,7 +29,6 @@ export type EntityName = Identifier;
 export type ExportDeclaration = ClassDeclaration | ClassExpression | FunctionDeclaration | VariableDeclaration;
 export type Expression = ArrowFunctionExpression | AssignmentExpression | BinaryExpression | ConditionalExpression | MetaProperty | ChainExpression | JSXClosingElement | JSXClosingFragment | JSXExpressionContainer | JSXOpeningElement | JSXOpeningFragment | JSXSpreadChild | LogicalExpression | NewExpression | RestElement | SequenceExpression | SpreadElement | AwaitExpression | LeftHandSideExpression | UnaryExpression | UpdateExpression | YieldExpression;
 export type ForInitializer = Expression | VariableDeclaration;
-export { ForInitializer as ForInitialiser };
 export type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier;
 export type IterationStatement = DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | WhileStatement;
 export type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText;
@@ -39,8 +38,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 {
@@ -90,9 +89,6 @@ export interface AwaitExpression extends _Node {
     type: 'AwaitExpression';
     argument: Expression;
 }
-export interface BigIntLiteral extends Literal {
-    bigint: string;
-}
 export interface BinaryExpression extends _Node {
     type: 'BinaryExpression';
     operator: string;
@@ -186,8 +182,8 @@ export interface EmptyStatement extends _Node {
 }
 export interface ExportAllDeclaration extends _Node {
     type: 'ExportAllDeclaration';
-    source: Literal;
-    exported: Identifier | Literal | null;
+    source: StringLiteral;
+    exported: Identifier | StringLiteral | null;
     attributes: ImportAttribute[];
 }
 export interface ExportDefaultDeclaration extends _Node {
@@ -198,13 +194,13 @@ export interface ExportNamedDeclaration extends _Node {
     type: 'ExportNamedDeclaration';
     declaration: ExportDeclaration | null;
     specifiers: ExportSpecifier[];
-    source: Literal | null;
+    source: StringLiteral | null;
     attributes: ImportAttribute[];
 }
 export interface ExportSpecifier extends _Node {
     type: 'ExportSpecifier';
-    local: Identifier | Literal;
-    exported: Identifier | Literal;
+    local: Identifier | StringLiteral;
+    exported: Identifier | StringLiteral;
 }
 export interface ExpressionStatement extends _Node {
     type: 'ExpressionStatement';
@@ -247,19 +243,16 @@ 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;
+    source: StringLiteral;
     specifiers: ImportClause[];
     attributes: ImportAttribute[];
 }
 export interface ImportAttribute extends _Node {
     type: 'ImportAttribute';
-    key: Identifier | Literal;
-    value: Literal;
+    key: Identifier | StringLiteral;
+    value: StringLiteral;
 }
 export interface ImportDefaultSpecifier extends _Node {
     type: 'ImportDefaultSpecifier';
@@ -272,7 +265,7 @@ export interface ImportNamespaceSpecifier extends _Node {
 export interface ImportSpecifier extends _Node {
     type: 'ImportSpecifier';
     local: Identifier;
-    imported: Identifier | Literal;
+    imported: Identifier | StringLiteral;
 }
 export interface JSXNamespacedName extends _Node {
     type: 'JSXNamespacedName';
@@ -347,11 +340,34 @@ export interface LabeledStatement extends _Node {
     label: Identifier;
     body: Statement;
 }
-export interface Literal extends _Node {
+export type Literal = StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral | BigIntLiteral | RegExpLiteral;
+export interface _LiteralBase extends _Node {
     type: 'Literal';
-    value: boolean | number | string | null | RegExp | bigint;
     raw?: string;
 }
+export interface StringLiteral extends _LiteralBase {
+    value: string;
+}
+export interface NumericLiteral extends _LiteralBase {
+    value: number;
+}
+export interface BooleanLiteral extends _LiteralBase {
+    value: boolean;
+}
+export interface NullLiteral extends _LiteralBase {
+    value: null;
+}
+export interface BigIntLiteral extends _LiteralBase {
+    value: bigint;
+    bigint: string;
+}
+export interface RegExpLiteral extends _LiteralBase {
+    value: RegExp | null;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+}
 export interface LogicalExpression extends _Node {
     type: 'LogicalExpression';
     operator: string;
@@ -411,12 +427,6 @@ export interface Property extends _Node {
     shorthand: boolean;
     kind: 'init' | 'get' | 'set';
 }
-export interface RegExpLiteral extends Literal {
-    regex: {
-        pattern: string;
-        flags: string;
-    };
-}
 export interface RestElement extends _Node {
     type: 'RestElement';
     argument: BindingPattern | Identifier | Expression | PropertyName;
@@ -519,3 +529,4 @@ export interface YieldExpression extends _Node {
     delegate: boolean;
     argument?: Expression | null;
 }
+export {};

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';
+import { LexerState } from './common';
 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/common.d.ts

@@ -1,5 +1,5 @@
-import { Token } from '../token';
 import { type Parser } from '../parser/parser';
+import { Token } from '../token';
 export declare const enum LexerState {
     None = 0,
     NewLine = 1,

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

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

@@ -1,7 +1,6 @@
-import { Token } from '../token';
 import { Context } from '../common';
 import { type Parser } from '../parser/parser';
+import { Token } from '../token';
 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 parseScript(source: string, options?: Omit<Options, 'sourceType'>): Program;
+export declare function parseModule(source: string, options?: Omit<Options, 'sourceType'>): 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,32 @@
+import type * as ESTree from './estree';
+import { type Token } from './token';
+type OnInsertedSemicolon = (pos: number) => any;
+type SourceType = 'script' | 'module' | 'commonjs';
+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 {
+    sourceType?: SourceType;
+    next?: boolean;
+    ranges?: boolean;
+    webcompat?: boolean;
+    loc?: boolean;
+    raw?: boolean;
+    impliedStrict?: boolean;
+    preserveParens?: boolean;
+    lexical?: boolean;
+    source?: string;
+    jsx?: boolean;
+    onComment?: ESTree.Comment[] | OnComment;
+    onInsertedSemicolon?: OnInsertedSemicolon;
+    onToken?: Token[] | OnToken;
+    validateRegex?: boolean;
+    module?: boolean;
+    globalReturn?: boolean;
+}
+export type NormalizedOptions = Omit<Options, 'validateRegex' | 'onComment' | 'onToken'> & {
+    validateRegex: boolean;
+    onComment?: OnComment;
+    onToken?: OnToken;
+};
+export declare function normalizeOptions(rawOptions: Options): NormalizedOptions;
+export {};

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

@@ -1,18 +1,14 @@
-import { Token } from '../token';
+import { type AssignmentKind, type DestructuringKind, Flags, type Location } from '../common';
+import { Errors } from '../errors';
 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 NormalizedOptions, type Options } from '../options';
+import { Token } from '../token';
+import { PrivateScope } from './private-scope';
+import { Scope, type ScopeKind } from './scope';
 export declare class Parser {
     readonly source: string;
-    readonly options: ParserOptions;
     private lastOnToken;
+    options: NormalizedOptions;
     token: Token;
     flags: Flags;
     index: number;
@@ -32,20 +28,27 @@ 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, rawOptions?: Options);
     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;
+    cloneIdentifier(original: ESTree.Identifier): ESTree.Identifier;
+    cloneStringLiteral(original: ESTree.StringLiteral): ESTree.StringLiteral;
+    private cloneLocationInformation;
 }
-export declare function pushComment(comments: ESTree.Comment[], options: ParserOptions): OnComment;
-export declare function pushToken(tokens: any[], options: ParserOptions): OnToken;

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

@@ -0,0 +1,16 @@
+import { type Location, PropertyKind } 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 { BindingKind, Context, type Location, Origin } from '../common';
+import { Errors } from '../errors';
+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 {};