vue-eslint-parser

vue-eslint-parser

Version 9.4.3
Published 2 months ago
1.14 MB
7 dependencies
MIT license

Install

npm i vue-eslint-parser

yarn add vue-eslint-parser

pnpm add vue-eslint-parser

Overview

The ESLint custom parser for `.vue` files.

Index

Namespaces

vue-eslint-parser
vue-eslint-parser.AST
vue-eslint-parser/ast
vue-eslint-parser/ast/errors
- ErrorCode
- ParseError
vue-eslint-parser/ast/locations
vue-eslint-parser/ast/nodes
vue-eslint-parser/ast/tokens
- Token
vue-eslint-parser/ast/traverse

Namespaces

namespace vue-eslint-parser

module 'vue-eslint-parser' {}

variable meta

const meta: { name: string; version: string | undefined };

function parse

parse: (code: string, options: any) => AST.ESLintProgram;

function parseForESLint

parseForESLint: (code: string, parserOptions: any) => AST.ESLintExtendedProgram;

namespace vue-eslint-parser.AST

namespace vue-eslint-parser.AST {}

variable KEYS

const KEYS: Readonly<{ [type: string]: readonly string[] }>;

variable NS

const NS: Readonly<{
    HTML: 'http://www.w3.org/1999/xhtml';
    MathML: 'http://www.w3.org/1998/Math/MathML';
    SVG: 'http://www.w3.org/2000/svg';
    XLink: 'http://www.w3.org/1999/xlink';
    XML: 'http://www.w3.org/XML/1998/namespace';
    XMLNS: 'http://www.w3.org/2000/xmlns/';
}>;

function getFallbackKeys

getFallbackKeys: (node: Node) => string[];

function traverseNodes

traverseNodes: (node: Node, visitor: Visitor) => void;

class ParseError

class ParseError extends SyntaxError {}

constructor

constructor(
    message: string,
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
);

property code

code?: ErrorCode;

property column

column: number;

property index

index: number;

property lineNumber

lineNumber: number;

method fromCode

static fromCode: (
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
) => ParseError;

method isParseError

static isParseError: (x: any) => x is ParseError;

method normalize

static normalize: (x: any) => ParseError | null;

interface ESLintArrayExpression

interface ESLintArrayExpression extends HasLocation, HasParent {}

property elements

elements: (ESLintExpression | ESLintSpreadElement)[];

property type

type: 'ArrayExpression';

interface ESLintArrayPattern

interface ESLintArrayPattern extends HasLocation, HasParent {}

property elements

elements: ESLintPattern[];

property type

type: 'ArrayPattern';

interface ESLintArrowFunctionExpression

interface ESLintArrowFunctionExpression extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement | ESLintExpression;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'ArrowFunctionExpression';

interface ESLintAssignmentExpression

interface ESLintAssignmentExpression extends HasLocation, HasParent {}

property left

left: ESLintPattern;

property operator

operator:
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '**='
    | '<<='
    | '>>='
    | '>>>='
    | '|='
    | '^='
    | '&='
    | '||='
    | '&&='
    | '??=';

property right

right: ESLintExpression;

property type

type: 'AssignmentExpression';

interface ESLintAssignmentPattern

interface ESLintAssignmentPattern extends HasLocation, HasParent {}

property left

left: ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'AssignmentPattern';

interface ESLintAssignmentProperty

interface ESLintAssignmentProperty extends ESLintProperty {}

property kind

kind: 'init';

property method

method: false;

property value

value: ESLintPattern;

interface ESLintAwaitExpression

interface ESLintAwaitExpression extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'AwaitExpression';

interface ESLintBigIntLiteral

interface ESLintBigIntLiteral extends ESLintLiteralBase {}

property bigint

bigint: string;

property regex

regex?: undefined;

property value

value: null | bigint;

interface ESLintBinaryExpression

interface ESLintBinaryExpression extends HasLocation, HasParent {}

property left

left: ESLintExpression | ESLintPrivateIdentifier;

property operator

operator:
    | '=='
    | '!='
    | '==='
    | '!=='
    | '<'
    | '<='
    | '>'
    | '>='
    | '<<'
    | '>>'
    | '>>>'
    | '+'
    | '-'
    | '*'
    | '/'
    | '%'
    | '**'
    | '|'
    | '^'
    | '&'
    | 'in'
    | 'instanceof';

property right

right: ESLintExpression;

property type

type: 'BinaryExpression';

interface ESLintBlockStatement

interface ESLintBlockStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement[];

property type

type: 'BlockStatement';

interface ESLintBooleanLiteral

interface ESLintBooleanLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex?: undefined;

property value

value: boolean;

interface ESLintBreakStatement

interface ESLintBreakStatement extends HasLocation, HasParent {}

property label

label: ESLintIdentifier | null;

property type

type: 'BreakStatement';

interface ESLintCallExpression

interface ESLintCallExpression extends HasLocation, HasParent {}

property arguments

arguments: (ESLintExpression | ESLintSpreadElement)[];

property callee

callee: ESLintExpression | ESLintSuper;

property optional

optional: boolean;

property type

type: 'CallExpression';

interface ESLintCatchClause

interface ESLintCatchClause extends HasLocation, HasParent {}

property body

body: ESLintBlockStatement;

property param

param: ESLintPattern | null;

property type

type: 'CatchClause';

interface ESLintChainExpression

interface ESLintChainExpression extends HasLocation, HasParent {}

property expression

expression: ESLintChainElement;

property type

type: 'ChainExpression';

interface ESLintClassBody

interface ESLintClassBody extends HasLocation, HasParent {}

property body

body: (ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock)[];

property type

type: 'ClassBody';

interface ESLintClassDeclaration

interface ESLintClassDeclaration extends HasLocation, HasParent {}

property body

body: ESLintClassBody;

property id

id: ESLintIdentifier | null;

property superClass

superClass: ESLintExpression | null;

property type

type: 'ClassDeclaration';

interface ESLintClassExpression

interface ESLintClassExpression extends HasLocation, HasParent {}

property body

body: ESLintClassBody;

property id

id: ESLintIdentifier | null;

property superClass

superClass: ESLintExpression | null;

property type

type: 'ClassExpression';

interface ESLintConditionalExpression

interface ESLintConditionalExpression extends HasLocation, HasParent {}

property alternate

alternate: ESLintExpression;

property consequent

consequent: ESLintExpression;

property test

test: ESLintExpression;

property type

type: 'ConditionalExpression';

interface ESLintContinueStatement

interface ESLintContinueStatement extends HasLocation, HasParent {}

property label

label: ESLintIdentifier | null;

property type

type: 'ContinueStatement';

interface ESLintDebuggerStatement

interface ESLintDebuggerStatement extends HasLocation, HasParent {}

property type

type: 'DebuggerStatement';

interface ESLintDoWhileStatement

interface ESLintDoWhileStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property test

test: ESLintExpression;

property type

type: 'DoWhileStatement';

interface ESLintEmptyStatement

interface ESLintEmptyStatement extends HasLocation, HasParent {}

property type

type: 'EmptyStatement';

interface ESLintExportAllDeclaration

interface ESLintExportAllDeclaration extends HasLocation, HasParent {}

property exported

exported: ESLintIdentifier | ESLintStringLiteral | null;

property source

source: ESLintLiteral;

property type

type: 'ExportAllDeclaration';

interface ESLintExportDefaultDeclaration

interface ESLintExportDefaultDeclaration extends HasLocation, HasParent {}

property declaration

declaration: ESLintDeclaration | ESLintExpression;

property type

type: 'ExportDefaultDeclaration';

interface ESLintExportNamedDeclaration

interface ESLintExportNamedDeclaration extends HasLocation, HasParent {}

property declaration

declaration?: ESLintDeclaration | null;

property source

source?: ESLintLiteral | null;

property specifiers

specifiers: ESLintExportSpecifier[];

property type

type: 'ExportNamedDeclaration';

interface ESLintExportSpecifier

interface ESLintExportSpecifier extends HasLocation, HasParent {}

property exported

exported: ESLintIdentifier | ESLintStringLiteral;

property local

local: ESLintIdentifier | ESLintStringLiteral;

property type

type: 'ExportSpecifier';

interface ESLintExpressionStatement

interface ESLintExpressionStatement extends HasLocation, HasParent {}

property expression

expression: ESLintExpression;

property type

type: 'ExpressionStatement';

interface ESLintExtendedProgram

interface ESLintExtendedProgram {}

property ast

ast: ESLintProgram;

property scopeManager

scopeManager?: ScopeManager;

property services

services?: {};

property visitorKeys

visitorKeys?: {
    [type: string]: string[];
};

interface ESLintForInStatement

interface ESLintForInStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property left

left: ESLintVariableDeclaration | ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'ForInStatement';

interface ESLintForOfStatement

interface ESLintForOfStatement extends HasLocation, HasParent {}

property await

await: boolean;

property body

body: ESLintStatement;

property left

left: ESLintVariableDeclaration | ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'ForOfStatement';

interface ESLintForStatement

interface ESLintForStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property init

init: ESLintVariableDeclaration | ESLintExpression | null;

property test

test: ESLintExpression | null;

property type

type: 'ForStatement';

property update

update: ESLintExpression | null;

interface ESLintFunctionDeclaration

interface ESLintFunctionDeclaration extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'FunctionDeclaration';

interface ESLintFunctionExpression

interface ESLintFunctionExpression extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'FunctionExpression';

interface ESLintIdentifier

interface ESLintIdentifier extends HasLocation, HasParent {}

property name

name: string;

property type

type: 'Identifier';

interface ESLintIfStatement

interface ESLintIfStatement extends HasLocation, HasParent {}

property alternate

alternate: ESLintStatement | null;

property consequent

consequent: ESLintStatement;

property test

test: ESLintExpression;

property type

type: 'IfStatement';

interface ESLintImportDeclaration

interface ESLintImportDeclaration extends HasLocation, HasParent {}

property source

source: ESLintLiteral;

property specifiers

specifiers: (
    | ESLintImportSpecifier
    | ESLintImportDefaultSpecifier
    | ESLintImportNamespaceSpecifier
)[];

property type

type: 'ImportDeclaration';

interface ESLintImportDefaultSpecifier

interface ESLintImportDefaultSpecifier extends HasLocation, HasParent {}

property local

local: ESLintIdentifier;

property type

type: 'ImportDefaultSpecifier';

interface ESLintImportExpression

interface ESLintImportExpression extends HasLocation, HasParent {}

property source

source: ESLintExpression;

property type

type: 'ImportExpression';

interface ESLintImportNamespaceSpecifier

interface ESLintImportNamespaceSpecifier extends HasLocation, HasParent {}

property local

local: ESLintIdentifier;

property type

type: 'ImportNamespaceSpecifier';

interface ESLintImportSpecifier

interface ESLintImportSpecifier extends HasLocation, HasParent {}

property imported

imported: ESLintIdentifier | ESLintStringLiteral;

property local

local: ESLintIdentifier;

property type

type: 'ImportSpecifier';

interface ESLintLabeledStatement

interface ESLintLabeledStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property label

label: ESLintIdentifier;

property type

type: 'LabeledStatement';

interface ESLintLegacyRestProperty

interface ESLintLegacyRestProperty extends HasLocation, HasParent {}

property argument

argument: ESLintPattern;

property type

type: 'RestProperty' | 'ExperimentalRestProperty';

interface ESLintLegacySpreadProperty

interface ESLintLegacySpreadProperty extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'SpreadProperty' | 'ExperimentalSpreadProperty';

interface ESLintLogicalExpression

interface ESLintLogicalExpression extends HasLocation, HasParent {}

property left

left: ESLintExpression;

property operator

operator: '||' | '&&' | '??';

property right

right: ESLintExpression;

property type

type: 'LogicalExpression';

interface ESLintMemberExpression

interface ESLintMemberExpression extends HasLocation, HasParent {}

property computed

computed: boolean;

property object

object: ESLintExpression | ESLintSuper;

property optional

optional: boolean;

property property

property: ESLintExpression | ESLintPrivateIdentifier;

property type

type: 'MemberExpression';

interface ESLintMetaProperty

interface ESLintMetaProperty extends HasLocation, HasParent {}

property meta

meta: ESLintIdentifier;

property property

property: ESLintIdentifier;

property type

type: 'MetaProperty';

interface ESLintMethodDefinition

interface ESLintMethodDefinition extends HasLocation, HasParent {}

property computed

computed: boolean;

property key

key: ESLintExpression | ESLintPrivateIdentifier;

property kind

kind: 'constructor' | 'method' | 'get' | 'set';

property static

static: boolean;

property type

type: 'MethodDefinition';

property value

value: ESLintFunctionExpression;

interface ESLintNewExpression

interface ESLintNewExpression extends HasLocation, HasParent {}

property arguments

arguments: (ESLintExpression | ESLintSpreadElement)[];

property callee

callee: ESLintExpression;

property type

type: 'NewExpression';

interface ESLintNullLiteral

interface ESLintNullLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex?: undefined;

property value

value: null;

interface ESLintNumberLiteral

interface ESLintNumberLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex?: undefined;

property value

value: number;

interface ESLintObjectExpression

interface ESLintObjectExpression extends HasLocation, HasParent {}

property properties

properties: (
    | ESLintProperty
    | ESLintSpreadElement
    | ESLintLegacySpreadProperty
)[];

property type

type: 'ObjectExpression';

interface ESLintObjectPattern

interface ESLintObjectPattern extends HasLocation, HasParent {}

property properties

properties: (
    | ESLintAssignmentProperty
    | ESLintRestElement
    | ESLintLegacyRestProperty
)[];

property type

type: 'ObjectPattern';

interface ESLintPrivateIdentifier

interface ESLintPrivateIdentifier extends HasLocation, HasParent {}

property name

name: string;

property type

type: 'PrivateIdentifier';

interface ESLintProgram

interface ESLintProgram extends HasLocation, HasParent {}

property body

body: (ESLintStatement | ESLintModuleDeclaration)[];

property comments

comments?: Token[];

property errors

errors?: ParseError[];

property sourceType

sourceType: 'script' | 'module';

property templateBody

templateBody?: VElement & HasConcreteInfo;

property tokens

tokens?: Token[];

property type

type: 'Program';

interface ESLintProperty

interface ESLintProperty extends HasLocation, HasParent {}

property computed

computed: boolean;

property key

key: ESLintExpression;

property kind

kind: 'init' | 'get' | 'set';

property method

method: boolean;

property shorthand

shorthand: boolean;

property type

type: 'Property';

property value

value: ESLintExpression | ESLintPattern;

interface ESLintPropertyDefinition

interface ESLintPropertyDefinition extends HasLocation, HasParent {}

property computed

computed: boolean;

property key

key: ESLintExpression | ESLintPrivateIdentifier;

property static

static: boolean;

property type

type: 'PropertyDefinition';

property value

value: ESLintExpression | null;

interface ESLintRegExpLiteral

interface ESLintRegExpLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex: {
    pattern: string;
    flags: string;
};

property value

value: null | RegExp;

interface ESLintRestElement

interface ESLintRestElement extends HasLocation, HasParent {}

property argument

argument: ESLintPattern;

property type

type: 'RestElement';

interface ESLintReturnStatement

interface ESLintReturnStatement extends HasLocation, HasParent {}

property argument

argument: ESLintExpression | null;

property type

type: 'ReturnStatement';

interface ESLintSequenceExpression

interface ESLintSequenceExpression extends HasLocation, HasParent {}

property expressions

expressions: ESLintExpression[];

property type

type: 'SequenceExpression';

interface ESLintSpreadElement

interface ESLintSpreadElement extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'SpreadElement';

interface ESLintStaticBlock

interface ESLintStaticBlock
    extends HasLocation,
        HasParent,
        Omit<ESLintBlockStatement, 'type'> {}

property body

body: ESLintStatement[];

property type

type: 'StaticBlock';

interface ESLintStringLiteral

interface ESLintStringLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex?: undefined;

property value

value: string;

interface ESLintSuper

interface ESLintSuper extends HasLocation, HasParent {}

property type

type: 'Super';

interface ESLintSwitchCase

interface ESLintSwitchCase extends HasLocation, HasParent {}

property consequent

consequent: ESLintStatement[];

property test

test: ESLintExpression | null;

property type

type: 'SwitchCase';

interface ESLintSwitchStatement

interface ESLintSwitchStatement extends HasLocation, HasParent {}

property cases

cases: ESLintSwitchCase[];

property discriminant

discriminant: ESLintExpression;

property type

type: 'SwitchStatement';

interface ESLintTaggedTemplateExpression

interface ESLintTaggedTemplateExpression extends HasLocation, HasParent {}

property quasi

quasi: ESLintTemplateLiteral;

property tag

tag: ESLintExpression;

property type

type: 'TaggedTemplateExpression';

interface ESLintTemplateElement

interface ESLintTemplateElement extends HasLocation, HasParent {}

property tail

tail: boolean;

property type

type: 'TemplateElement';

property value

value: {
    cooked: string | null;
    raw: string;
};

interface ESLintTemplateLiteral

interface ESLintTemplateLiteral extends HasLocation, HasParent {}

property expressions

expressions: ESLintExpression[];

property quasis

quasis: ESLintTemplateElement[];

property type

type: 'TemplateLiteral';

interface ESLintThisExpression

interface ESLintThisExpression extends HasLocation, HasParent {}

property type

type: 'ThisExpression';

interface ESLintThrowStatement

interface ESLintThrowStatement extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'ThrowStatement';

interface ESLintTryStatement

interface ESLintTryStatement extends HasLocation, HasParent {}

property block

block: ESLintBlockStatement;

property finalizer

finalizer: ESLintBlockStatement | null;

property handler

handler: ESLintCatchClause | null;

property type

type: 'TryStatement';

interface ESLintUnaryExpression

interface ESLintUnaryExpression extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property operator

operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';

property prefix

prefix: boolean;

property type

type: 'UnaryExpression';

interface ESLintUpdateExpression

interface ESLintUpdateExpression extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property operator

operator: '++' | '--';

property prefix

prefix: boolean;

property type

type: 'UpdateExpression';

interface ESLintVariableDeclaration

interface ESLintVariableDeclaration extends HasLocation, HasParent {}

property declarations

declarations: ESLintVariableDeclarator[];

property kind

kind: 'var' | 'let' | 'const';

property type

type: 'VariableDeclaration';

interface ESLintVariableDeclarator

interface ESLintVariableDeclarator extends HasLocation, HasParent {}

property id

id: ESLintPattern;

property init

init: ESLintExpression | null;

property type

type: 'VariableDeclarator';

interface ESLintWhileStatement

interface ESLintWhileStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property test

test: ESLintExpression;

property type

type: 'WhileStatement';

interface ESLintWithStatement

interface ESLintWithStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property object

object: ESLintExpression;

property type

type: 'WithStatement';

interface ESLintYieldExpression

interface ESLintYieldExpression extends HasLocation, HasParent {}

property argument

argument: ESLintExpression | null;

property delegate

delegate: boolean;

property type

type: 'YieldExpression';

interface HasConcreteInfo

interface HasConcreteInfo {}

property comments

comments: Token[];

property errors

errors: ParseError[];

property tokens

tokens: Token[];

interface HasLocation

interface HasLocation {}

property end

end?: number;

property loc

loc: LocationRange;

property range

range: OffsetRange;

property start

start?: number;

interface HasParent

interface HasParent {}

property parent

parent?: Node | null;

interface Location

interface Location {}

property column

column: number;

property line

line: number;

interface LocationRange

interface LocationRange {}

property end

end: Location;

property start

start: Location;

interface Reference

interface Reference {}

property id

id: ESLintIdentifier;

property isTypeReference

isTypeReference?: boolean;

property isValueReference

isValueReference?: boolean;

property mode

mode: 'rw' | 'r' | 'w';

property variable

variable: Variable | null;

interface Token

interface Token extends HasLocation {}

property type

type: string;

property value

value: string;

interface Variable

interface Variable {}

property id

id: ESLintIdentifier;

property kind

kind: 'v-for' | 'scope' | 'generic';

property references

references: Reference[];

interface VAttribute

interface VAttribute extends HasLocation, HasParent {}

property directive

directive: false;

property key

key: VIdentifier;

property parent

parent: VStartTag;

property type

type: 'VAttribute';

property value

value: VLiteral | null;

interface VDirective

interface VDirective extends HasLocation, HasParent {}

property directive

directive: true;

property key

key: VDirectiveKey;

property parent

parent: VStartTag;

property type

type: 'VAttribute';

property value

value: VExpressionContainer | null;

interface VDirectiveKey

interface VDirectiveKey extends HasLocation, HasParent {}

property argument

argument: VExpressionContainer | VIdentifier | null;

property modifiers

modifiers: VIdentifier[];

property name

name: VIdentifier;

property parent

parent: VDirective;

property type

type: 'VDirectiveKey';

interface VDocumentFragment

interface VDocumentFragment extends HasLocation, HasParent, HasConcreteInfo {}

property children

children: (VElement | VText | VExpressionContainer | VStyleElement)[];

property parent

parent: null;

property type

type: 'VDocumentFragment';

interface VElement

interface VElement extends HasLocation, HasParent {}

property children

children: (VElement | VText | VExpressionContainer)[];

property endTag

endTag: VEndTag | null;

property name

name: string;

property namespace

namespace: Namespace;

property parent

parent: VDocumentFragment | VElement;

property rawName

rawName: string;

property startTag

startTag: VStartTag;

property type

type: 'VElement';

property variables

variables: Variable[];

interface VEndTag

interface VEndTag extends HasLocation, HasParent {}

property parent

parent: VElement;

property type

type: 'VEndTag';

interface VExpressionContainer

interface VExpressionContainer extends HasLocation, HasParent {}

property expression

expression:
    | ESLintExpression
    | VFilterSequenceExpression
    | VForExpression
    | VOnExpression
    | VSlotScopeExpression
    | VGenericExpression
    | null;

property parent

parent: VDocumentFragment | VElement | VDirective | VDirectiveKey;

property references

references: Reference[];

property type

type: 'VExpressionContainer';

interface VFilter

interface VFilter extends HasLocation, HasParent {}

property arguments

arguments: (ESLintExpression | ESLintSpreadElement)[];

property callee

callee: ESLintIdentifier;

property parent

parent: VFilterSequenceExpression;

property type

type: 'VFilter';

interface VFilterSequenceExpression

interface VFilterSequenceExpression extends HasLocation, HasParent {}

property expression

expression: ESLintExpression;

property filters

filters: VFilter[];

property parent

parent: VExpressionContainer;

property type

type: 'VFilterSequenceExpression';

interface VForExpression

interface VForExpression extends HasLocation, HasParent {}

property left

left: ESLintPattern[];

property parent

parent: VExpressionContainer;

property right

right: ESLintExpression;

property type

type: 'VForExpression';

interface VGenericExpression

interface VGenericExpression extends HasLocation, HasParent {}

property params

params: TSESTree.TSTypeParameterDeclaration['params'];

property parent

parent: VExpressionContainer;

property rawParams

rawParams: string[];

property type

type: 'VGenericExpression';

interface VIdentifier

interface VIdentifier extends HasLocation, HasParent {}

property name

name: string;

property parent

parent: VAttribute | VDirectiveKey;

property rawName

rawName: string;

property type

type: 'VIdentifier';

interface Visitor

interface Visitor {}

property visitorKeys

visitorKeys?: VisitorKeys;

method enterNode

enterNode: (node: Node, parent: Node | null) => void;

method leaveNode

leaveNode: (node: Node, parent: Node | null) => void;

interface VLiteral

interface VLiteral extends HasLocation, HasParent {}

property parent

parent: VAttribute;

property type

type: 'VLiteral';

property value

value: string;

interface VOnExpression

interface VOnExpression extends HasLocation, HasParent {}

property body

body: ESLintStatement[];

property parent

parent: VExpressionContainer;

property type

type: 'VOnExpression';

interface VSlotScopeExpression

interface VSlotScopeExpression extends HasLocation, HasParent {}

property params

params: ESLintPattern[];

property parent

parent: VExpressionContainer;

property type

type: 'VSlotScopeExpression';

interface VStartTag

interface VStartTag extends HasLocation, HasParent {}

property attributes

attributes: (VAttribute | VDirective)[];

property parent

parent: VElement;

property selfClosing

selfClosing: boolean;

property type

type: 'VStartTag';

interface VStyleElement

interface VStyleElement extends VElement {}

property children

children: (VText | VExpressionContainer)[];

property name

name: 'style';

property style

style: true;

property type

type: 'VElement';

interface VText

interface VText extends HasLocation, HasParent {}

property parent

parent: VDocumentFragment | VElement;

property type

type: 'VText';

property value

value: string;

type ErrorCode

type ErrorCode =
    | 'abrupt-closing-of-empty-comment'
    | 'absence-of-digits-in-numeric-character-reference'
    | 'cdata-in-html-content'
    | 'character-reference-outside-unicode-range'
    | 'control-character-in-input-stream'
    | 'control-character-reference'
    | 'eof-before-tag-name'
    | 'eof-in-cdata'
    | 'eof-in-comment'
    | 'eof-in-tag'
    | 'incorrectly-closed-comment'
    | 'incorrectly-opened-comment'
    | 'invalid-first-character-of-tag-name'
    | 'missing-attribute-value'
    | 'missing-end-tag-name'
    | 'missing-semicolon-after-character-reference'
    | 'missing-whitespace-between-attributes'
    | 'nested-comment'
    | 'noncharacter-character-reference'
    | 'noncharacter-in-input-stream'
    | 'null-character-reference'
    | 'surrogate-character-reference'
    | 'surrogate-in-input-stream'
    | 'unexpected-character-in-attribute-name'
    | 'unexpected-character-in-unquoted-attribute-value'
    | 'unexpected-equals-sign-before-attribute-name'
    | 'unexpected-null-character'
    | 'unexpected-question-mark-instead-of-tag-name'
    | 'unexpected-solidus-in-tag'
    | 'unknown-named-character-reference'
    | 'end-tag-with-attributes'
    | 'duplicate-attribute'
    | 'end-tag-with-trailing-solidus'
    | 'non-void-html-element-start-tag-with-trailing-solidus'
    | 'x-invalid-end-tag'
    | 'x-invalid-namespace'
    | 'x-missing-interpolation-end';

type ESLintChainElement

type ESLintChainElement = ESLintCallExpression | ESLintMemberExpression;

type ESLintDeclaration

type ESLintDeclaration =
    | ESLintFunctionDeclaration
    | ESLintVariableDeclaration
    | ESLintClassDeclaration;

type ESLintExpression

type ESLintExpression =
    | ESLintThisExpression
    | ESLintArrayExpression
    | ESLintObjectExpression
    | ESLintFunctionExpression
    | ESLintArrowFunctionExpression
    | ESLintYieldExpression
    | ESLintLiteral
    | ESLintUnaryExpression
    | ESLintUpdateExpression
    | ESLintBinaryExpression
    | ESLintAssignmentExpression
    | ESLintLogicalExpression
    | ESLintMemberExpression
    | ESLintConditionalExpression
    | ESLintCallExpression
    | ESLintNewExpression
    | ESLintSequenceExpression
    | ESLintTemplateLiteral
    | ESLintTaggedTemplateExpression
    | ESLintClassExpression
    | ESLintMetaProperty
    | ESLintIdentifier
    | ESLintAwaitExpression
    | ESLintChainExpression;

type ESLintLiteral

type ESLintLiteral =
    | ESLintStringLiteral
    | ESLintBooleanLiteral
    | ESLintNullLiteral
    | ESLintNumberLiteral
    | ESLintRegExpLiteral
    | ESLintBigIntLiteral;

type ESLintModuleDeclaration

type ESLintModuleDeclaration =
    | ESLintImportDeclaration
    | ESLintExportNamedDeclaration
    | ESLintExportDefaultDeclaration
    | ESLintExportAllDeclaration;

type ESLintModuleSpecifier

type ESLintModuleSpecifier =
    | ESLintImportSpecifier
    | ESLintImportDefaultSpecifier
    | ESLintImportNamespaceSpecifier
    | ESLintExportSpecifier;

type ESLintNode

type ESLintNode =
    | ESLintIdentifier
    | ESLintLiteral
    | ESLintProgram
    | ESLintSwitchCase
    | ESLintCatchClause
    | ESLintVariableDeclarator
    | ESLintStatement
    | ESLintExpression
    | ESLintProperty
    | ESLintAssignmentProperty
    | ESLintSuper
    | ESLintTemplateElement
    | ESLintSpreadElement
    | ESLintPattern
    | ESLintClassBody
    | ESLintMethodDefinition
    | ESLintPropertyDefinition
    | ESLintStaticBlock
    | ESLintPrivateIdentifier
    | ESLintModuleDeclaration
    | ESLintModuleSpecifier
    | ESLintImportExpression
    | ESLintLegacyRestProperty;

type ESLintPattern

type ESLintPattern =
    | ESLintIdentifier
    | ESLintObjectPattern
    | ESLintArrayPattern
    | ESLintRestElement
    | ESLintAssignmentPattern
    | ESLintMemberExpression
    | ESLintLegacyRestProperty;

type ESLintStatement

type ESLintStatement =
    | ESLintExpressionStatement
    | ESLintBlockStatement
    | ESLintEmptyStatement
    | ESLintDebuggerStatement
    | ESLintWithStatement
    | ESLintReturnStatement
    | ESLintLabeledStatement
    | ESLintBreakStatement
    | ESLintContinueStatement
    | ESLintIfStatement
    | ESLintSwitchStatement
    | ESLintThrowStatement
    | ESLintTryStatement
    | ESLintWhileStatement
    | ESLintDoWhileStatement
    | ESLintForStatement
    | ESLintForInStatement
    | ESLintForOfStatement
    | ESLintDeclaration;

type Namespace

type Namespace =
    | typeof NS.HTML
    | typeof NS.MathML
    | typeof NS.SVG
    | typeof NS.XLink
    | typeof NS.XML
    | typeof NS.XMLNS;

type Node

type Node =
    | ESLintNode
    | VNode
    | VForExpression
    | VOnExpression
    | VSlotScopeExpression
    | VGenericExpression
    | VFilterSequenceExpression
    | VFilter;

type Offset

type Offset = number;

type OffsetRange

type OffsetRange = [Offset, Offset];

type VNode

type VNode =
    | VAttribute
    | VDirective
    | VDirectiveKey
    | VDocumentFragment
    | VElement
    | VEndTag
    | VExpressionContainer
    | VIdentifier
    | VLiteral
    | VStartTag
    | VText;

namespace vue-eslint-parser/ast

module 'vue-eslint-parser/ast' {}

variable KEYS

const KEYS: Readonly<{ [type: string]: readonly string[] }>;

variable NS

const NS: Readonly<{
    HTML: 'http://www.w3.org/1999/xhtml';
    MathML: 'http://www.w3.org/1998/Math/MathML';
    SVG: 'http://www.w3.org/2000/svg';
    XLink: 'http://www.w3.org/1999/xlink';
    XML: 'http://www.w3.org/XML/1998/namespace';
    XMLNS: 'http://www.w3.org/2000/xmlns/';
}>;

function getFallbackKeys

getFallbackKeys: (node: Node) => string[];

function traverseNodes

traverseNodes: (node: Node, visitor: Visitor) => void;

class ParseError

class ParseError extends SyntaxError {}

constructor

constructor(
    message: string,
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
);

property code

code?: ErrorCode;

property column

column: number;

property index

index: number;

property lineNumber

lineNumber: number;

method fromCode

static fromCode: (
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
) => ParseError;

method isParseError

static isParseError: (x: any) => x is ParseError;

method normalize

static normalize: (x: any) => ParseError | null;

interface ESLintArrayExpression

interface ESLintArrayExpression extends HasLocation, HasParent {}

property elements

elements: (ESLintExpression | ESLintSpreadElement)[];

property type

type: 'ArrayExpression';

interface ESLintArrayPattern

interface ESLintArrayPattern extends HasLocation, HasParent {}

property elements

elements: ESLintPattern[];

property type

type: 'ArrayPattern';

interface ESLintArrowFunctionExpression

interface ESLintArrowFunctionExpression extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement | ESLintExpression;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'ArrowFunctionExpression';

interface ESLintAssignmentExpression

interface ESLintAssignmentExpression extends HasLocation, HasParent {}

property left

left: ESLintPattern;

property operator

operator:
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '**='
    | '<<='
    | '>>='
    | '>>>='
    | '|='
    | '^='
    | '&='
    | '||='
    | '&&='
    | '??=';

property right

right: ESLintExpression;

property type

type: 'AssignmentExpression';

interface ESLintAssignmentPattern

interface ESLintAssignmentPattern extends HasLocation, HasParent {}

property left

left: ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'AssignmentPattern';

interface ESLintAssignmentProperty

interface ESLintAssignmentProperty extends ESLintProperty {}

property kind

kind: 'init';

property method

method: false;

property value

value: ESLintPattern;

interface ESLintAwaitExpression

interface ESLintAwaitExpression extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'AwaitExpression';

interface ESLintBigIntLiteral

interface ESLintBigIntLiteral extends ESLintLiteralBase {}

property bigint

bigint: string;

property regex

regex?: undefined;

property value

value: null | bigint;

interface ESLintBinaryExpression

interface ESLintBinaryExpression extends HasLocation, HasParent {}

property left

left: ESLintExpression | ESLintPrivateIdentifier;

property operator

operator:
    | '=='
    | '!='
    | '==='
    | '!=='
    | '<'
    | '<='
    | '>'
    | '>='
    | '<<'
    | '>>'
    | '>>>'
    | '+'
    | '-'
    | '*'
    | '/'
    | '%'
    | '**'
    | '|'
    | '^'
    | '&'
    | 'in'
    | 'instanceof';

property right

right: ESLintExpression;

property type

type: 'BinaryExpression';

interface ESLintBlockStatement

interface ESLintBlockStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement[];

property type

type: 'BlockStatement';

interface ESLintBooleanLiteral

interface ESLintBooleanLiteral extends ESLintLiteralBase {}

property bigint

bigint?: undefined;

property regex

regex?: undefined;

property value

value: boolean;

interface ESLintBreakStatement

interface ESLintBreakStatement extends HasLocation, HasParent {}

property label

label: ESLintIdentifier | null;

property type

type: 'BreakStatement';

interface ESLintCallExpression

interface ESLintCallExpression extends HasLocation, HasParent {}

property arguments

arguments: (ESLintExpression | ESLintSpreadElement)[];

property callee

callee: ESLintExpression | ESLintSuper;

property optional

optional: boolean;

property type

type: 'CallExpression';

interface ESLintCatchClause

interface ESLintCatchClause extends HasLocation, HasParent {}

property body

body: ESLintBlockStatement;

property param

param: ESLintPattern | null;

property type

type: 'CatchClause';

interface ESLintChainExpression

interface ESLintChainExpression extends HasLocation, HasParent {}

property expression

expression: ESLintChainElement;

property type

type: 'ChainExpression';

interface ESLintClassBody

interface ESLintClassBody extends HasLocation, HasParent {}

property body

body: (ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock)[];

property type

type: 'ClassBody';

interface ESLintClassDeclaration

interface ESLintClassDeclaration extends HasLocation, HasParent {}

property body

body: ESLintClassBody;

property id

id: ESLintIdentifier | null;

property superClass

superClass: ESLintExpression | null;

property type

type: 'ClassDeclaration';

interface ESLintClassExpression

interface ESLintClassExpression extends HasLocation, HasParent {}

property body

body: ESLintClassBody;

property id

id: ESLintIdentifier | null;

property superClass

superClass: ESLintExpression | null;

property type

type: 'ClassExpression';

interface ESLintConditionalExpression

interface ESLintConditionalExpression extends HasLocation, HasParent {}

property alternate

alternate: ESLintExpression;

property consequent

consequent: ESLintExpression;

property test

test: ESLintExpression;

property type

type: 'ConditionalExpression';

interface ESLintContinueStatement

interface ESLintContinueStatement extends HasLocation, HasParent {}

property label

label: ESLintIdentifier | null;

property type

type: 'ContinueStatement';

interface ESLintDebuggerStatement

interface ESLintDebuggerStatement extends HasLocation, HasParent {}

property type

type: 'DebuggerStatement';

interface ESLintDoWhileStatement

interface ESLintDoWhileStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property test

test: ESLintExpression;

property type

type: 'DoWhileStatement';

interface ESLintEmptyStatement

interface ESLintEmptyStatement extends HasLocation, HasParent {}

property type

type: 'EmptyStatement';

interface ESLintExportAllDeclaration

interface ESLintExportAllDeclaration extends HasLocation, HasParent {}

property exported

exported: ESLintIdentifier | ESLintStringLiteral | null;

property source

source: ESLintLiteral;

property type

type: 'ExportAllDeclaration';

interface ESLintExportDefaultDeclaration

interface ESLintExportDefaultDeclaration extends HasLocation, HasParent {}

property declaration

declaration: ESLintDeclaration | ESLintExpression;

property type

type: 'ExportDefaultDeclaration';

interface ESLintExportNamedDeclaration

interface ESLintExportNamedDeclaration extends HasLocation, HasParent {}

property declaration

declaration?: ESLintDeclaration | null;

property source

source?: ESLintLiteral | null;

property specifiers

specifiers: ESLintExportSpecifier[];

property type

type: 'ExportNamedDeclaration';

interface ESLintExportSpecifier

interface ESLintExportSpecifier extends HasLocation, HasParent {}

property exported

exported: ESLintIdentifier | ESLintStringLiteral;

property local

local: ESLintIdentifier | ESLintStringLiteral;

property type

type: 'ExportSpecifier';

interface ESLintExpressionStatement

interface ESLintExpressionStatement extends HasLocation, HasParent {}

property expression

expression: ESLintExpression;

property type

type: 'ExpressionStatement';

interface ESLintExtendedProgram

interface ESLintExtendedProgram {}

property ast

ast: ESLintProgram;

property scopeManager

scopeManager?: ScopeManager;

property services

services?: {};

property visitorKeys

visitorKeys?: {
    [type: string]: string[];
};

interface ESLintForInStatement

interface ESLintForInStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property left

left: ESLintVariableDeclaration | ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'ForInStatement';

interface ESLintForOfStatement

interface ESLintForOfStatement extends HasLocation, HasParent {}

property await

await: boolean;

property body

body: ESLintStatement;

property left

left: ESLintVariableDeclaration | ESLintPattern;

property right

right: ESLintExpression;

property type

type: 'ForOfStatement';

interface ESLintForStatement

interface ESLintForStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property init

init: ESLintVariableDeclaration | ESLintExpression | null;

property test

test: ESLintExpression | null;

property type

type: 'ForStatement';

property update

update: ESLintExpression | null;

interface ESLintFunctionDeclaration

interface ESLintFunctionDeclaration extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'FunctionDeclaration';

interface ESLintFunctionExpression

interface ESLintFunctionExpression extends HasLocation, HasParent {}

property async

async: boolean;

property body

body: ESLintBlockStatement;

property generator

generator: boolean;

property id

id: ESLintIdentifier | null;

property params

params: ESLintPattern[];

property type

type: 'FunctionExpression';

interface ESLintIdentifier

interface ESLintIdentifier extends HasLocation, HasParent {}

property name

name: string;

property type

type: 'Identifier';

interface ESLintIfStatement

interface ESLintIfStatement extends HasLocation, HasParent {}

property alternate

alternate: ESLintStatement | null;

property consequent

consequent: ESLintStatement;

property test

test: ESLintExpression;

property type

type: 'IfStatement';

interface ESLintImportDeclaration

interface ESLintImportDeclaration extends HasLocation, HasParent {}

property source

source: ESLintLiteral;

property specifiers

specifiers: (
    | ESLintImportSpecifier
    | ESLintImportDefaultSpecifier
    | ESLintImportNamespaceSpecifier
)[];

property type

type: 'ImportDeclaration';

interface ESLintImportDefaultSpecifier

interface ESLintImportDefaultSpecifier extends HasLocation, HasParent {}

property local

local: ESLintIdentifier;

property type

type: 'ImportDefaultSpecifier';

interface ESLintImportExpression

interface ESLintImportExpression extends HasLocation, HasParent {}

property source

source: ESLintExpression;

property type

type: 'ImportExpression';

interface ESLintImportNamespaceSpecifier

interface ESLintImportNamespaceSpecifier extends HasLocation, HasParent {}

property local

local: ESLintIdentifier;

property type

type: 'ImportNamespaceSpecifier';

interface ESLintImportSpecifier

interface ESLintImportSpecifier extends HasLocation, HasParent {}

property imported

imported: ESLintIdentifier | ESLintStringLiteral;

property local

local: ESLintIdentifier;

property type

type: 'ImportSpecifier';

interface ESLintLabeledStatement

interface ESLintLabeledStatement extends HasLocation, HasParent {}

property body

body: ESLintStatement;

property label

label: ESLintIdentifier;

property type

type: 'LabeledStatement';

interface ESLintLegacyRestProperty

interface ESLintLegacyRestProperty extends HasLocation, HasParent {}

property argument

argument: ESLintPattern;

property type

type: 'RestProperty' | 'ExperimentalRestProperty';

interface ESLintLegacySpreadProperty

interface ESLintLegacySpreadProperty extends HasLocation, HasParent {}

property argument

argument: ESLintExpression;

property type

type: 'SpreadProperty' | 'ExperimentalSpreadProperty';

interface ESLintLogicalExpression

interface ESLintLogicalExpression extends HasLocation, HasParent {}

property left

left: ESLintExpression;