@types/estree - npm Package Compare versions

Comparing version 0.0.52 to 1.0.0

estree/flow.d.ts

@@ -1,174 +0,167 @@
-// Type definitions for ESTree AST extensions for Facebook Flow
-// Project: https://github.com/estree/estree
-// Definitions by: RReverser <https://github.com/RReverser>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
 declare namespace ESTree {
-  interface FlowTypeAnnotation extends Node {}
+    interface FlowTypeAnnotation extends Node {}
 
-  interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
+    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
 
-  interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
+    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
 
-  interface FlowDeclaration extends Declaration {}
+    interface FlowDeclaration extends Declaration {}
 
-  interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
 
-  interface ArrayTypeAnnotation extends FlowTypeAnnotation {
-    elementType: FlowTypeAnnotation;
-  }
+    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
+        elementType: FlowTypeAnnotation;
+    }
 
-  interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
 
-  interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
 
-  interface ClassImplements extends Node {
-    id: Identifier;
-    typeParameters?: TypeParameterInstantiation | null;
-  }
+    interface ClassImplements extends Node {
+        id: Identifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
 
-  interface ClassProperty {
-    key: Expression;
-    value?: Expression | null;
-    typeAnnotation?: TypeAnnotation | null;
-    computed: boolean;
-    static: boolean;
-  }
+    interface ClassProperty {
+        key: Expression;
+        value?: Expression | null;
+        typeAnnotation?: TypeAnnotation | null;
+        computed: boolean;
+        static: boolean;
+    }
 
-  interface DeclareClass extends FlowDeclaration {
-    id: Identifier;
-    typeParameters?: TypeParameterDeclaration | null;
-    body: ObjectTypeAnnotation;
-    extends: Array<InterfaceExtends>;
-  }
+    interface DeclareClass extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        body: ObjectTypeAnnotation;
+        extends: InterfaceExtends[];
+    }
 
-  interface DeclareFunction extends FlowDeclaration {
-    id: Identifier;
-  }
+    interface DeclareFunction extends FlowDeclaration {
+        id: Identifier;
+    }
 
-  interface DeclareModule extends FlowDeclaration {
-    id: Literal | Identifier;
-    body: BlockStatement;
-  }
+    interface DeclareModule extends FlowDeclaration {
+        id: Literal | Identifier;
+        body: BlockStatement;
+    }
 
-  interface DeclareVariable extends FlowDeclaration {
-    id: Identifier;
-  }
+    interface DeclareVariable extends FlowDeclaration {
+        id: Identifier;
+    }
 
-  interface FunctionTypeAnnotation extends FlowTypeAnnotation {
-    params: Array<FunctionTypeParam>;
-    returnType: FlowTypeAnnotation;
-    rest?: FunctionTypeParam | null;
-    typeParameters?: TypeParameterDeclaration | null;
-  }
+    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
+        params: FunctionTypeParam[];
+        returnType: FlowTypeAnnotation;
+        rest?: FunctionTypeParam | null;
+        typeParameters?: TypeParameterDeclaration | null;
+    }
 
-  interface FunctionTypeParam {
-    name: Identifier;
-    typeAnnotation: FlowTypeAnnotation;
-    optional: boolean;
-  }
+    interface FunctionTypeParam {
+        name: Identifier;
+        typeAnnotation: FlowTypeAnnotation;
+        optional: boolean;
+    }
 
-  interface GenericTypeAnnotation extends FlowTypeAnnotation {
-    id: Identifier | QualifiedTypeIdentifier;
-    typeParameters?: TypeParameterInstantiation | null;
-  }
+    interface GenericTypeAnnotation extends FlowTypeAnnotation {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
 
-  interface InterfaceExtends extends Node {
-    id: Identifier | QualifiedTypeIdentifier;
-    typeParameters?: TypeParameterInstantiation | null;
-  }
+    interface InterfaceExtends extends Node {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
 
-  interface InterfaceDeclaration extends FlowDeclaration {
-    id: Identifier;
-    typeParameters?: TypeParameterDeclaration | null;
-    extends: Array<InterfaceExtends>;
-    body: ObjectTypeAnnotation;
-  }
+    interface InterfaceDeclaration extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        extends: InterfaceExtends[];
+        body: ObjectTypeAnnotation;
+    }
 
-  interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
-    types: Array<FlowTypeAnnotation>;
-  }
+    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
 
-  interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
 
-  interface NullableTypeAnnotation extends FlowTypeAnnotation {
-    typeAnnotation: TypeAnnotation;
-  }
+    interface NullableTypeAnnotation extends FlowTypeAnnotation {
+        typeAnnotation: TypeAnnotation;
+    }
 
-  interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
 
-  interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
 
-  interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
 
-  interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
 
-  interface TupleTypeAnnotation extends FlowTypeAnnotation {
-    types: Array<FlowTypeAnnotation>;
-  }
+    interface TupleTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
 
-  interface TypeofTypeAnnotation extends FlowTypeAnnotation {
-    argument: FlowTypeAnnotation;
-  }
+    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
+        argument: FlowTypeAnnotation;
+    }
 
-  interface TypeAlias extends FlowDeclaration {
-    id: Identifier;
-    typeParameters?: TypeParameterDeclaration | null;
-    right: FlowTypeAnnotation;
-  }
+    interface TypeAlias extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        right: FlowTypeAnnotation;
+    }
 
-  interface TypeAnnotation extends Node {
-    typeAnnotation: FlowTypeAnnotation;
-  }
+    interface TypeAnnotation extends Node {
+        typeAnnotation: FlowTypeAnnotation;
+    }
 
-  interface TypeCastExpression extends Expression {
-    expression: Expression;
-    typeAnnotation: TypeAnnotation;
-  }
+    interface TypeCastExpression extends Expression {
+        expression: Expression;
+        typeAnnotation: TypeAnnotation;
+    }
 
-  interface TypeParameterDeclaration extends Node {
-    params: Array<Identifier>;
-  }
+    interface TypeParameterDeclaration extends Node {
+        params: Identifier[];
+    }
 
-  interface TypeParameterInstantiation extends Node {
-    params: Array<FlowTypeAnnotation>;
-  }
+    interface TypeParameterInstantiation extends Node {
+        params: FlowTypeAnnotation[];
+    }
 
-  interface ObjectTypeAnnotation extends FlowTypeAnnotation {
-    properties: Array<ObjectTypeProperty>;
-    indexers: Array<ObjectTypeIndexer>;
-    callProperties: Array<ObjectTypeCallProperty>;
-  }
+    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
+        properties: ObjectTypeProperty[];
+        indexers: ObjectTypeIndexer[];
+        callProperties: ObjectTypeCallProperty[];
+    }
 
-  interface ObjectTypeCallProperty extends Node {
-    value: FunctionTypeAnnotation;
-    static: boolean;
-  }
+    interface ObjectTypeCallProperty extends Node {
+        value: FunctionTypeAnnotation;
+        static: boolean;
+    }
 
-  interface ObjectTypeIndexer extends Node {
-    id: Identifier;
-    key: FlowTypeAnnotation;
-    value: FlowTypeAnnotation;
-    static: boolean;
-  }
+    interface ObjectTypeIndexer extends Node {
+        id: Identifier;
+        key: FlowTypeAnnotation;
+        value: FlowTypeAnnotation;
+        static: boolean;
+    }
 
-  interface ObjectTypeProperty extends Node {
-    key: Expression;
-    value: FlowTypeAnnotation;
-    optional: boolean;
-    static: boolean;
-  }
+    interface ObjectTypeProperty extends Node {
+        key: Expression;
+        value: FlowTypeAnnotation;
+        optional: boolean;
+        static: boolean;
+    }
 
-  interface QualifiedTypeIdentifier extends Node {
-    qualification: Identifier | QualifiedTypeIdentifier;
-    id: Identifier;
-  }
+    interface QualifiedTypeIdentifier extends Node {
+        qualification: Identifier | QualifiedTypeIdentifier;
+        id: Identifier;
+    }
 
-  interface UnionTypeAnnotation extends FlowTypeAnnotation {
-    types: Array<FlowTypeAnnotation>;
-  }
+    interface UnionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
 
-  interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
+    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
 }

estree/index.d.ts

@@ -1,2 +0,2 @@
-// Type definitions for ESTree AST specification
+// Type definitions for non-npm package estree 1.0
 // Project: https://github.com/estree/estree
@@ -24,280 +24,293 @@ // Definitions by: RReverser <https://github.com/RReverser>
 
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
+export interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
 }
 
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Array<Comment> | undefined;
-  trailingComments?: Array<Comment> | undefined;
+export interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
 }
 
-interface NodeMap {
-  AssignmentProperty: AssignmentProperty;
-  CatchClause: CatchClause;
-  Class: Class;
-  ClassBody: ClassBody;
-  Expression: Expression;
-  Function: Function;
-  Identifier: Identifier;
-  Literal: Literal;
-  MethodDefinition: MethodDefinition;
-  ModuleDeclaration: ModuleDeclaration;
-  ModuleSpecifier: ModuleSpecifier;
-  Pattern: Pattern;
-  PrivateIdentifier: PrivateIdentifier;
-  Program: Program;
-  Property: Property;
-  PropertyDefinition: PropertyDefinition;
-  SpreadElement: SpreadElement;
-  Statement: Statement;
-  Super: Super;
-  SwitchCase: SwitchCase;
-  TemplateElement: TemplateElement;
-  VariableDeclarator: VariableDeclarator;
+export interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
 }
 
-export type Node = NodeMap[keyof NodeMap]
+export type Node = NodeMap[keyof NodeMap];
 
 export interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
+    type: 'Line' | 'Block';
+    value: string;
 }
 
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
 }
 
 export interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
 }
 
 export interface Program extends BaseNode {
-  type: "Program";
-  sourceType: "script" | "module";
-  body: Array<Directive | Statement | ModuleDeclaration>;
-  comments?: Array<Comment> | undefined;
+    type: 'Program';
+    sourceType: 'script' | 'module';
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
 }
 
 export interface Directive extends BaseNode {
-  type: "ExpressionStatement";
-  expression: Literal;
-  directive: string;
+    type: 'ExpressionStatement';
+    expression: Literal;
+    directive: string;
 }
 
-interface BaseFunction extends BaseNode {
-  params: Array<Pattern>;
-  generator?: boolean | undefined;
-  async?: boolean | undefined;
-  // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
+export interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
 }
 
-export type Function =
-    FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
 
 export type Statement =
-    ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement |
-    DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement |
-    BreakStatement | ContinueStatement | IfStatement | SwitchStatement |
-    ThrowStatement | TryStatement | WhileStatement | DoWhileStatement |
-    ForStatement | ForInStatement | ForOfStatement | Declaration;
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
 
-interface BaseStatement extends BaseNode { }
+export interface BaseStatement extends BaseNode {}
 
 export interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
+    type: 'EmptyStatement';
 }
 
 export interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Array<Statement>;
-  innerComments?: Array<Comment> | undefined;
+    type: 'BlockStatement';
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
 }
 
 export interface StaticBlock extends Omit<BlockStatement, 'type'> {
-    type: "StaticBlock";
+    type: 'StaticBlock';
 }
 
 export interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
+    type: 'ExpressionStatement';
+    expression: Expression;
 }
 
 export interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
+    type: 'IfStatement';
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
 }
 
 export interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
+    type: 'LabeledStatement';
+    label: Identifier;
+    body: Statement;
 }
 
 export interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
+    type: 'BreakStatement';
+    label?: Identifier | null | undefined;
 }
 
 export interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
+    type: 'ContinueStatement';
+    label?: Identifier | null | undefined;
 }
 
 export interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
+    type: 'WithStatement';
+    object: Expression;
+    body: Statement;
 }
 
 export interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: Array<SwitchCase>;
+    type: 'SwitchStatement';
+    discriminant: Expression;
+    cases: SwitchCase[];
 }
 
 export interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
+    type: 'ReturnStatement';
+    argument?: Expression | null | undefined;
 }
 
 export interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
+    type: 'ThrowStatement';
+    argument: Expression;
 }
 
 export interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
+    type: 'TryStatement';
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
 }
 
 export interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
+    type: 'WhileStatement';
+    test: Expression;
+    body: Statement;
 }
 
 export interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
+    type: 'DoWhileStatement';
+    body: Statement;
+    test: Expression;
 }
 
 export interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
+    type: 'ForStatement';
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
 }
 
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
+export interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
 }
 
 export interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
+    type: 'ForInStatement';
 }
 
 export interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
+    type: 'DebuggerStatement';
 }
 
-export type Declaration =
-      FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
 
-interface BaseDeclaration extends BaseStatement { }
+export 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 */
-  id: Identifier | null;
-  body: BlockStatement;
+    type: 'FunctionDeclaration';
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
 }
 
 export interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: Array<VariableDeclarator>;
-  kind: "var" | "let" | "const";
+    type: 'VariableDeclaration';
+    declarations: VariableDeclarator[];
+    kind: 'var' | 'let' | 'const';
 }
 
 export interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
+    type: 'VariableDeclarator';
+    id: Pattern;
+    init?: Expression | null | undefined;
 }
 
 export interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
 }
 
-type Expression = ExpressionMap[keyof ExpressionMap]
+export type Expression = ExpressionMap[keyof ExpressionMap];
 
-export interface BaseExpression extends BaseNode { }
+export interface BaseExpression extends BaseNode {}
 
-type ChainElement = SimpleCallExpression | MemberExpression;
+export type ChainElement = SimpleCallExpression | MemberExpression;
 
 export interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
+    type: 'ChainExpression';
+    expression: ChainElement;
 }
 
 export interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
+    type: 'ThisExpression';
 }
 
 export interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
+    type: 'ArrayExpression';
+    elements: Array<Expression | SpreadElement | null>;
 }
 
 export interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
+    type: 'ObjectExpression';
+    properties: Array<Property | SpreadElement>;
 }
 
 export interface PrivateIdentifier extends BaseNode {
-    type: "PrivateIdentifier";
+    type: 'PrivateIdentifier';
     name: string;
@@ -307,13 +320,13 @@ }
 export interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
+    type: 'Property';
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: 'init' | 'get' | 'set';
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
 }
 
 export interface PropertyDefinition extends BaseNode {
-    type: "PropertyDefinition";
+    type: 'PropertyDefinition';
     key: Expression | PrivateIdentifier;
@@ -326,57 +339,57 @@ value?: Expression | null | undefined;
 export interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
+    id?: Identifier | null | undefined;
+    type: 'FunctionExpression';
+    body: BlockStatement;
 }
 
 export interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Array<Expression>;
+    type: 'SequenceExpression';
+    expressions: Expression[];
 }
 
 export interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
+    type: 'UnaryExpression';
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
 }
 
 export interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression;
-  right: Expression;
+    type: 'BinaryExpression';
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
 }
 
 export interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
+    type: 'AssignmentExpression';
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
 }
 
 export interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
+    type: 'UpdateExpression';
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
 }
 
 export interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
+    type: 'LogicalExpression';
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
 }
 
 export interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
+    type: 'ConditionalExpression';
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
 }
 
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
+export interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
 }
@@ -386,39 +399,37 @@ export type CallExpression = SimpleCallExpression | NewExpression;
 export interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
+    type: 'CallExpression';
+    optional: boolean;
 }
 
 export interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
+    type: 'NewExpression';
 }
 
 export interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
+    type: 'MemberExpression';
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
 }
 
-export type Pattern =
-    Identifier | ObjectPattern | ArrayPattern | RestElement |
-    AssignmentPattern | MemberExpression;
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
 
-interface BasePattern extends BaseNode { }
+export interface BasePattern extends BaseNode {}
 
 export interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Array<Statement>;
+    type: 'SwitchCase';
+    test?: Expression | null | undefined;
+    consequent: Statement[];
 }
 
 export interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
+    type: 'CatchClause';
+    param: Pattern | null;
+    body: BlockStatement;
 }
 
 export interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
+    type: 'Identifier';
+    name: string;
 }
@@ -429,214 +440,243 @@
 export interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
+    type: 'Literal';
+    value: string | boolean | number | null;
+    raw?: string | undefined;
 }
 
 export interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
+    type: 'Literal';
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
 }
 
 export interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
+    type: 'Literal';
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
 }
 
-export type UnaryOperator =
-    "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+export type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
 
 export type BinaryOperator =
-    "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" |
-    ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" |
-    "instanceof";
+    | '=='
+    | '!='
+    | '==='
+    | '!=='
+    | '<'
+    | '<='
+    | '>'
+    | '>='
+    | '<<'
+    | '>>'
+    | '>>>'
+    | '+'
+    | '-'
+    | '*'
+    | '/'
+    | '%'
+    | '**'
+    | '|'
+    | '^'
+    | '&'
+    | 'in'
+    | 'instanceof';
 
-export type LogicalOperator = "||" | "&&" | "??";
+export type LogicalOperator = '||' | '&&' | '??';
 
 export type AssignmentOperator =
-    "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" |
-    "|=" | "^=" | "&=";
+    | '='
+    | '+='
+    | '-='
+    | '*='
+    | '/='
+    | '%='
+    | '**='
+    | '<<='
+    | '>>='
+    | '>>>='
+    | '|='
+    | '^='
+    | '&=';
 
-export type UpdateOperator = "++" | "--";
+export type UpdateOperator = '++' | '--';
 
 export interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
+    type: 'ForOfStatement';
+    await: boolean;
 }
 
 export interface Super extends BaseNode {
-  type: "Super";
+    type: 'Super';
 }
 
 export interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
+    type: 'SpreadElement';
+    argument: Expression;
 }
 
 export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
+    type: 'ArrowFunctionExpression';
+    expression: boolean;
+    body: BlockStatement | Expression;
 }
 
 export interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
+    type: 'YieldExpression';
+    argument?: Expression | null | undefined;
+    delegate: boolean;
 }
 
 export interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: Array<TemplateElement>;
-  expressions: Array<Expression>;
+    type: 'TemplateLiteral';
+    quasis: TemplateElement[];
+    expressions: Expression[];
 }
 
 export interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
+    type: 'TaggedTemplateExpression';
+    tag: Expression;
+    quasi: TemplateLiteral;
 }
 
 export interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
-    cooked?: string | null | undefined;
-    raw: string;
-  };
+    type: 'TemplateElement';
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
 }
 
 export interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
+    value: Pattern;
+    kind: 'init';
+    method: boolean; // false
 }
 
 export interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
+    type: 'ObjectPattern';
+    properties: Array<AssignmentProperty | RestElement>;
 }
 
 export interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
+    type: 'ArrayPattern';
+    elements: Array<Pattern | null>;
 }
 
 export interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
+    type: 'RestElement';
+    argument: Pattern;
 }
 
 export interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
+    type: 'AssignmentPattern';
+    left: Pattern;
+    right: Expression;
 }
 
 export type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
+export interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
 }
 
 export interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+    type: 'ClassBody';
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
 }
 
 export interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
+    type: 'MethodDefinition';
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: 'constructor' | 'method' | 'get' | 'set';
+    computed: boolean;
+    static: boolean;
 }
 
 export interface ClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
+    type: 'ClassDeclaration';
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
 }
 
 export interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
+    type: 'ClassExpression';
+    id?: Identifier | null | undefined;
 }
 
 export interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
+    type: 'MetaProperty';
+    meta: Identifier;
+    property: Identifier;
 }
 
 export type ModuleDeclaration =
-    ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration |
-    ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode { }
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
 
-export type ModuleSpecifier =
-    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier |
-    ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
-  local: Identifier;
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
 }
 
 export interface ImportDeclaration extends BaseModuleDeclaration {
-  type: "ImportDeclaration";
-  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-  source: Literal;
+    type: 'ImportDeclaration';
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
 }
 
 export interface ImportSpecifier extends BaseModuleSpecifier {
-  type: "ImportSpecifier";
-  imported: Identifier;
+    type: 'ImportSpecifier';
+    imported: Identifier;
 }
 
 export interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
+    type: 'ImportExpression';
+    source: Expression;
 }
 
 export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-  type: "ImportDefaultSpecifier";
+    type: 'ImportDefaultSpecifier';
 }
 
 export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-  type: "ImportNamespaceSpecifier";
+    type: 'ImportNamespaceSpecifier';
 }
 
 export interface ExportNamedDeclaration extends BaseModuleDeclaration {
-  type: "ExportNamedDeclaration";
-  declaration?: Declaration | null | undefined;
-  specifiers: Array<ExportSpecifier>;
-  source?: Literal | null | undefined;
+    type: 'ExportNamedDeclaration';
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    source?: Literal | null | undefined;
 }
 
 export interface ExportSpecifier extends BaseModuleSpecifier {
-  type: "ExportSpecifier";
-  exported: Identifier;
+    type: 'ExportSpecifier';
+    exported: Identifier;
 }
 
 export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-  type: "ExportDefaultDeclaration";
-  declaration: Declaration | Expression;
+    type: 'ExportDefaultDeclaration';
+    declaration: Declaration | Expression;
 }
 
 export interface ExportAllDeclaration extends BaseModuleDeclaration {
-  type: "ExportAllDeclaration";
-  exported: Identifier | null;
-  source: Literal;
+    type: 'ExportAllDeclaration';
+    exported: Identifier | null;
+    source: Literal;
 }
 
 export interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
+    type: 'AwaitExpression';
+    argument: Expression;
 }

estree/package.json

 {
     "name": "@types/estree",
-    "version": "0.0.52",
-    "description": "TypeScript definitions for ESTree AST specification",
+    "version": "1.0.0",
+    "description": "TypeScript definitions for estree",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
@@ -23,4 +23,4 @@ "license": "MIT",
     "dependencies": {},
-    "typesPublisherContentHash": "b0676d90e8ad8d4e2e79cad828f7376d13fcbceea7d6df658e0910ff66daa200",
+    "typesPublisherContentHash": "a2ea4a390167d173308db373b92a5dc4b94a7e8263cc0de049320c577bb30fc1",
     "typeScriptVersion": "4.0"
 }

estree/README.md

@@ -5,3 +5,3 @@ # Installation
 # Summary
-This package contains type definitions for ESTree AST specification (https://github.com/estree/estree).
+This package contains type definitions for estree (https://github.com/estree/estree).
 
@@ -12,3 +12,3 @@ # Details
 ### Additional Details
- * Last updated: Sat, 25 Jun 2022 10:01:36 GMT
+ * Last updated: Tue, 12 Jul 2022 20:32:23 GMT
  * Dependencies: none
@@ -15,0 +15,0 @@ * Global values: none

New alerts

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

25667

3.33%

Lines of code

699

5.43%

Number of low quality alerts

0

-100%

Worsened metrics

Number of low supply chain risk alerts

1

Infinity%

No dependency changes