Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

meriyah

Package Overview
Dependencies
Maintainers
1
Versions
917
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

meriyah - npm Package Compare versions

Comparing version 0.1.11 to 0.1.12

4

package.json
{
"name": "meriyah",
"version": "0.1.11",
"description": "Fast and lightweight, standard-compliant javascript parser written in ECMAScript",
"version": "0.1.12",
"description": "A 100% compliant, self-hosted javascript parser with high focus on both performance and stability",
"main": "dist/meriyah.umd.js",

@@ -6,0 +6,0 @@ "module": "dist/meriyah.esm.js",

469

src/estree.ts

@@ -1,3 +0,5 @@

interface _Node {
type: string;
interface _Node<T extends string> {
type: T;
start?: number;
end?: number;
loc?: SourceLocation | null;

@@ -7,2 +9,64 @@ range?: [number, number];

export interface T_Node extends T_Statement, T_Expression, T_Pattern, T_ModuleDeclaration, T_ModuleSpecifier {
Program: Program;
SwitchCase: SwitchCase;
CatchClause: CatchClause;
Property: Property | AssignmentProperty;
Super: Super;
SpreadElement: SpreadElement;
TemplateElement: TemplateElement;
ClassBody: ClassBody;
FieldDefinition: FieldDefinition;
PrivateName: PrivateName;
Decorator: Decorator;
MethodDefinition: MethodDefinition;
VariableDeclarator: VariableDeclarator;
}
interface _Expression<T extends string> extends _Node<T> {}
interface T_Expression {
Identifier: Identifier;
Literal: Literal | RegExpLiteral;
ThisExpression: ThisExpression;
ArrayExpression: ArrayExpression;
ObjectExpression: ObjectExpression;
FunctionExpression: FunctionExpression;
UnaryExpression: UnaryExpression;
UpdateExpression: UpdateExpression;
BinaryExpression: BinaryExpression;
AssignmentExpression: AssignmentExpression;
LogicalExpression: LogicalExpression;
MemberExpression: MemberExpression;
ConditionalExpression: ConditionalExpression;
CallExpression: CallExpression;
NewExpression: NewExpression;
SequenceExpression: SequenceExpression;
ArrowFunctionExpression: ArrowFunctionExpression;
YieldExpression: YieldExpression;
TemplateLiteral: TemplateLiteral;
TaggedTemplateExpression: TaggedTemplateExpression;
ClassExpression: ClassExpression;
MetaProperty: MetaProperty;
AwaitExpression: AwaitExpression;
}
interface T_ModuleSpecifier {
ImportSpecifier: ImportSpecifier;
ImportDefaultSpecifier: ImportDefaultSpecifier;
ImportNamespaceSpecifier: ImportNamespaceSpecifier;
ExportSpecifier: ExportSpecifier;
}
interface T_ModuleDeclaration {
ImportDeclaration: ImportDeclaration;
ExportNamedDeclaration: ExportNamedDeclaration;
ExportDefaultDeclaration: ExportDefaultDeclaration;
ExportAllDeclaration: ExportAllDeclaration;
}
interface T_Pattern {
Identifier: Identifier;
ObjectPattern: ObjectPattern;
ArrayPattern: ArrayPattern;
MemberExpression: MemberExpression;
AssignmentPattern: AssignmentPattern;
RestElement: RestElement;
}
export type Node =

@@ -25,3 +89,3 @@ | Identifier

| ClassBody
| Class
| Decorator
| MethodDefinition

@@ -31,5 +95,10 @@ | ModuleDeclaration

export interface Comment extends _Node {
type: 'Line' | 'Block';
export type CommentType = 'Line' | 'Block' | 'HTMLOpen' | 'HTMLClose';
export interface Comment {
type: CommentType;
value: string;
start?: number;
end?: number;
loc?: SourceLocation | null;
}

@@ -49,5 +118,6 @@

}
export interface Program extends _Node {
type: 'Program';
/**
* Core types
*/
export interface Program extends _Node<'Program'> {
sourceType: 'script' | 'module';

@@ -58,3 +128,3 @@ body: Array<Statement | ModuleDeclaration>;

interface BaseFunction extends _Node {
interface BaseFunction extends _Node<'Function'> {
params: Array<Pattern>;

@@ -117,10 +187,5 @@ generator?: boolean;

interface BaseStatement extends _Node {}
export interface EmptyStatement extends _Node<'EmptyStatement'> {}
export interface EmptyStatement extends BaseStatement {
type: 'EmptyStatement';
}
export interface BlockStatement extends BaseStatement {
type: 'BlockStatement';
export interface BlockStatement extends _Node<'BlockStatement'> {
body: Array<Statement>;

@@ -130,4 +195,3 @@ innerComments?: Array<Comment>;

export interface ExpressionStatement extends BaseStatement {
type: 'ExpressionStatement';
export interface ExpressionStatement extends _Node<'ExpressionStatement'> {
expression: Expression;

@@ -137,4 +201,3 @@ directive?: string;

export interface IfStatement extends BaseStatement {
type: 'IfStatement';
export interface IfStatement extends _Node<'IfStatement'> {
test: Expression;

@@ -145,4 +208,3 @@ consequent: Statement;

export interface LabeledStatement extends BaseStatement {
type: 'LabeledStatement';
export interface LabeledStatement extends _Node<'LabeledStatement'> {
label: Identifier;

@@ -152,14 +214,11 @@ body: Statement;

export interface BreakStatement extends BaseStatement {
type: 'BreakStatement';
export interface BreakStatement extends _Node<'BreakStatement'> {
label?: Identifier | null;
}
export interface ContinueStatement extends BaseStatement {
type: 'ContinueStatement';
export interface ContinueStatement extends _Node<'ContinueStatement'> {
label?: Identifier | null;
}
export interface WithStatement extends BaseStatement {
type: 'WithStatement';
export interface WithStatement extends _Node<'WithStatement'> {
object: Expression;

@@ -169,4 +228,3 @@ body: Statement;

export interface SwitchStatement extends BaseStatement {
type: 'SwitchStatement';
export interface SwitchStatement extends _Node<'SwitchStatement'> {
discriminant: Expression;

@@ -176,14 +234,11 @@ cases: Array<SwitchCase>;

export interface ReturnStatement extends BaseStatement {
type: 'ReturnStatement';
export interface ReturnStatement extends _Node<'ReturnStatement'> {
argument?: Expression | null;
}
export interface ThrowStatement extends BaseStatement {
type: 'ThrowStatement';
export interface ThrowStatement extends _Node<'ThrowStatement'> {
argument: Expression;
}
export interface TryStatement extends BaseStatement {
type: 'TryStatement';
export interface TryStatement extends _Node<'TryStatement'> {
block: BlockStatement;

@@ -194,4 +249,3 @@ handler?: CatchClause | null;

export interface WhileStatement extends BaseStatement {
type: 'WhileStatement';
export interface WhileStatement extends _Node<'WhileStatement'> {
test: Expression;

@@ -201,4 +255,3 @@ body: Statement;

export interface DoWhileStatement extends BaseStatement {
type: 'DoWhileStatement';
export interface DoWhileStatement extends _Node<'DoWhileStatement'> {
body: Statement;

@@ -208,4 +261,3 @@ test: Expression;

export interface ForStatement extends BaseStatement {
type: 'ForStatement';
export interface ForStatement extends _Node<'ForStatement'> {
init?: VariableDeclaration | Expression | null;

@@ -216,40 +268,85 @@ test?: Expression | null;

}
export interface ForInStatement extends _Statement<'ForInStatement'> {
left: VariableDeclaration | Pattern;
right: Expression;
body: Statement;
}
interface BaseForXStatement extends BaseStatement {
export interface ForOfStatement extends _Statement<'ForOfStatement'> {
left: VariableDeclaration | Pattern;
right: Expression;
body: Statement;
await: boolean;
}
export interface ForInStatement extends BaseForXStatement {
type: 'ForInStatement';
export interface ForStatement extends _Statement<'ForStatement'> {
init?: VariableDeclaration | Expression | null;
test?: Expression | null;
update?: Expression | null;
body: Statement;
}
export interface DebuggerStatement extends BaseStatement {
type: 'DebuggerStatement';
interface _Statement<T extends string> extends _Node<T> {}
interface T_Declaration {
FunctionDeclaration: FunctionDeclaration;
VariableDeclaration: VariableDeclaration;
ClassDeclaration: ClassDeclaration;
}
interface T_Statement extends T_Declaration {
ExpressionStatement: ExpressionStatement;
BlockStatement: BlockStatement;
EmptyStatement: EmptyStatement;
DebuggerStatement: DebuggerStatement;
WithStatement: WithStatement;
ReturnStatement: ReturnStatement;
LabeledStatement: LabeledStatement;
BreakStatement: BreakStatement;
ContinueStatement: ContinueStatement;
IfStatement: IfStatement;
SwitchStatement: SwitchStatement;
ThrowStatement: ThrowStatement;
TryStatement: TryStatement;
WhileStatement: WhileStatement;
DoWhileStatement: DoWhileStatement;
ForStatement: ForStatement;
ForInStatement: ForInStatement;
ForOfStatement: ForOfStatement;
Decorator: Decorator;
}
export interface ForInStatement extends _Statement<'ForInStatement'> {
left:
| Identifier
| MemberExpression
| ObjectPattern
| ArrayPattern
| AssignmentPattern
| RestElement
| VariableDeclaration;
right: Expression;
body: Statement;
}
export interface DebuggerStatement extends _Node<'DebuggerStatement'> {}
export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
interface _Declaration<T extends string> extends _Statement<T> {}
interface BaseDeclaration extends _Node<'ExpressionStatement'> {}
interface BaseDeclaration extends BaseStatement {}
export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
type: 'FunctionDeclaration';
/** It is null when a function declaration is a part of the `export default function` statement */
export interface FunctionDeclaration extends _Declaration<'FunctionDeclaration'> {
id: Identifier | null;
params: Pattern[];
body: BlockStatement;
generator: boolean;
async: boolean;
}
export interface VariableDeclaration extends BaseDeclaration {
type: 'VariableDeclaration';
declarations: Array<VariableDeclarator>;
export interface VariableDeclaration extends _Declaration<'VariableDeclaration'> {
declarations: VariableDeclarator[];
kind: 'var' | 'let' | 'const';
}
export interface VariableDeclarator extends _Node {
type: 'VariableDeclarator';
export interface VariableDeclarator extends _Node<'VariableDeclarator'> {
id: Pattern;
init?: Expression | null;
}
type Expression =

@@ -280,41 +377,33 @@ | ThisExpression

export interface BaseExpression extends _Node {}
export interface ThisExpression extends _Expression<'ThisExpression'> {}
export interface ThisExpression extends BaseExpression {
type: 'ThisExpression';
}
export interface ArrayExpression extends BaseExpression {
type: 'ArrayExpression';
export interface ArrayExpression extends _Expression<'ArrayExpression'> {
elements: Array<Expression | SpreadElement>;
}
export interface ObjectExpression extends BaseExpression {
type: 'ObjectExpression';
export interface ObjectExpression extends _Expression<'ObjectExpression'> {
properties: Array<Property>;
}
export interface Property extends _Node {
type: 'Property';
export interface Property extends _Node<'Property'> {
key: Expression;
value: Expression | Pattern; // Could be an AssignmentProperty
computed: boolean;
value: Expression | null;
kind: 'init' | 'get' | 'set';
method: boolean;
shorthand: boolean;
computed: boolean;
}
export interface FunctionExpression extends BaseFunction, BaseExpression {
export interface FunctionExpression extends _Expression<'FunctionExpression'> {
id?: Identifier | null;
type: 'FunctionExpression';
body: BlockStatement;
params: Pattern[];
async: boolean;
generator: boolean;
}
export interface SequenceExpression extends BaseExpression {
type: 'SequenceExpression';
export interface SequenceExpression extends _Expression<'SequenceExpression'> {
expressions: Array<Expression>;
}
export interface UnaryExpression extends BaseExpression {
type: 'UnaryExpression';
export interface UnaryExpression extends _Expression<'UnaryExpression'> {
operator: UnaryOperator;

@@ -325,4 +414,3 @@ prefix: true;

export interface BinaryExpression extends BaseExpression {
type: 'BinaryExpression';
export interface BinaryExpression extends _Expression<'BinaryExpression'> {
operator: BinaryOperator;

@@ -333,4 +421,3 @@ left: Expression;

export interface AssignmentExpression extends BaseExpression {
type: 'AssignmentExpression';
export interface AssignmentExpression extends _Expression<'AssignmentExpression'> {
operator: AssignmentOperator;

@@ -341,4 +428,3 @@ left: Pattern | MemberExpression;

export interface UpdateExpression extends BaseExpression {
type: 'UpdateExpression';
export interface UpdateExpression extends _Expression<'UpdateExpression'> {
operator: UpdateOperator;

@@ -349,4 +435,3 @@ argument: Expression;

export interface LogicalExpression extends BaseExpression {
type: 'LogicalExpression';
export interface LogicalExpression extends _Expression<'LogicalExpression'> {
operator: LogicalOperator;

@@ -357,4 +442,3 @@ left: Expression;

export interface ConditionalExpression extends BaseExpression {
type: 'ConditionalExpression';
export interface ConditionalExpression extends _Expression<'ConditionalExpression'> {
test: Expression;

@@ -365,21 +449,19 @@ alternate: Expression;

interface BaseCallExpression extends BaseExpression {
interface BaseCallExpression extends _Expression<'ThisExObjectExpressionpression'> {
callee: Expression | Super;
arguments: Array<Expression | SpreadElement>;
}
export type CallExpression = SimpleCallExpression | NewExpression;
export interface SimpleCallExpression extends BaseCallExpression {
type: 'CallExpression';
export interface CallExpression extends _Expression<'CallExpression'> {
callee: Expression | Super;
arguments: (Expression | SpreadElement)[];
}
export interface NewExpression extends BaseCallExpression {
type: 'NewExpression';
export interface NewExpression extends _Expression<'NewExpression'> {
callee: Expression;
arguments: (Expression | SpreadElement)[];
}
export interface MemberExpression extends BaseExpression, BasePattern {
type: 'MemberExpression';
export interface MemberExpression extends _Expression<'MemberExpression'> {
computed: boolean;
object: Expression | Super;
property: Expression | PrivateName;
computed: boolean;
}

@@ -389,26 +471,27 @@

interface BasePattern extends _Node {}
export interface SwitchCase extends _Node {
type: 'SwitchCase';
test?: Expression | null;
consequent: Array<Statement>;
export interface SwitchCase extends _Node<'SwitchCase'> {
test: Expression | null;
consequent: Statement[];
}
export interface CatchClause extends _Node {
type: 'CatchClause';
export interface CatchClause extends _Node<'CatchClause'> {
param: Pattern;
body: BlockStatement;
}
interface _Pattern<T extends string> extends _Node<T> {}
export interface Identifier extends _Node, BaseExpression, BasePattern {
type: 'Identifier';
interface T_Pattern {
Identifier: Identifier;
ObjectPattern: ObjectPattern;
ArrayPattern: ArrayPattern;
MemberExpression: MemberExpression;
AssignmentPattern: AssignmentPattern;
RestElement: RestElement;
}
export interface Identifier extends _Expression<'Identifier'>, _Pattern<'Identifier'> {
name: string;
raw?: string;
}
export type Literal = SimpleLiteral | RegExpLiteral;
export interface SimpleLiteral extends _Node, BaseExpression {
type: 'Literal';
value: string | boolean | number | null;
export interface Literal extends _Expression<'Literal'> {
value: boolean | number | string | null;
raw?: string;

@@ -418,10 +501,6 @@ bigint?: string;

export interface RegExpLiteral extends _Node, BaseExpression {
type: 'Literal';
value?: RegExp | null;
regex: {
pattern: string;
flags: string;
};
export interface RegExpLiteral extends _Expression<'Literal'> {
value: RegExp | null;
raw?: string;
regex: { pattern: string; flags: string };
}

@@ -474,24 +553,16 @@

export interface ForOfStatement extends BaseForXStatement {
type: 'ForOfStatement';
await: boolean;
}
export interface Super extends _Node<'Super'> {}
export interface Super extends _Node {
type: 'Super';
}
export interface SpreadElement extends _Node {
type: 'SpreadElement';
export interface SpreadElement extends _Node<'SpreadElement'> {
argument: Expression;
}
export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
type: 'ArrowFunctionExpression';
export interface ArrowFunctionExpression extends _Expression<'ArrowFunctionExpression'> {
expression: boolean;
body: BlockStatement | Expression;
params: Pattern[];
async: boolean;
}
export interface YieldExpression extends BaseExpression {
type: 'YieldExpression';
export interface YieldExpression extends _Expression<'YieldExpression'> {
argument?: Expression | null;

@@ -501,4 +572,3 @@ delegate: boolean;

export interface TemplateLiteral extends BaseExpression {
type: 'TemplateLiteral';
export interface TemplateLiteral extends _Expression<'TemplateLiteral'> {
quasis: Array<TemplateElement>;

@@ -508,4 +578,3 @@ expressions: Array<Expression>;

export interface TaggedTemplateExpression extends BaseExpression {
type: 'TaggedTemplateExpression';
export interface TaggedTemplateExpression extends _Expression<'TaggedTemplateExpression'> {
tag: Expression;

@@ -515,12 +584,8 @@ quasi: TemplateLiteral;

export interface TemplateElement extends _Node {
type: 'TemplateElement';
export interface TemplateElement extends _Node<'TemplateElement'> {
value: { cooked: string | null; raw: string };
tail: boolean;
value: {
cooked: string;
raw: string;
};
}
export interface AssignmentProperty extends Property {
export interface AssignmentProperty extends _Node<'Property'> {
value: Pattern;

@@ -531,19 +596,15 @@ kind: 'init';

export interface ObjectPattern extends BasePattern {
type: 'ObjectPattern';
export interface ObjectPattern extends _Pattern<'ObjectPattern'> {
properties: Array<AssignmentProperty>;
}
export interface ArrayPattern extends BasePattern {
type: 'ArrayPattern';
export interface ArrayPattern extends _Pattern<'ArrayPattern'> {
elements: Array<Pattern>;
}
export interface RestElement extends BasePattern {
type: 'RestElement';
export interface RestElement extends _Pattern<'RestElement'> {
argument: Pattern;
}
export interface AssignmentPattern extends BasePattern {
type: 'AssignmentPattern';
export interface AssignmentPattern extends _Pattern<'AssignmentPattern'> {
left: Pattern;

@@ -553,25 +614,17 @@ right: Expression;

export type Class = ClassDeclaration | ClassExpression;
interface BaseClass extends _Node {
superClass?: Expression | null;
body: ClassBody;
}
export interface ClassBody extends _Node {
type: 'ClassBody';
export interface ClassBody extends _Node<'ClassBody'> {
body: Array<MethodDefinition>;
decorators?: Decorator[] | null;
}
export interface PrivateMemberExpression extends _Node {
export interface PrivateMemberExpression extends _Node<'FieldDefinition'> {
object: Expression;
property: PrivateName;
}
export interface Decorator extends _Node {
type: 'Decorator';
export interface Decorator extends _Node<'Decorator'> {
expression: Expression;
}
export interface PrivateName extends _Node {
type: 'PrivateName';
export interface PrivateName extends _Node<'PrivateName'> {
name: string;
}
export interface FieldDefinition extends _Node {
export interface FieldDefinition extends _Node<'FieldDefinition'> {
key: PrivateName | Expression;

@@ -583,4 +636,3 @@ value: any;

}
export interface MethodDefinition extends _Node {
type: 'MethodDefinition';
export interface MethodDefinition extends _Node<'MethodDefinition'> {
key: Expression;

@@ -591,17 +643,19 @@ value: FunctionExpression;

static: boolean;
decorators?: Decorator[] | null;
}
export interface ClassDeclaration extends BaseClass, BaseDeclaration {
type: 'ClassDeclaration';
/** It is null when a class declaration is a part of the `export default class` statement */
export interface ClassDeclaration extends _Declaration<'ClassDeclaration'> {
id: Identifier | null;
superClass: Expression | null;
body: ClassBody;
decorators?: Decorator[] | null;
}
export interface ClassExpression extends BaseClass, BaseExpression {
type: 'ClassExpression';
id?: Identifier | null;
export interface ClassExpression extends _Expression<'ClassExpression'> {
id: Identifier | null;
superClass: Expression | null;
body: ClassBody;
decorators?: Decorator[] | null;
}
export interface MetaProperty extends BaseExpression {
type: 'MetaProperty';
export interface MetaProperty extends _Expression<'MetaProperty'> {
meta: Identifier;

@@ -611,2 +665,9 @@ property: Identifier;

interface T_ModuleDeclaration {
ImportDeclaration: ImportDeclaration;
ExportNamedDeclaration: ExportNamedDeclaration;
ExportDefaultDeclaration: ExportDefaultDeclaration;
ExportAllDeclaration: ExportAllDeclaration;
}
export type ModuleDeclaration =

@@ -617,53 +678,39 @@ | ImportDeclaration

| ExportAllDeclaration;
interface BaseModuleDeclaration extends _Node {}
export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
interface BaseModuleSpecifier extends _Node {
interface _ModuleSpecifier<T extends string> extends _Node<T> {
local: Identifier;
}
export interface ImportDeclaration extends BaseModuleDeclaration {
type: 'ImportDeclaration';
specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
interface _ModuleDeclaration<T extends string> extends _Node<T> {}
export interface ImportDeclaration extends _ModuleDeclaration<'ImportDeclaration'> {
specifiers: (ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier)[];
source: Literal;
}
export interface ImportSpecifier extends BaseModuleSpecifier {
type: 'ImportSpecifier';
export interface ImportSpecifier extends _ModuleSpecifier<'ImportSpecifier'> {
imported: Identifier;
}
export interface ImportDefaultSpecifier extends _ModuleSpecifier<'ImportDefaultSpecifier'> {}
export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
type: 'ImportDefaultSpecifier';
}
export interface ImportNamespaceSpecifier extends _ModuleSpecifier<'ImportNamespaceSpecifier'> {}
export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
type: 'ImportNamespaceSpecifier';
export interface ExportNamedDeclaration extends _ModuleDeclaration<'ExportNamedDeclaration'> {
declaration: Declaration | null;
specifiers: ExportSpecifier[];
source: Literal | null;
}
export interface ExportNamedDeclaration extends BaseModuleDeclaration {
type: 'ExportNamedDeclaration';
declaration?: Declaration | null;
specifiers: Array<ExportSpecifier>;
source?: Literal | null;
}
export interface ExportSpecifier extends BaseModuleSpecifier {
type: 'ExportSpecifier';
export interface ExportSpecifier extends _ModuleSpecifier<'ExportSpecifier'> {
exported: Identifier;
}
export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
type: 'ExportDefaultDeclaration';
export interface ExportDefaultDeclaration extends _ModuleDeclaration<'ExportDefaultDeclaration'> {
declaration: Declaration | Expression;
}
export interface ExportAllDeclaration extends BaseModuleDeclaration {
type: 'ExportAllDeclaration';
export interface ExportAllDeclaration extends _ModuleDeclaration<'ExportAllDeclaration'> {
source: Literal;
}
export interface AwaitExpression extends BaseExpression {
type: 'AwaitExpression';
export interface AwaitExpression extends _Expression<'AwaitExpression'> {
argument: Expression;
}
src/parser.ts

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc