meriyah 6.0.6 → 6.1.1

package/dist/{src → types}/chars.d.ts

@@ -133,4 +133,3 @@ export declare const enum Chars {
     UTF16Max = 65535,
     NonBMPMin = 65536
 }
-//# sourceMappingURL=chars.d.ts.map

package/dist/{src → types}/common.d.ts

@@ -1,6 +1,7 @@
 import { Token } from './token';
 import { Errors } from './errors';
-import { Node, Decorator, SourceLocation } from './estree';
+import type * as ESTree from './estree';
+import { type Parser } from './parser/parser';
 export declare const enum Context {
     None = 0,
     OptionsNext = 1,
@@ -100,7 +101,7 @@ export declare const enum Flags {
     None = 0,
     NewLine = 1,
     HasConstructor = 32,
-    Octals = 64,
+    Octal = 64,
     NonSimpleParameterList = 128,
     HasStrictReserved = 256,
     StrictEvalArguments = 512,
@@ -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,73 +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;
-//# sourceMappingURL=common.d.ts.map
+export declare function classifyIdentifier(parser: Parser, context: Context, t: Token): any;
+export type Location = {
+    index: number;
+    line: number;
+    column: number;
+};

package/dist/{src → types}/errors.d.ts

@@ -1,5 +1,6 @@
-import { _Node, SourceLocation } from './estree';
-import { ParserState, ScopeError } 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,
@@ -23,7 +24,7 @@ export declare const enum Errors {
     InvalidDynamicUnicode = 19,
     IllegalCharacter = 20,
     MissingHexDigits = 21,
-    InvalidImplicitOctals = 22,
+    InvalidImplicitOctal = 22,
     InvalidStringLT = 23,
     InvalidEscapeIdentifier = 24,
     ExpectedToken = 25,
@@ -145,7 +146,7 @@ export declare const enum Errors {
     ImportNotOneArg = 141,
     InvalidImportNew = 142,
     InvalidSpreadInImport = 143,
-    UncompleteArrow = 144,
+    IncompleteArrow = 144,
     DuplicateBinding = 145,
     DuplicatePrivateIdentifier = 146,
     DuplicateExportBinding = 147,
@@ -189,10 +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;
-//# sourceMappingURL=errors.d.ts.map
+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/{src → 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;
@@ -31,7 +28,8 @@ export type DeclarationStatement = ClassDeclaration | ClassExpression | ExportDe
 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 ForInitialiser = Expression | VariableDeclaration;
+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;
@@ -58,14 +56,6 @@ interface FunctionDeclarationBase extends _Node {
     params: Parameter[];
     body?: BlockStatement | null;
 }
-interface MethodDefinitionBase extends _Node {
-    key: Expression | PrivateIdentifier | null;
-    value: FunctionExpression;
-    computed: boolean;
-    static: boolean;
-    kind: 'method' | 'get' | 'set' | 'constructor';
-    decorators?: Decorator[];
-}
 export interface BlockStatementBase extends _Node {
     body: Statement[];
 }
@@ -83,6 +73,7 @@ export interface ArrowFunctionExpression extends _Node {
     body: Expression | BlockStatement;
     async: boolean;
     expression: boolean;
+    generator: false;
 }
 export interface AssignmentExpression extends _Node {
     type: 'AssignmentExpression';
@@ -128,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';
@@ -197,7 +188,7 @@ export interface ExportAllDeclaration extends _Node {
     type: 'ExportAllDeclaration';
     source: Literal;
     exported: Identifier | Literal | null;
-    attributes?: ImportAttribute[];
+    attributes: ImportAttribute[];
 }
 export interface ExportDefaultDeclaration extends _Node {
     type: 'ExportDefaultDeclaration';
@@ -208,7 +199,7 @@ export interface ExportNamedDeclaration extends _Node {
     declaration: ExportDeclaration | null;
     specifiers: ExportSpecifier[];
     source: Literal | null;
-    attributes?: ImportAttribute[];
+    attributes: ImportAttribute[];
 }
 export interface ExportSpecifier extends _Node {
     type: 'ExportSpecifier';
@@ -218,23 +209,24 @@ export interface ExportSpecifier extends _Node {
 export interface ExpressionStatement extends _Node {
     type: 'ExpressionStatement';
     expression: Expression;
+    directive?: string;
 }
 export interface ForInStatement extends _Node {
     type: 'ForInStatement';
-    left: ForInitialiser;
+    left: ForInitializer;
     right: Expression;
     body: Statement;
 }
 export interface ForOfStatement extends _Node {
     type: 'ForOfStatement';
-    left: ForInitialiser;
+    left: ForInitializer;
     right: Expression;
     body: Statement;
     await: boolean;
 }
 export interface ForStatement extends _Node {
     type: 'ForStatement';
-    init: Expression | ForInitialiser | null;
+    init: Expression | ForInitializer | null;
     test: Expression | null;
     update: Expression | null;
     body: Statement;
@@ -262,7 +254,7 @@ export interface ImportDeclaration extends _Node {
     type: 'ImportDeclaration';
     source: Literal;
     specifiers: ImportClause[];
-    attributes?: ImportAttribute[];
+    attributes: ImportAttribute[];
 }
 export interface ImportAttribute extends _Node {
     type: 'ImportAttribute';
@@ -370,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 {
@@ -379,8 +371,14 @@ export interface MetaProperty extends _Node {
     meta: Identifier;
     property: Identifier;
 }
-export interface MethodDefinition extends MethodDefinitionBase {
+export interface MethodDefinition extends _Node {
     type: 'MethodDefinition';
+    key: Expression | PrivateIdentifier | null;
+    value: FunctionExpression;
+    computed: boolean;
+    static: boolean;
+    kind: 'method' | 'get' | 'set' | 'constructor';
+    decorators?: Decorator[];
 }
 export interface NewExpression extends _Node {
     type: 'NewExpression';
@@ -521,5 +519,3 @@ export interface YieldExpression extends _Node {
     delegate: boolean;
     argument?: Expression | null;
 }
-export {};
-//# sourceMappingURL=estree.d.ts.map

package/dist/{src → types}/lexer/charClassifier.d.ts

@@ -22,4 +22,3 @@ export declare const isIdStart: number[];
 export declare const isIdPart: number[];
 export declare function isIdentifierStart(code: number): boolean;
 export declare function isIdentifierPart(code: number): boolean;
-//# sourceMappingURL=charClassifier.d.ts.map

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

@@ -0,0 +1,16 @@
+import { LexerState } 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,
+    HTMLOpen = 2,
+    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 skipMultiLineComment(parser: Parser, source: string, state: LexerState): LexerState | void;

package/dist/{src → types}/lexer/common.d.ts

@@ -1,5 +1,5 @@
 import { Token } from '../token';
-import { ParserState } from '../common';
+import { type Parser } from '../parser/parser';
 export declare const enum LexerState {
     None = 0,
     NewLine = 1,
@@ -16,11 +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;
-//# sourceMappingURL=common.d.ts.map

package/dist/{src → types}/lexer/decodeHTML.d.ts

@@ -1,2 +1 @@
 export declare function decodeHTMLStrict(text: string): string;
-//# sourceMappingURL=decodeHTML.d.ts.map

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

@@ -0,0 +1,9 @@
+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/{src → types}/lexer/index.d.ts

@@ -1,10 +1,9 @@
 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 { 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 { scanIdentifier, scanIdentifierSlowCase, scanUnicodeIdentifier, scanPrivateIdentifier, scanUnicodeEscape, } from './identifier';
 export { scanString } from './string';
 export { scanNumber } from './numeric';
 export { scanTemplate, scanTemplateTail } from './template';
 export { scanRegularExpression } from './regexp';
-//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,7 @@
+import { Token } from '../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

@@ -0,0 +1,6 @@
+import { Context } from '../common';
+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

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

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,13 @@
+import { Context } from '../common';
+import { type Parser } from '../parser/parser';
+import { Token } from '../token';
+export declare const enum Escape {
+    Empty = -1,
+    StrictOctal = -2,
+    EightOrNine = -3,
+    InvalidHex = -4,
+    OutOfRange = -5
+}
+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

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

package/dist/{src → types}/meriyah.d.ts

@@ -1,8 +1,8 @@
 import { Options } from './parser';
-import * as ESTree from './estree';
+import { type Program } from './estree';
 declare const version: string;
-export declare function parseScript(source: string, options?: Options): ESTree.Program;
-export declare function parseModule(source: string, options?: Options): ESTree.Program;
-export declare function parse(source: string, options?: Options): ESTree.Program;
-export { Options, ESTree, version };
-//# sourceMappingURL=meriyah.d.ts.map
+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 * as ESTree from './estree';

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;