@vue-vine/eslint-parser 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { ParserOptions, parseForESLint as parseForESLint$1 } from "@typescript-eslint/parser";
 import { ScopeManager } from "eslint-scope";
 import { TSESTree } from "@typescript-eslint/typescript-estree";
+import { ESLint, Linter } from "eslint";
 import { TSESTree as TSESTree$1 } from "@typescript-eslint/types";
 import { VisitorKeys } from "eslint-visitor-keys";
 
@@ -9,90 +10,90 @@ import { VisitorKeys } from "eslint-visitor-keys";
 * HTML parse errors.
 */
 /**
- * HTML parse errors.
- */
+* HTML parse errors.
+*/
 declare class ParseError extends SyntaxError {
   code?: ErrorCode;
   index: number;
   lineNumber: number;
   column: number;
   /**
-   * Create new parser error object.
-   * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
-   * @param offset The offset number of this error.
-   * @param line The line number of this error.
-   * @param column The column number of this error.
-   */
+  * Create new parser error object.
+  * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+  * @param offset The offset number of this error.
+  * @param line The line number of this error.
+  * @param column The column number of this error.
+  */
   static fromCode(code: ErrorCode, offset: number, line: number, column: number): ParseError;
   /**
-   * Normalize the error object.
-   * @param x The error object to normalize.
-   */
+  * Normalize the error object.
+  * @param x The error object to normalize.
+  */
   static normalize(x: any): ParseError | null;
   /**
-   * Initialize this ParseError instance.
-   * @param message The error message.
-   * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
-   * @param offset The offset number of this error.
-   * @param line The line number of this error.
-   * @param column The column number of this error.
-   */
+  * Initialize this ParseError instance.
+  * @param message The error message.
+  * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+  * @param offset The offset number of this error.
+  * @param line The line number of this error.
+  * @param column The column number of this error.
+  */
   constructor(message: string, code: ErrorCode | undefined, offset: number, line: number, column: number);
   /**
-   * Type guard for ParseError.
-   * @param x The value to check.
-   * @returns `true` if the value has `message`, `pos`, `loc` properties.
-   */
+  * Type guard for ParseError.
+  * @param x The value to check.
+  * @returns `true` if the value has `message`, `pos`, `loc` properties.
+  */
   static isParseError(x: any): x is ParseError;
 }
 /**
- * The error codes of HTML syntax errors.
- * https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
- */
-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'; //#endregion
+* The error codes of HTML syntax errors.
+* https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+*/
+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"; //#endregion
 //#region src/ast/locations.d.ts
 /**
- * Location information in lines and columns.
- */
+* Location information in lines and columns.
+*/
 interface Location {
   /**
-   * The line number. This is 1-based.
-   */
+  * The line number. This is 1-based.
+  */
   line: number;
   /**
-   * The column number. This is 0-based.
-   */
+  * The column number. This is 0-based.
+  */
   column: number;
 }
 /**
- * Range information in lines and columns.
- */
+* Range information in lines and columns.
+*/
 interface LocationRange {
   /**
-   * The start location.
-   */
+  * The start location.
+  */
   start: Location;
   /**
-   * The end location.
-   */
+  * The end location.
+  */
   end: Location;
 }
 /**
- * Location information in offsets.
- * This is 0-based.
- */
+* Location information in offsets.
+* This is 0-based.
+*/
 type Offset = number;
 /**
- * Range information in offsets.
- * The 1st element is the start offset.
- * The 2nd element is the end offset.
- *
- * This is 0-based.
- */
+* Range information in offsets.
+* The 1st element is the start offset.
+* The 2nd element is the end offset.
+*
+* This is 0-based.
+*/
 type OffsetRange = [Offset, Offset];
 /**
- * Objects which have their location.
- */
+* Objects which have their location.
+*/
 interface HasLocation {
   range: OffsetRange;
   loc: LocationRange;
@@ -100,109 +101,51 @@ interface HasLocation {
   end?: number;
 }
 
-//#endregion
-//#region src/common/parser-object.d.ts
-/**
- * The type of basic ESLint custom parser.
- * e.g. espree
- */
-interface BasicParserObject<R = ESLintProgram> {
-  parse: (code: string, options: any) => R;
-  parseForESLint: undefined;
-}
-/**
- * The type of ESLint custom parser enhanced for ESLint.
- * e.g. @babel/eslint-parser, @typescript-eslint/parser
- */
-interface EnhancedParserObject<R = ESLintExtendedProgram> {
-  parseForESLint: (code: string, options: any) => R;
-  parse: undefined;
-}
-/**
- * The type of ESLint (custom) parsers.
- */
-type ParserObject<R1 = ESLintExtendedProgram, R2 = ESLintProgram> = EnhancedParserObject<R1> | BasicParserObject<R2>;
-
-//#endregion
-//#region src/template/utils/process-vine-template-node.d.ts
-declare function prepareTemplate(templateNode: TSESTree.TaggedTemplateExpression): {
-  templatePositionInfo: {
-    templateStartLine: number;
-    templateStartColumn: number;
-    templateStartOffset: number;
-    templateEndOffset: number;
-    templateEndLine: number;
-    templateEndColumn: number;
-  };
-  templateRawContent: string;
-};
-
-//#endregion
-//#region src/types.d.ts
-type PrettierType<T> = { [K in keyof T]: T[K] } & {};
-type TsESLintParseForESLint = ReturnType<typeof parseForESLint$1>;
-interface ParseForESLintResult {
-  ast: ESLintProgram;
-  services: TsESLintParseForESLint['services'];
-  scopeManager: TsESLintParseForESLint['scopeManager'];
-  visitorKeys: TsESLintParseForESLint['visitorKeys'];
-}
-type VineESLintParserOptions = ParserOptions & {
-  parser?: boolean | string | ParserObject | Record<string, string | ParserObject | undefined>;
-  ecmaFeatures?: ParserOptions['ecmaFeatures'] & {
-    [key: string]: any;
-  };
-  sourceType?: 'module' | 'script';
-};
-interface VineTemplateMeta {
-  tokens: Token[];
-  comments: Token[];
-  errors: ParseError[];
-}
-type FinalProcessTemplateInfo = ReturnType<typeof prepareTemplate> & {
-  templateRootAST: VTemplateRoot;
-  templateMeta: VineTemplateMeta;
-};
-
 //#endregion
 //#region src/ast/tokens.d.ts
 /**
- * Tokens.
- */
+* Tokens.
+*/
 interface Token extends HasLocation {
   /**
-   * Token types.
-   */
+  * Token types.
+  */
   type: string;
   /**
-   * Processed values.
-   */
+  * Processed values.
+  */
   value: string;
 }
 
 //#endregion
 //#region src/ast/nodes.d.ts
+// ------------------------------------------------------------------------------
+// Common
+// ------------------------------------------------------------------------------
 /**
- * Objects which have their parent.
- */
+* Objects which have their parent.
+*/
 interface HasParent {
   parent?: Node | null;
 }
 /**
- * The union type for all nodes.
- */
+* The union type for all nodes.
+*/
 type Node = ESLintNode | VNode | VForExpression | VOnExpression | VSlotScopeExpression | VFilterSequenceExpression | VFilter;
 /**
- * The union type for all template nodes.
- */
+* The union type for all template nodes.
+*/
 type VTemplateNode = VNode | VForExpression | VOnExpression | VSlotScopeExpression | VFilterSequenceExpression | VFilter;
+// ------------------------------------------------------------------------------
+// Script
+// ------------------------------------------------------------------------------
 /**
- * The union type for ESLint nodes.
- */
+* The union type for ESLint nodes.
+*/
 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;
 /**
- * The parsing result of ESLint custom parsers.
- */
+* The parsing result of ESLint custom parsers.
+*/
 interface ESLintExtendedProgram {
   ast: ESLintProgram;
   services?: Record<string, unknown>;
@@ -212,8 +155,8 @@ interface ESLintExtendedProgram {
   scopeManager?: ScopeManager;
 }
 interface ESLintProgram extends HasLocation, HasParent {
-  type: 'Program';
-  sourceType: 'script' | 'module';
+  type: "Program";
+  sourceType: "script" | "module";
   body: (ESLintStatement | ESLintModuleDeclaration)[];
   templateBody?: VElement & HasConcreteInfo;
   tokens?: Token[];
@@ -222,110 +165,110 @@ interface ESLintProgram extends HasLocation, HasParent {
 }
 type ESLintStatement = ESLintExpressionStatement | ESLintDirective | ESLintBlockStatement | ESLintEmptyStatement | ESLintDebuggerStatement | ESLintWithStatement | ESLintReturnStatement | ESLintLabeledStatement | ESLintBreakStatement | ESLintContinueStatement | ESLintIfStatement | ESLintSwitchStatement | ESLintThrowStatement | ESLintTryStatement | ESLintWhileStatement | ESLintDoWhileStatement | ESLintForStatement | ESLintForInStatement | ESLintForOfStatement | ESLintDeclaration;
 interface ESLintEmptyStatement extends HasLocation, HasParent {
-  type: 'EmptyStatement';
+  type: "EmptyStatement";
 }
 interface ESLintBlockStatement extends HasLocation, HasParent {
-  type: 'BlockStatement';
+  type: "BlockStatement";
   body: ESLintStatement[];
 }
 interface ESLintExpressionStatement extends HasLocation, HasParent {
-  type: 'ExpressionStatement';
+  type: "ExpressionStatement";
   expression: ESLintExpression;
 }
 interface ESLintDirective extends HasLocation, HasParent {
-  type: 'ExpressionStatement';
+  type: "ExpressionStatement";
   expression: ESLintLiteral;
   directive: string;
 }
 interface ESLintIfStatement extends HasLocation, HasParent {
-  type: 'IfStatement';
+  type: "IfStatement";
   test: ESLintExpression;
   consequent: ESLintStatement;
   alternate: ESLintStatement | null;
 }
 interface ESLintSwitchStatement extends HasLocation, HasParent {
-  type: 'SwitchStatement';
+  type: "SwitchStatement";
   discriminant: ESLintExpression;
   cases: ESLintSwitchCase[];
 }
 interface ESLintSwitchCase extends HasLocation, HasParent {
-  type: 'SwitchCase';
+  type: "SwitchCase";
   test: ESLintExpression | null;
   consequent: ESLintStatement[];
 }
 interface ESLintWhileStatement extends HasLocation, HasParent {
-  type: 'WhileStatement';
+  type: "WhileStatement";
   test: ESLintExpression;
   body: ESLintStatement;
 }
 interface ESLintDoWhileStatement extends HasLocation, HasParent {
-  type: 'DoWhileStatement';
+  type: "DoWhileStatement";
   body: ESLintStatement;
   test: ESLintExpression;
 }
 interface ESLintForStatement extends HasLocation, HasParent {
-  type: 'ForStatement';
+  type: "ForStatement";
   init: ESLintVariableDeclaration | ESLintExpression | null;
   test: ESLintExpression | null;
   update: ESLintExpression | null;
   body: ESLintStatement;
 }
 interface ESLintForInStatement extends HasLocation, HasParent {
-  type: 'ForInStatement';
+  type: "ForInStatement";
   left: ESLintVariableDeclaration | ESLintPattern;
   right: ESLintExpression;
   body: ESLintStatement;
 }
 interface ESLintForOfStatement extends HasLocation, HasParent {
-  type: 'ForOfStatement';
+  type: "ForOfStatement";
   left: ESLintVariableDeclaration | ESLintPattern;
   right: ESLintExpression;
   body: ESLintStatement;
   await: boolean;
 }
 interface ESLintLabeledStatement extends HasLocation, HasParent {
-  type: 'LabeledStatement';
+  type: "LabeledStatement";
   label: ESLintIdentifier;
   body: ESLintStatement;
 }
 interface ESLintBreakStatement extends HasLocation, HasParent {
-  type: 'BreakStatement';
+  type: "BreakStatement";
   label: ESLintIdentifier | null;
 }
 interface ESLintContinueStatement extends HasLocation, HasParent {
-  type: 'ContinueStatement';
+  type: "ContinueStatement";
   label: ESLintIdentifier | null;
 }
 interface ESLintReturnStatement extends HasLocation, HasParent {
-  type: 'ReturnStatement';
+  type: "ReturnStatement";
   argument: ESLintExpression | null;
 }
 interface ESLintThrowStatement extends HasLocation, HasParent {
-  type: 'ThrowStatement';
+  type: "ThrowStatement";
   argument: ESLintExpression;
 }
 interface ESLintTryStatement extends HasLocation, HasParent {
-  type: 'TryStatement';
+  type: "TryStatement";
   block: ESLintBlockStatement;
   handler: ESLintCatchClause | null;
   finalizer: ESLintBlockStatement | null;
 }
 interface ESLintCatchClause extends HasLocation, HasParent {
-  type: 'CatchClause';
+  type: "CatchClause";
   param: ESLintPattern | null;
   body: ESLintBlockStatement;
 }
 interface ESLintWithStatement extends HasLocation, HasParent {
-  type: 'WithStatement';
+  type: "WithStatement";
   object: ESLintExpression;
   body: ESLintStatement;
 }
 interface ESLintDebuggerStatement extends HasLocation, HasParent {
-  type: 'DebuggerStatement';
+  type: "DebuggerStatement";
 }
 type ESLintDeclaration = ESLintFunctionDeclaration | ESLintVariableDeclaration | ESLintClassDeclaration;
 interface ESLintFunctionDeclaration extends HasLocation, HasParent {
-  type: 'FunctionDeclaration';
+  type: "FunctionDeclaration";
   async: boolean;
   generator: boolean;
   id: ESLintIdentifier | null;
@@ -333,99 +276,99 @@ interface ESLintFunctionDeclaration extends HasLocation, HasParent {
   body: ESLintBlockStatement;
 }
 interface ESLintVariableDeclaration extends HasLocation, HasParent {
-  type: 'VariableDeclaration';
-  kind: 'var' | 'let' | 'const';
+  type: "VariableDeclaration";
+  kind: "var" | "let" | "const";
   declarations: ESLintVariableDeclarator[];
 }
 interface ESLintVariableDeclarator extends HasLocation, HasParent {
-  type: 'VariableDeclarator';
+  type: "VariableDeclarator";
   id: ESLintPattern;
   init: ESLintExpression | null;
 }
 interface ESLintClassDeclaration extends HasLocation, HasParent {
-  type: 'ClassDeclaration';
+  type: "ClassDeclaration";
   id: ESLintIdentifier | null;
   superClass: ESLintExpression | null;
   body: ESLintClassBody;
 }
 interface ESLintClassBody extends HasLocation, HasParent {
-  type: 'ClassBody';
+  type: "ClassBody";
   body: (ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock)[];
 }
 interface ESLintMethodDefinition extends HasLocation, HasParent {
-  type: 'MethodDefinition';
-  kind: 'constructor' | 'method' | 'get' | 'set';
+  type: "MethodDefinition";
+  kind: "constructor" | "method" | "get" | "set";
   computed: boolean;
   static: boolean;
   key: ESLintExpression | ESLintPrivateIdentifier;
   value: ESLintFunctionExpression;
 }
 interface ESLintPropertyDefinition extends HasLocation, HasParent {
-  type: 'PropertyDefinition';
+  type: "PropertyDefinition";
   computed: boolean;
   static: boolean;
   key: ESLintExpression | ESLintPrivateIdentifier;
   value: ESLintExpression | null;
 }
-interface ESLintStaticBlock extends HasLocation, HasParent, Omit<ESLintBlockStatement, 'type'> {
-  type: 'StaticBlock';
+interface ESLintStaticBlock extends HasLocation, HasParent, Omit<ESLintBlockStatement, "type"> {
+  type: "StaticBlock";
   body: ESLintStatement[];
 }
 interface ESLintPrivateIdentifier extends HasLocation, HasParent {
-  type: 'PrivateIdentifier';
+  type: "PrivateIdentifier";
   name: string;
 }
 type ESLintModuleDeclaration = ESLintImportDeclaration | ESLintExportNamedDeclaration | ESLintExportDefaultDeclaration | ESLintExportAllDeclaration;
 type ESLintModuleSpecifier = ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier | ESLintExportSpecifier;
 interface ESLintImportDeclaration extends HasLocation, HasParent {
-  type: 'ImportDeclaration';
+  type: "ImportDeclaration";
   specifiers: (ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier)[];
   source: ESLintLiteral;
 }
 interface ESLintImportSpecifier extends HasLocation, HasParent {
-  type: 'ImportSpecifier';
+  type: "ImportSpecifier";
   imported: ESLintIdentifier | ESLintStringLiteral;
   local: ESLintIdentifier;
 }
 interface ESLintImportDefaultSpecifier extends HasLocation, HasParent {
-  type: 'ImportDefaultSpecifier';
+  type: "ImportDefaultSpecifier";
   local: ESLintIdentifier;
 }
 interface ESLintImportNamespaceSpecifier extends HasLocation, HasParent {
-  type: 'ImportNamespaceSpecifier';
+  type: "ImportNamespaceSpecifier";
   local: ESLintIdentifier;
 }
 interface ESLintImportExpression extends HasLocation, HasParent {
-  type: 'ImportExpression';
+  type: "ImportExpression";
   source: ESLintExpression;
 }
 interface ESLintExportNamedDeclaration extends HasLocation, HasParent {
-  type: 'ExportNamedDeclaration';
+  type: "ExportNamedDeclaration";
   declaration?: ESLintDeclaration | null;
   specifiers: ESLintExportSpecifier[];
   source?: ESLintLiteral | null;
 }
 interface ESLintExportSpecifier extends HasLocation, HasParent {
-  type: 'ExportSpecifier';
+  type: "ExportSpecifier";
   local: ESLintIdentifier | ESLintStringLiteral;
   exported: ESLintIdentifier | ESLintStringLiteral;
 }
 interface ESLintExportDefaultDeclaration extends HasLocation, HasParent {
-  type: 'ExportDefaultDeclaration';
+  type: "ExportDefaultDeclaration";
   declaration: ESLintDeclaration | ESLintExpression;
 }
 interface ESLintExportAllDeclaration extends HasLocation, HasParent {
-  type: 'ExportAllDeclaration';
+  type: "ExportAllDeclaration";
   exported: ESLintIdentifier | ESLintStringLiteral | null;
   source: ESLintLiteral;
 }
 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;
 interface ESLintIdentifier extends HasLocation, HasParent {
-  type: 'Identifier';
+  type: "Identifier";
   name: string;
 }
 interface ESLintLiteralBase extends HasLocation, HasParent {
-  type: 'Literal';
+  type: "Literal";
   value: string | boolean | null | number | RegExp | bigint;
   raw: string;
   regex?: {
@@ -469,19 +412,19 @@ interface ESLintBigIntLiteral extends ESLintLiteralBase {
 }
 type ESLintLiteral = ESLintStringLiteral | ESLintBooleanLiteral | ESLintNullLiteral | ESLintNumberLiteral | ESLintRegExpLiteral | ESLintBigIntLiteral;
 interface ESLintThisExpression extends HasLocation, HasParent {
-  type: 'ThisExpression';
+  type: "ThisExpression";
 }
 interface ESLintArrayExpression extends HasLocation, HasParent {
-  type: 'ArrayExpression';
+  type: "ArrayExpression";
   elements: (ESLintExpression | ESLintSpreadElement)[];
 }
 interface ESLintObjectExpression extends HasLocation, HasParent {
-  type: 'ObjectExpression';
+  type: "ObjectExpression";
   properties: (ESLintProperty | ESLintSpreadElement | ESLintLegacySpreadProperty)[];
 }
 interface ESLintProperty extends HasLocation, HasParent {
-  type: 'Property';
-  kind: 'init' | 'get' | 'set';
+  type: "Property";
+  kind: "init" | "get" | "set";
   method: boolean;
   shorthand: boolean;
   computed: boolean;
@@ -489,7 +432,7 @@ interface ESLintProperty extends HasLocation, HasParent {
   value: ESLintExpression | ESLintPattern;
 }
 interface ESLintFunctionExpression extends HasLocation, HasParent {
-  type: 'FunctionExpression';
+  type: "FunctionExpression";
   async: boolean;
   generator: boolean;
   id: ESLintIdentifier | null;
@@ -497,7 +440,7 @@ interface ESLintFunctionExpression extends HasLocation, HasParent {
   body: ESLintBlockStatement;
 }
 interface ESLintArrowFunctionExpression extends HasLocation, HasParent {
-  type: 'ArrowFunctionExpression';
+  type: "ArrowFunctionExpression";
   async: boolean;
   generator: boolean;
   id: ESLintIdentifier | null;
@@ -505,87 +448,87 @@ interface ESLintArrowFunctionExpression extends HasLocation, HasParent {
   body: ESLintBlockStatement;
 }
 interface ESLintSequenceExpression extends HasLocation, HasParent {
-  type: 'SequenceExpression';
+  type: "SequenceExpression";
   expressions: ESLintExpression[];
 }
 interface ESLintUnaryExpression extends HasLocation, HasParent {
-  type: 'UnaryExpression';
-  operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
+  type: "UnaryExpression";
+  operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
   prefix: boolean;
   argument: ESLintExpression;
 }
 interface ESLintBinaryExpression extends HasLocation, HasParent {
-  type: 'BinaryExpression';
-  operator: '==' | '!=' | '===' | '!==' | '<' | '<=' | '>' | '>=' | '<<' | '>>' | '>>>' | '+' | '-' | '*' | '/' | '%' | '**' | '|' | '^' | '&' | 'in' | 'instanceof';
+  type: "BinaryExpression";
+  operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
   left: ESLintExpression | ESLintPrivateIdentifier;
   right: ESLintExpression;
 }
 interface ESLintAssignmentExpression extends HasLocation, HasParent {
-  type: 'AssignmentExpression';
-  operator: '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '<<=' | '>>=' | '>>>=' | '|=' | '^=' | '&=' | '||=' | '&&=' | '??=';
+  type: "AssignmentExpression";
+  operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
   left: ESLintPattern;
   right: ESLintExpression;
 }
 interface ESLintUpdateExpression extends HasLocation, HasParent {
-  type: 'UpdateExpression';
-  operator: '++' | '--';
+  type: "UpdateExpression";
+  operator: "++" | "--";
   argument: ESLintExpression;
   prefix: boolean;
 }
 interface ESLintLogicalExpression extends HasLocation, HasParent {
-  type: 'LogicalExpression';
-  operator: '||' | '&&' | '??';
+  type: "LogicalExpression";
+  operator: "||" | "&&" | "??";
   left: ESLintExpression;
   right: ESLintExpression;
 }
 interface ESLintConditionalExpression extends HasLocation, HasParent {
-  type: 'ConditionalExpression';
+  type: "ConditionalExpression";
   test: ESLintExpression;
   alternate: ESLintExpression;
   consequent: ESLintExpression;
 }
 interface ESLintCallExpression extends HasLocation, HasParent {
-  type: 'CallExpression';
+  type: "CallExpression";
   optional: boolean;
   callee: ESLintExpression | ESLintSuper;
   arguments: (ESLintExpression | ESLintSpreadElement)[];
 }
 interface ESLintSuper extends HasLocation, HasParent {
-  type: 'Super';
+  type: "Super";
 }
 interface ESLintNewExpression extends HasLocation, HasParent {
-  type: 'NewExpression';
+  type: "NewExpression";
   callee: ESLintExpression;
   arguments: (ESLintExpression | ESLintSpreadElement)[];
 }
 interface ESLintMemberExpression extends HasLocation, HasParent {
-  type: 'MemberExpression';
+  type: "MemberExpression";
   optional: boolean;
   computed: boolean;
   object: ESLintExpression | ESLintSuper;
   property: ESLintExpression | ESLintPrivateIdentifier;
 }
 interface ESLintYieldExpression extends HasLocation, HasParent {
-  type: 'YieldExpression';
+  type: "YieldExpression";
   delegate: boolean;
   argument: ESLintExpression | null;
 }
 interface ESLintAwaitExpression extends HasLocation, HasParent {
-  type: 'AwaitExpression';
+  type: "AwaitExpression";
   argument: ESLintExpression;
 }
 interface ESLintTemplateLiteral extends HasLocation, HasParent {
-  type: 'TemplateLiteral';
+  type: "TemplateLiteral";
   quasis: ESLintTemplateElement[];
   expressions: ESLintExpression[];
 }
 interface ESLintTaggedTemplateExpression extends HasLocation, HasParent {
-  type: 'TaggedTemplateExpression';
+  type: "TaggedTemplateExpression";
   tag: ESLintExpression;
   quasi: ESLintTemplateLiteral;
 }
 interface ESLintTemplateElement extends HasLocation, HasParent {
-  type: 'TemplateElement';
+  type: "TemplateElement";
   tail: boolean;
   value: {
     cooked: string | null;
@@ -593,66 +536,69 @@ interface ESLintTemplateElement extends HasLocation, HasParent {
   };
 }
 interface ESLintClassExpression extends HasLocation, HasParent {
-  type: 'ClassExpression';
+  type: "ClassExpression";
   id: ESLintIdentifier | null;
   superClass: ESLintExpression | null;
   body: ESLintClassBody;
 }
 interface ESLintMetaProperty extends HasLocation, HasParent {
-  type: 'MetaProperty';
+  type: "MetaProperty";
   meta: ESLintIdentifier;
   property: ESLintIdentifier;
 }
 type ESLintPattern = ESLintIdentifier | ESLintObjectPattern | ESLintArrayPattern | ESLintRestElement | ESLintAssignmentPattern | ESLintMemberExpression | ESLintLegacyRestProperty;
 interface ESLintObjectPattern extends HasLocation, HasParent {
-  type: 'ObjectPattern';
+  type: "ObjectPattern";
   properties: (ESLintAssignmentProperty | ESLintRestElement | ESLintLegacyRestProperty)[];
 }
 interface ESLintAssignmentProperty extends ESLintProperty {
   value: ESLintPattern;
-  kind: 'init';
+  kind: "init";
   method: false;
 }
 interface ESLintArrayPattern extends HasLocation, HasParent {
-  type: 'ArrayPattern';
+  type: "ArrayPattern";
   elements: ESLintPattern[];
 }
 interface ESLintRestElement extends HasLocation, HasParent {
-  type: 'RestElement';
+  type: "RestElement";
   argument: ESLintPattern;
 }
 interface ESLintSpreadElement extends HasLocation, HasParent {
-  type: 'SpreadElement';
+  type: "SpreadElement";
   argument: ESLintExpression;
 }
 interface ESLintAssignmentPattern extends HasLocation, HasParent {
-  type: 'AssignmentPattern';
+  type: "AssignmentPattern";
   left: ESLintPattern;
   right: ESLintExpression;
 }
 type ESLintChainElement = ESLintCallExpression | ESLintMemberExpression;
 interface ESLintChainExpression extends HasLocation, HasParent {
-  type: 'ChainExpression';
+  type: "ChainExpression";
   expression: ESLintChainElement;
 }
 /**
- * Legacy for babel-eslint and espree.
- */
+* Legacy for babel-eslint and espree.
+*/
 interface ESLintLegacyRestProperty extends HasLocation, HasParent {
-  type: 'RestProperty' | 'ExperimentalRestProperty';
+  type: "RestProperty" | "ExperimentalRestProperty";
   argument: ESLintPattern;
 }
 /**
- * Legacy for babel-eslint and espree.
- */
+* Legacy for babel-eslint and espree.
+*/
 interface ESLintLegacySpreadProperty extends HasLocation, HasParent {
-  type: 'SpreadProperty' | 'ExperimentalSpreadProperty';
+  type: "SpreadProperty" | "ExperimentalSpreadProperty";
   argument: ESLintExpression;
 }
+// ------------------------------------------------------------------------------
+// Template
+// ------------------------------------------------------------------------------
 /**
- * Constants of namespaces.
- * @see https://infra.spec.whatwg.org/#namespaces
- */
+* Constants of namespaces.
+* @see https://infra.spec.whatwg.org/#namespaces
+*/
 declare const NS: Readonly<{
   HTML: "http://www.w3.org/1999/xhtml";
   MathML: "http://www.w3.org/1998/Math/MathML";
@@ -662,169 +608,170 @@ declare const NS: Readonly<{
   XMLNS: "http://www.w3.org/2000/xmlns/";
 }>;
 /**
- * Type of namespaces.
- */
+* Type of namespaces.
+*/
 type Namespace = typeof NS.HTML | typeof NS.MathML | typeof NS.SVG | typeof NS.XLink | typeof NS.XML | typeof NS.XMLNS;
 /**
- * Type of variable definitions.
- */
+* Type of variable definitions.
+*/
 interface Variable {
   id: ESLintIdentifier;
-  kind: 'v-for' | 'scope';
+  kind: "v-for" | "scope";
   references: Reference[];
 }
 /**
- * Type of variable references.
- */
+* Type of variable references.
+*/
 interface Reference {
   id: ESLintIdentifier;
-  mode: 'rw' | 'r' | 'w';
+  mode: "rw" | "r" | "w";
   variable: Variable | null;
+  // For typescript-eslint
   isValueReference?: boolean;
   isTypeReference?: boolean;
 }
 /**
- * The node of `v-for` directives.
- */
+* The node of `v-for` directives.
+*/
 interface VForExpression extends HasLocation, HasParent {
-  type: 'VForExpression';
+  type: "VForExpression";
   parent: VExpressionContainer;
   left: ESLintPattern[];
   right: ESLintExpression;
 }
 /**
- * The node of `v-on` directives.
- */
+* The node of `v-on` directives.
+*/
 interface VOnExpression extends HasLocation, HasParent {
-  type: 'VOnExpression';
+  type: "VOnExpression";
   parent: VExpressionContainer;
   body: ESLintStatement[];
 }
 /**
- * The node of `slot-scope` directives.
- */
+* The node of `slot-scope` directives.
+*/
 interface VSlotScopeExpression extends HasLocation, HasParent {
-  type: 'VSlotScopeExpression';
+  type: "VSlotScopeExpression";
   parent: VExpressionContainer;
   params: ESLintPattern[];
 }
 /**
- * The node of a filter sequence which is separated by `|`.
- */
+* The node of a filter sequence which is separated by `|`.
+*/
 interface VFilterSequenceExpression extends HasLocation, HasParent {
-  type: 'VFilterSequenceExpression';
+  type: "VFilterSequenceExpression";
   parent: VExpressionContainer;
   expression: ESLintExpression;
   filters: VFilter[];
 }
 /**
- * The node of a filter sequence which is separated by `|`.
- */
+* The node of a filter sequence which is separated by `|`.
+*/
 interface VFilter extends HasLocation, HasParent {
-  type: 'VFilter';
+  type: "VFilter";
   parent: VFilterSequenceExpression;
   callee: ESLintIdentifier;
   arguments: (ESLintExpression | ESLintSpreadElement)[];
 }
 /**
- * The union type of any nodes.
- */
+* The union type of any nodes.
+*/
 type VNode = VAttribute | VDirective | VDirectiveKey | VTemplateRoot | VElement | VEndTag | VExpressionContainer | VIdentifier | VLiteral | VStartTag | VText;
 type VExpression = ESLintExpression | VFilterSequenceExpression | VForExpression | VOnExpression | VSlotScopeExpression;
 /**
- * Text nodes.
- */
+* Text nodes.
+*/
 interface VText extends HasLocation, HasParent {
-  type: 'VText';
+  type: "VText";
   parent: VTemplateRoot | VElement;
   value: string;
 }
 /**
- * The node of JavaScript expression in text.
- * e.g. `{{ name }}`
- */
+* The node of JavaScript expression in text.
+* e.g. `{{ name }}`
+*/
 interface VExpressionContainer extends HasLocation, HasParent {
-  type: 'VExpressionContainer';
+  type: "VExpressionContainer";
   parent: VTemplateRoot | VElement | VDirective | VDirectiveKey;
   expression: VExpression | null;
   references: Reference[];
 }
 /**
- * Attribute name nodes.
- */
+* Attribute name nodes.
+*/
 interface VIdentifier extends HasLocation, HasParent {
-  type: 'VIdentifier';
+  type: "VIdentifier";
   parent: VAttribute | VDirectiveKey;
   name: string;
   rawName: string;
 }
 /**
- * Attribute name nodes.
- */
+* Attribute name nodes.
+*/
 interface VDirectiveKey extends HasLocation, HasParent {
-  type: 'VDirectiveKey';
+  type: "VDirectiveKey";
   parent: VDirective;
   name: VIdentifier;
   argument: VExpressionContainer | VIdentifier | null;
   modifiers: VIdentifier[];
 }
 /**
- * Attribute value nodes.
- */
+* Attribute value nodes.
+*/
 interface VLiteral extends HasLocation, HasParent {
-  type: 'VLiteral';
+  type: "VLiteral";
   parent: VAttribute;
   value: string;
 }
 /**
- * Static attribute nodes.
- */
+* Static attribute nodes.
+*/
 interface VAttribute extends HasLocation, HasParent {
-  type: 'VAttribute';
+  type: "VAttribute";
   parent: VStartTag;
   directive: false;
   key: VIdentifier;
   value: VLiteral | null;
 }
 /**
- * Directive nodes.
- */
+* Directive nodes.
+*/
 interface VDirective extends HasLocation, HasParent {
-  type: 'VAttribute';
+  type: "VAttribute";
   parent: VStartTag;
   directive: true;
   key: VDirectiveKey;
   value: VExpressionContainer | null;
 }
 /**
- * Start tag nodes.
- */
+* Start tag nodes.
+*/
 interface VStartTag extends HasLocation, HasParent {
-  type: 'VStartTag';
+  type: "VStartTag";
   parent: VElement;
   selfClosing: boolean;
   attributes: (VAttribute | VDirective)[];
 }
 /**
- * End tag nodes.
- */
+* End tag nodes.
+*/
 interface VEndTag extends HasLocation, HasParent {
-  type: 'VEndTag';
+  type: "VEndTag";
   parent: VElement;
 }
 /**
- * The property which has concrete information.
- */
+* The property which has concrete information.
+*/
 interface HasConcreteInfo {
   tokens: Token[];
   comments: Token[];
   errors: ParseError[];
 }
 /**
- * Element nodes.
- */
+* Element nodes.
+*/
 interface VElement extends HasLocation, HasParent {
-  type: 'VElement';
+  type: "VElement";
   parent: VTemplateRoot | VElement;
   namespace: Namespace;
   name: string;
@@ -835,42 +782,111 @@ interface VElement extends HasLocation, HasParent {
   variables: Variable[];
 }
 /**
- * Root nodes.
- */
+* Root nodes.
+*/
 interface VTemplateRoot extends HasLocation {
-  type: 'VTemplateRoot';
+  type: "VTemplateRoot";
   parent: TSESTree$1.Node;
   children: (VElement | VText | VExpressionContainer)[];
-  templateInfo?: PrettierType<Omit<FinalProcessTemplateInfo, 'templateMeta' | 'templateRootAST'>>;
+  templateInfo?: PrettierType<Omit<FinalProcessTemplateInfo, "templateMeta" | "templateRootAST">>;
 }
 
 //#endregion
 //#region src/ast/traverse.d.ts
-declare const KEYS: {
-  readonly [type: string]: readonly string[];
-};
+declare const KEYS: VisitorKeys;
 /**
- * Get the keys of the given node to traverse it.
- * @param node The node to get.
- * @returns The keys to traverse.
- */
+* Get the keys of the given node to traverse it.
+* @param node The node to get.
+* @returns The keys to traverse.
+*/
 declare function getFallbackKeys(node: any): string[];
+// ------------------------------------------------------------------------------
+// Exports
+// ------------------------------------------------------------------------------
 interface Visitor {
   visitorKeys?: VisitorKeys;
   enterNode: (node: Node, parent: Node | null) => void;
   leaveNode: (node: Node, parent: Node | null) => void;
 }
 /**
- * Traverse the given AST tree.
- * @param node Root node to traverse.
- * @param visitor Visitor.
- */
+* Traverse the given AST tree.
+* @param node Root node to traverse.
+* @param visitor Visitor.
+*/
 declare function traverseNodes(node: Node, visitor: Visitor): void;
 
+//#endregion
+//#region src/common/parser-object.d.ts
+/**
+* The type of basic ESLint custom parser.
+* e.g. espree
+*/
+interface BasicParserObject<R = ESLintProgram> {
+  parse: (code: string, options: any) => R;
+  parseForESLint: undefined;
+}
+/**
+* The type of ESLint custom parser enhanced for ESLint.
+* e.g. @babel/eslint-parser, @typescript-eslint/parser
+*/
+interface EnhancedParserObject<R = ESLintExtendedProgram> {
+  parseForESLint: (code: string, options: any) => R;
+  parse: undefined;
+}
+/**
+* The type of ESLint (custom) parsers.
+*/
+type ParserObject<R1 = ESLintExtendedProgram, R2 = ESLintProgram> = EnhancedParserObject<R1> | BasicParserObject<R2>;
+
+//#endregion
+//#region src/template/utils/process-vine-template-node.d.ts
+declare function prepareTemplate(templateNode: TSESTree.TaggedTemplateExpression): {
+  templatePositionInfo: VineTemplatePositionInfo;
+  templateRawContent: string;
+};
+
+//#endregion
+//#region src/types.d.ts
+type PrettierType<T> = { [K in keyof T]: T[K] } & {};
+type TsESLintParseForESLint = ReturnType<typeof parseForESLint$1>;
+interface ParseForESLintResult {
+  ast: ESLintProgram;
+  services: TsESLintParseForESLint["services"];
+  scopeManager: TsESLintParseForESLint["scopeManager"];
+  visitorKeys: TsESLintParseForESLint["visitorKeys"];
+}
+type VineESLintParserOptions = ParserOptions & {
+  // ...To be extended
+  parser?: boolean | string | ParserObject | Record<string, string | ParserObject | undefined>;
+  ecmaFeatures?: ParserOptions["ecmaFeatures"] & {
+    [key: string]: any;
+  };
+  sourceType?: "module" | "script";
+};
+interface VineTemplatePositionInfo {
+  templateStartLine: number;
+  templateStartColumn: number;
+  templateStartOffset: number;
+  templateEndOffset: number;
+  templateEndLine: number;
+  templateEndColumn: number;
+}
+interface VineTemplateMeta {
+  tokens: Token[];
+  comments: Token[];
+  errors: ParseError[];
+}
+type FinalProcessTemplateInfo = ReturnType<typeof prepareTemplate> & {
+  templateRootAST: VTemplateRoot;
+  templateMeta: VineTemplateMeta;
+};
+
 //#endregion
 //#region src/index.d.ts
-declare function parse(code: string, parserOptions: VineESLintParserOptions): ESLintProgram;
+declare const meta: ESLint.ObjectMetaProperties;
+declare function parse(code: string, parserOptions: VineESLintParserOptions): ParseForESLintResult["ast"];
 declare function parseForESLint(code: string, parserOptions: VineESLintParserOptions): ParseForESLintResult;
+declare const _default: Linter.Parser;
 
 //#endregion
-export { ESLintArrayExpression, ESLintArrayPattern, ESLintArrowFunctionExpression, ESLintAssignmentExpression, ESLintAssignmentPattern, ESLintAssignmentProperty, ESLintAwaitExpression, ESLintBigIntLiteral, ESLintBinaryExpression, ESLintBlockStatement, ESLintBooleanLiteral, ESLintBreakStatement, ESLintCallExpression, ESLintCatchClause, ESLintChainElement, ESLintChainExpression, ESLintClassBody, ESLintClassDeclaration, ESLintClassExpression, ESLintConditionalExpression, ESLintContinueStatement, ESLintDebuggerStatement, ESLintDeclaration, ESLintDirective, ESLintDoWhileStatement, ESLintEmptyStatement, ESLintExportAllDeclaration, ESLintExportDefaultDeclaration, ESLintExportNamedDeclaration, ESLintExportSpecifier, ESLintExpression, ESLintExpressionStatement, ESLintExtendedProgram, ESLintForInStatement, ESLintForOfStatement, ESLintForStatement, ESLintFunctionDeclaration, ESLintFunctionExpression, ESLintIdentifier, ESLintIfStatement, ESLintImportDeclaration, ESLintImportDefaultSpecifier, ESLintImportExpression, ESLintImportNamespaceSpecifier, ESLintImportSpecifier, ESLintLabeledStatement, ESLintLegacyRestProperty, ESLintLegacySpreadProperty, ESLintLiteral, ESLintLogicalExpression, ESLintMemberExpression, ESLintMetaProperty, ESLintMethodDefinition, ESLintModuleDeclaration, ESLintModuleSpecifier, ESLintNewExpression, ESLintNode, ESLintNullLiteral, ESLintNumberLiteral, ESLintObjectExpression, ESLintObjectPattern, ESLintPattern, ESLintPrivateIdentifier, ESLintProgram, ESLintProperty, ESLintPropertyDefinition, ESLintRegExpLiteral, ESLintRestElement, ESLintReturnStatement, ESLintSequenceExpression, ESLintSpreadElement, ESLintStatement, ESLintStaticBlock, ESLintStringLiteral, ESLintSuper, ESLintSwitchCase, ESLintSwitchStatement, ESLintTaggedTemplateExpression, ESLintTemplateElement, ESLintTemplateLiteral, ESLintThisExpression, ESLintThrowStatement, ESLintTryStatement, ESLintUnaryExpression, ESLintUpdateExpression, ESLintVariableDeclaration, ESLintVariableDeclarator, ESLintWhileStatement, ESLintWithStatement, ESLintYieldExpression, ErrorCode, HasConcreteInfo, HasLocation, HasParent, KEYS, Location, LocationRange, NS, Namespace, Node, Offset, OffsetRange, ParseError, Reference, Token, VAttribute, VDirective, VDirectiveKey, VElement, VEndTag, VExpression, VExpressionContainer, VFilter, VFilterSequenceExpression, VForExpression, VIdentifier, VLiteral, VNode, VOnExpression, VSlotScopeExpression, VStartTag, VTemplateNode, VTemplateRoot, VText, Variable, Visitor, getFallbackKeys, parse, parseForESLint, traverseNodes };
+export { ESLintArrayExpression, ESLintArrayPattern, ESLintArrowFunctionExpression, ESLintAssignmentExpression, ESLintAssignmentPattern, ESLintAssignmentProperty, ESLintAwaitExpression, ESLintBigIntLiteral, ESLintBinaryExpression, ESLintBlockStatement, ESLintBooleanLiteral, ESLintBreakStatement, ESLintCallExpression, ESLintCatchClause, ESLintChainElement, ESLintChainExpression, ESLintClassBody, ESLintClassDeclaration, ESLintClassExpression, ESLintConditionalExpression, ESLintContinueStatement, ESLintDebuggerStatement, ESLintDeclaration, ESLintDirective, ESLintDoWhileStatement, ESLintEmptyStatement, ESLintExportAllDeclaration, ESLintExportDefaultDeclaration, ESLintExportNamedDeclaration, ESLintExportSpecifier, ESLintExpression, ESLintExpressionStatement, ESLintExtendedProgram, ESLintForInStatement, ESLintForOfStatement, ESLintForStatement, ESLintFunctionDeclaration, ESLintFunctionExpression, ESLintIdentifier, ESLintIfStatement, ESLintImportDeclaration, ESLintImportDefaultSpecifier, ESLintImportExpression, ESLintImportNamespaceSpecifier, ESLintImportSpecifier, ESLintLabeledStatement, ESLintLegacyRestProperty, ESLintLegacySpreadProperty, ESLintLiteral, ESLintLogicalExpression, ESLintMemberExpression, ESLintMetaProperty, ESLintMethodDefinition, ESLintModuleDeclaration, ESLintModuleSpecifier, ESLintNewExpression, ESLintNode, ESLintNullLiteral, ESLintNumberLiteral, ESLintObjectExpression, ESLintObjectPattern, ESLintPattern, ESLintPrivateIdentifier, ESLintProgram, ESLintProperty, ESLintPropertyDefinition, ESLintRegExpLiteral, ESLintRestElement, ESLintReturnStatement, ESLintSequenceExpression, ESLintSpreadElement, ESLintStatement, ESLintStaticBlock, ESLintStringLiteral, ESLintSuper, ESLintSwitchCase, ESLintSwitchStatement, ESLintTaggedTemplateExpression, ESLintTemplateElement, ESLintTemplateLiteral, ESLintThisExpression, ESLintThrowStatement, ESLintTryStatement, ESLintUnaryExpression, ESLintUpdateExpression, ESLintVariableDeclaration, ESLintVariableDeclarator, ESLintWhileStatement, ESLintWithStatement, ESLintYieldExpression, ErrorCode, HasConcreteInfo, HasLocation, HasParent, KEYS, Location, LocationRange, NS, Namespace, Node, Offset, OffsetRange, ParseError, Reference, Token, VAttribute, VDirective, VDirectiveKey, VElement, VEndTag, VExpression, VExpressionContainer, VFilter, VFilterSequenceExpression, VForExpression, VIdentifier, VLiteral, VNode, VOnExpression, VSlotScopeExpression, VStartTag, VTemplateNode, VTemplateRoot, VText, Variable, Visitor, _default as default, getFallbackKeys, meta, parse, parseForESLint, traverseNodes };