>(type: T, n: Node | null | undefined, required: Partial): n is P`,
+ // eslint-disable-next-line max-len
+ `export function is
(type: string, n: Node | null | undefined, required: Partial
): n is P`,
+ `export function is(type: string, n: Node | null | undefined, required?: Partial): n is Node`,
+ `export function isBinding(node: Node, parent: Node, grandparent?: Node): boolean`,
+ // eslint-disable-next-line max-len
+ `export function isBlockScoped(node: Node): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration`,
+ `export function isImmutable(node: Node): node is Immutable`,
+ `export function isLet(node: Node): node is VariableDeclaration`,
+ `export function isNode(node: object | null | undefined): node is Node`,
+ `export function isNodesEquivalent>(a: T, b: any): b is T`,
+ `export function isNodesEquivalent(a: any, b: any): boolean`,
+ `export function isPlaceholderType(placeholderType: Node['type'], targetType: Node['type']): boolean`,
+ `export function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean`,
+ `export function isScope(node: Node, parent: Node): node is Scopable`,
+ `export function isSpecifierDefault(specifier: ModuleSpecifier): boolean`,
+ `export function isType(nodetype: string, targetType: T): nodetype is T`,
+ `export function isType(nodetype: string | null | undefined, targetType: string): boolean`,
+ `export function isValidES3Identifier(name: string): boolean`,
+ `export function isValidIdentifier(name: string): boolean`,
+ `export function isVar(node: Node): node is VariableDeclaration`,
+ // the MemberExpression implication is incidental, but it follows from the implementation
+ // eslint-disable-next-line max-len
+ `export function matchesPattern(node: Node | null | undefined, match: string | ReadonlyArray, allowPartial?: boolean): node is MemberExpression`,
+ // eslint-disable-next-line max-len
+ `export function validate(n: Node | null | undefined, key: K, value: T[K]): void;`,
+ `export function validate(n: Node, key: string, value: any): void;`
+);
+
+for (const type in t.DEPRECATED_KEYS) {
+ code += `/**
+ * @deprecated Use \`${t.DEPRECATED_KEYS[type]}\`
+ */
+export type ${type} = ${t.DEPRECATED_KEYS[type]};\n
+`;
+}
+
+for (const type in t.FLIPPED_ALIAS_KEYS) {
+ const types = t.FLIPPED_ALIAS_KEYS[type];
+ code += `export type ${type} = ${types
+ .map(type => `${type}`)
+ .join(" | ")};\n`;
+}
+code += "\n";
+
+code += "export interface Aliases {\n";
+for (const type in t.FLIPPED_ALIAS_KEYS) {
+ code += ` ${type}: ${type};\n`;
+}
+code += "}\n\n";
+
+code += lines.join("\n") + "\n";
+
+//
+
+process.stdout.write(code);
+
+//
+
+function areAllRemainingFieldsNullable(fieldName, fieldNames, fields) {
+ const index = fieldNames.indexOf(fieldName);
+ return fieldNames.slice(index).every(_ => isNullable(fields[_]));
+}
+
+function hasDefault(field) {
+ return field.default != null;
+}
+
+function isNullable(field) {
+ return field.optional || hasDefault(field);
+}
+
+function sortFieldNames(fields, type) {
+ return fields.sort((fieldA, fieldB) => {
+ const indexA = t.BUILDER_KEYS[type].indexOf(fieldA);
+ const indexB = t.BUILDER_KEYS[type].indexOf(fieldB);
+ if (indexA === indexB) return fieldA < fieldB ? -1 : 1;
+ if (indexA === -1) return 1;
+ if (indexB === -1) return -1;
+ return indexA - indexB;
+ });
+}
diff --git a/node_modules/@babel/types/scripts/generators/validators.js b/node_modules/@babel/types/scripts/generators/validators.js
new file mode 100644
index 0000000..acd6da6
--- /dev/null
+++ b/node_modules/@babel/types/scripts/generators/validators.js
@@ -0,0 +1,87 @@
+import definitions from "../../lib/definitions/index.js";
+
+const has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+function joinComparisons(leftArr, right) {
+ return (
+ leftArr.map(JSON.stringify).join(` === ${right} || `) + ` === ${right}`
+ );
+}
+
+function addIsHelper(type, aliasKeys, deprecated) {
+ const targetType = JSON.stringify(type);
+ let aliasSource = "";
+ if (aliasKeys) {
+ aliasSource = joinComparisons(aliasKeys, "nodeType");
+ }
+
+ let placeholderSource = "";
+ const placeholderTypes = [];
+ if (
+ definitions.PLACEHOLDERS.includes(type) &&
+ has(definitions.FLIPPED_ALIAS_KEYS, type)
+ ) {
+ placeholderTypes.push(type);
+ }
+ if (has(definitions.PLACEHOLDERS_FLIPPED_ALIAS, type)) {
+ placeholderTypes.push(...definitions.PLACEHOLDERS_FLIPPED_ALIAS[type]);
+ }
+ if (placeholderTypes.length > 0) {
+ placeholderSource =
+ ' || nodeType === "Placeholder" && (' +
+ joinComparisons(
+ placeholderTypes,
+ "(node as t.Placeholder).expectedNode"
+ ) +
+ ")";
+ }
+
+ const result =
+ definitions.NODE_FIELDS[type] || definitions.FLIPPED_ALIAS_KEYS[type]
+ ? `node is t.${type}`
+ : "boolean";
+
+ return `export function is${type}(node: object | null | undefined, opts?: object | null): ${result} {
+ ${deprecated || ""}
+ if (!node) return false;
+
+ const nodeType = (node as t.Node).type;
+ if (${
+ aliasSource ? aliasSource : `nodeType === ${targetType}`
+ }${placeholderSource}) {
+ if (typeof opts === "undefined") {
+ return true;
+ } else {
+ return shallowEqual(node, opts);
+ }
+ }
+
+ return false;
+ }
+ `;
+}
+
+export default function generateValidators() {
+ let output = `/*
+ * This file is auto-generated! Do not modify it directly.
+ * To re-generate run 'make build'
+ */
+import shallowEqual from "../../utils/shallowEqual";
+import type * as t from "../..";\n\n`;
+
+ Object.keys(definitions.VISITOR_KEYS).forEach(type => {
+ output += addIsHelper(type);
+ });
+
+ Object.keys(definitions.FLIPPED_ALIAS_KEYS).forEach(type => {
+ output += addIsHelper(type, definitions.FLIPPED_ALIAS_KEYS[type]);
+ });
+
+ Object.keys(definitions.DEPRECATED_KEYS).forEach(type => {
+ const newType = definitions.DEPRECATED_KEYS[type];
+ const deprecated = `console.trace("The node type ${type} has been renamed to ${newType}");`;
+ output += addIsHelper(type, null, deprecated);
+ });
+
+ return output;
+}
diff --git a/node_modules/@babel/types/scripts/package.json b/node_modules/@babel/types/scripts/package.json
new file mode 100644
index 0000000..5ffd980
--- /dev/null
+++ b/node_modules/@babel/types/scripts/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/node_modules/@babel/types/scripts/utils/formatBuilderName.js b/node_modules/@babel/types/scripts/utils/formatBuilderName.js
new file mode 100644
index 0000000..f00a3c4
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/formatBuilderName.js
@@ -0,0 +1,8 @@
+const toLowerCase = Function.call.bind("".toLowerCase);
+
+export default function formatBuilderName(type) {
+ // FunctionExpression -> functionExpression
+ // JSXIdentifier -> jsxIdentifier
+ // V8IntrinsicIdentifier -> v8IntrinsicIdentifier
+ return type.replace(/^([A-Z](?=[a-z0-9])|[A-Z]+(?=[A-Z]))/, toLowerCase);
+}
diff --git a/node_modules/@babel/types/scripts/utils/lowerFirst.js b/node_modules/@babel/types/scripts/utils/lowerFirst.js
new file mode 100644
index 0000000..012f252
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/lowerFirst.js
@@ -0,0 +1,3 @@
+export default function lowerFirst(string) {
+ return string[0].toLowerCase() + string.slice(1);
+}
diff --git a/node_modules/@babel/types/scripts/utils/stringifyValidator.js b/node_modules/@babel/types/scripts/utils/stringifyValidator.js
new file mode 100644
index 0000000..4b8d29c
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/stringifyValidator.js
@@ -0,0 +1,66 @@
+export default function stringifyValidator(validator, nodePrefix) {
+ if (validator === undefined) {
+ return "any";
+ }
+
+ if (validator.each) {
+ return `Array<${stringifyValidator(validator.each, nodePrefix)}>`;
+ }
+
+ if (validator.chainOf) {
+ return stringifyValidator(validator.chainOf[1], nodePrefix);
+ }
+
+ if (validator.oneOf) {
+ return validator.oneOf.map(JSON.stringify).join(" | ");
+ }
+
+ if (validator.oneOfNodeTypes) {
+ return validator.oneOfNodeTypes.map(_ => nodePrefix + _).join(" | ");
+ }
+
+ if (validator.oneOfNodeOrValueTypes) {
+ return validator.oneOfNodeOrValueTypes
+ .map(_ => {
+ return isValueType(_) ? _ : nodePrefix + _;
+ })
+ .join(" | ");
+ }
+
+ if (validator.type) {
+ return validator.type;
+ }
+
+ if (validator.shapeOf) {
+ return (
+ "{ " +
+ Object.keys(validator.shapeOf)
+ .map(shapeKey => {
+ const propertyDefinition = validator.shapeOf[shapeKey];
+ if (propertyDefinition.validate) {
+ const isOptional =
+ propertyDefinition.optional || propertyDefinition.default != null;
+ return (
+ shapeKey +
+ (isOptional ? "?: " : ": ") +
+ stringifyValidator(propertyDefinition.validate)
+ );
+ }
+ return null;
+ })
+ .filter(Boolean)
+ .join(", ") +
+ " }"
+ );
+ }
+
+ return ["any"];
+}
+
+/**
+ * Heuristic to decide whether or not the given type is a value type (eg. "null")
+ * or a Node type (eg. "Expression").
+ */
+function isValueType(type) {
+ return type.charAt(0).toLowerCase() === type.charAt(0);
+}
diff --git a/node_modules/@babel/types/scripts/utils/toFunctionName.js b/node_modules/@babel/types/scripts/utils/toFunctionName.js
new file mode 100644
index 0000000..2b64578
--- /dev/null
+++ b/node_modules/@babel/types/scripts/utils/toFunctionName.js
@@ -0,0 +1,4 @@
+export default function toFunctionName(typeName) {
+ const _ = typeName.replace(/^TS/, "ts").replace(/^JSX/, "jsx");
+ return _.slice(0, 1).toLowerCase() + _.slice(1);
+}
diff --git a/node_modules/@types/estree/LICENSE b/node_modules/@types/estree/LICENSE
new file mode 100644
index 0000000..9e841e7
--- /dev/null
+++ b/node_modules/@types/estree/LICENSE
@@ -0,0 +1,21 @@
+ MIT License
+
+ Copyright (c) Microsoft Corporation.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE
diff --git a/node_modules/@types/estree/README.md b/node_modules/@types/estree/README.md
new file mode 100644
index 0000000..95fcf63
--- /dev/null
+++ b/node_modules/@types/estree/README.md
@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/estree`
+
+# Summary
+This package contains type definitions for ESTree AST specification (https://github.com/estree/estree).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.
+
+### Additional Details
+ * Last updated: Wed, 02 Jun 2021 05:31:29 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [RReverser](https://github.com/RReverser).
diff --git a/node_modules/@types/estree/flow.d.ts b/node_modules/@types/estree/flow.d.ts
new file mode 100644
index 0000000..605765e
--- /dev/null
+++ b/node_modules/@types/estree/flow.d.ts
@@ -0,0 +1,174 @@
+// Type definitions for ESTree AST extensions for Facebook Flow
+// Project: https://github.com/estree/estree
+// Definitions by: RReverser
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+
+declare namespace ESTree {
+ interface FlowTypeAnnotation extends Node {}
+
+ interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
+
+ interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
+
+ interface FlowDeclaration extends Declaration {}
+
+ interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+ interface ArrayTypeAnnotation extends FlowTypeAnnotation {
+ elementType: FlowTypeAnnotation;
+ }
+
+ interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+ interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+ interface ClassImplements extends Node {
+ id: Identifier;
+ typeParameters?: TypeParameterInstantiation | null;
+ }
+
+ 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;
+ }
+
+ interface DeclareFunction extends FlowDeclaration {
+ id: Identifier;
+ }
+
+ interface DeclareModule extends FlowDeclaration {
+ id: Literal | Identifier;
+ body: BlockStatement;
+ }
+
+ interface DeclareVariable extends FlowDeclaration {
+ id: Identifier;
+ }
+
+ interface FunctionTypeAnnotation extends FlowTypeAnnotation {
+ params: Array;
+ returnType: FlowTypeAnnotation;
+ rest?: FunctionTypeParam | null;
+ typeParameters?: TypeParameterDeclaration | null;
+ }
+
+ interface FunctionTypeParam {
+ name: Identifier;
+ typeAnnotation: FlowTypeAnnotation;
+ optional: boolean;
+ }
+
+ interface GenericTypeAnnotation extends FlowTypeAnnotation {
+ 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;
+ body: ObjectTypeAnnotation;
+ }
+
+ interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
+ types: Array;
+ }
+
+ interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+ interface NullableTypeAnnotation extends FlowTypeAnnotation {
+ typeAnnotation: TypeAnnotation;
+ }
+
+ interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+ interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+ interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+ interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+ interface TupleTypeAnnotation extends FlowTypeAnnotation {
+ types: Array;
+ }
+
+ interface TypeofTypeAnnotation extends FlowTypeAnnotation {
+ argument: FlowTypeAnnotation;
+ }
+
+ interface TypeAlias extends FlowDeclaration {
+ id: Identifier;
+ typeParameters?: TypeParameterDeclaration | null;
+ right: FlowTypeAnnotation;
+ }
+
+ interface TypeAnnotation extends Node {
+ typeAnnotation: FlowTypeAnnotation;
+ }
+
+ interface TypeCastExpression extends Expression {
+ expression: Expression;
+ typeAnnotation: TypeAnnotation;
+ }
+
+ interface TypeParameterDeclaration extends Node {
+ params: Array;
+ }
+
+ interface TypeParameterInstantiation extends Node {
+ params: Array;
+ }
+
+ interface ObjectTypeAnnotation extends FlowTypeAnnotation {
+ properties: Array;
+ indexers: Array;
+ callProperties: Array;
+ }
+
+ interface ObjectTypeCallProperty extends Node {
+ value: FunctionTypeAnnotation;
+ 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 QualifiedTypeIdentifier extends Node {
+ qualification: Identifier | QualifiedTypeIdentifier;
+ id: Identifier;
+ }
+
+ interface UnionTypeAnnotation extends FlowTypeAnnotation {
+ types: Array;
+ }
+
+ interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
+}
diff --git a/node_modules/@types/estree/index.d.ts b/node_modules/@types/estree/index.d.ts
new file mode 100644
index 0000000..f652c30
--- /dev/null
+++ b/node_modules/@types/estree/index.d.ts
@@ -0,0 +1,590 @@
+// Type definitions for ESTree AST specification
+// Project: https://github.com/estree/estree
+// Definitions by: RReverser
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+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;
+ range?: [number, number];
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+ leadingComments?: Array;
+ trailingComments?: Array;
+}
+
+export type Node =
+ Identifier | Literal | Program | Function | SwitchCase | CatchClause |
+ VariableDeclarator | Statement | Expression | PrivateIdentifier | Property | PropertyDefinition |
+ AssignmentProperty | Super | TemplateElement | SpreadElement | Pattern |
+ ClassBody | Class | MethodDefinition | ModuleDeclaration | ModuleSpecifier;
+
+export interface Comment extends BaseNodeWithoutComments {
+ type: "Line" | "Block";
+ value: string;
+}
+
+interface SourceLocation {
+ source?: string | null;
+ start: Position;
+ end: Position;
+}
+
+export interface Position {
+ /** >= 1 */
+ line: number;
+ /** >= 0 */
+ column: number;
+}
+
+export interface Program extends BaseNode {
+ type: "Program";
+ sourceType: "script" | "module";
+ body: Array;
+ comments?: Array;
+}
+
+export interface Directive extends BaseNode {
+ type: "ExpressionStatement";
+ expression: Literal;
+ directive: string;
+}
+
+interface BaseFunction extends BaseNode {
+ params: Array;
+ generator?: boolean;
+ async?: boolean;
+ // 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 Statement =
+ ExpressionStatement | BlockStatement | EmptyStatement |
+ DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement |
+ BreakStatement | ContinueStatement | IfStatement | SwitchStatement |
+ ThrowStatement | TryStatement | WhileStatement | DoWhileStatement |
+ ForStatement | ForInStatement | ForOfStatement | Declaration;
+
+interface BaseStatement extends BaseNode { }
+
+export interface EmptyStatement extends BaseStatement {
+ type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+ type: "BlockStatement";
+ body: Array;
+ innerComments?: Array;
+}
+
+export interface ExpressionStatement extends BaseStatement {
+ type: "ExpressionStatement";
+ expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+ type: "IfStatement";
+ test: Expression;
+ consequent: Statement;
+ alternate?: Statement | null;
+}
+
+export interface LabeledStatement extends BaseStatement {
+ type: "LabeledStatement";
+ label: Identifier;
+ body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+ type: "BreakStatement";
+ label?: Identifier | null;
+}
+
+export interface ContinueStatement extends BaseStatement {
+ type: "ContinueStatement";
+ label?: Identifier | null;
+}
+
+export interface WithStatement extends BaseStatement {
+ type: "WithStatement";
+ object: Expression;
+ body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+ type: "SwitchStatement";
+ discriminant: Expression;
+ cases: Array;
+}
+
+export interface ReturnStatement extends BaseStatement {
+ type: "ReturnStatement";
+ argument?: Expression | null;
+}
+
+export interface ThrowStatement extends BaseStatement {
+ type: "ThrowStatement";
+ argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+ type: "TryStatement";
+ block: BlockStatement;
+ handler?: CatchClause | null;
+ finalizer?: BlockStatement | null;
+}
+
+export interface WhileStatement extends BaseStatement {
+ type: "WhileStatement";
+ test: Expression;
+ body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+ type: "DoWhileStatement";
+ body: Statement;
+ test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+ type: "ForStatement";
+ init?: VariableDeclaration | Expression | null;
+ test?: Expression | null;
+ update?: Expression | null;
+ body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+ left: VariableDeclaration | Pattern;
+ right: Expression;
+ body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+ type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+ type: "DebuggerStatement";
+}
+
+export type Declaration =
+ FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+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;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+ type: "VariableDeclaration";
+ declarations: Array;
+ kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+ type: "VariableDeclarator";
+ id: Pattern;
+ init?: Expression | null;
+}
+
+type Expression =
+ ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression |
+ ArrowFunctionExpression | YieldExpression | Literal | UnaryExpression |
+ UpdateExpression | BinaryExpression | AssignmentExpression |
+ LogicalExpression | MemberExpression | ConditionalExpression |
+ CallExpression | NewExpression | SequenceExpression | TemplateLiteral |
+ TaggedTemplateExpression | ClassExpression | MetaProperty | Identifier |
+ AwaitExpression | ImportExpression | ChainExpression;
+
+export interface BaseExpression extends BaseNode { }
+
+type ChainElement = SimpleCallExpression | MemberExpression;
+
+export interface ChainExpression extends BaseExpression {
+ type: "ChainExpression";
+ expression: ChainElement;
+}
+
+export interface ThisExpression extends BaseExpression {
+ type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+ type: "ArrayExpression";
+ elements: Array;
+}
+
+export interface ObjectExpression extends BaseExpression {
+ type: "ObjectExpression";
+ properties: Array;
+}
+
+export interface PrivateIdentifier extends BaseNode {
+ type: "PrivateIdentifier";
+ name: string;
+}
+
+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;
+}
+
+export interface PropertyDefinition extends BaseNode {
+ type: "PropertyDefinition";
+ key: Expression | PrivateIdentifier;
+ value?: Expression | null;
+ computed: boolean;
+ static: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+ id?: Identifier | null;
+ type: "FunctionExpression";
+ body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+ type: "SequenceExpression";
+ expressions: Array;
+}
+
+export interface UnaryExpression extends BaseExpression {
+ type: "UnaryExpression";
+ operator: UnaryOperator;
+ prefix: true;
+ argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+ type: "BinaryExpression";
+ operator: BinaryOperator;
+ left: Expression;
+ right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+ type: "AssignmentExpression";
+ operator: AssignmentOperator;
+ left: Pattern | MemberExpression;
+ right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+ type: "UpdateExpression";
+ operator: UpdateOperator;
+ argument: Expression;
+ prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+ type: "LogicalExpression";
+ operator: LogicalOperator;
+ left: Expression;
+ right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+ type: "ConditionalExpression";
+ test: Expression;
+ alternate: Expression;
+ consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+ callee: Expression | Super;
+ arguments: Array;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+ type: "CallExpression";
+ optional: boolean;
+}
+
+export interface NewExpression extends BaseCallExpression {
+ type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+ type: "MemberExpression";
+ object: Expression | Super;
+ property: Expression | PrivateIdentifier;
+ computed: boolean;
+ optional: boolean;
+}
+
+export type Pattern =
+ Identifier | ObjectPattern | ArrayPattern | RestElement |
+ AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode { }
+
+export interface SwitchCase extends BaseNode {
+ type: "SwitchCase";
+ test?: Expression | null;
+ consequent: Array;
+}
+
+export interface CatchClause extends BaseNode {
+ type: "CatchClause";
+ param: Pattern | null;
+ body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+ type: "Identifier";
+ name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+ type: "Literal";
+ value: string | boolean | number | null;
+ raw?: string;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+ type: "Literal";
+ value?: RegExp | null;
+ regex: {
+ pattern: string;
+ flags: string;
+ };
+ raw?: string;
+}
+
+export interface BigIntLiteral extends BaseNode, BaseExpression {
+ type: "Literal";
+ value?: bigint | null;
+ bigint: string;
+ raw?: string;
+}
+
+export type UnaryOperator =
+ "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+ "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" |
+ ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" |
+ "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type AssignmentOperator =
+ "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" |
+ "|=" | "^=" | "&=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+ type: "ForOfStatement";
+ await: boolean;
+}
+
+export interface Super extends BaseNode {
+ type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+ type: "SpreadElement";
+ argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+ type: "ArrowFunctionExpression";
+ expression: boolean;
+ body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+ type: "YieldExpression";
+ argument?: Expression | null;
+ delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+ type: "TemplateLiteral";
+ quasis: Array;
+ expressions: Array;
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+ 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;
+ raw: string;
+ };
+}
+
+export interface AssignmentProperty extends Property {
+ value: Pattern;
+ kind: "init";
+ method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+ type: "ObjectPattern";
+ properties: Array;
+}
+
+export interface ArrayPattern extends BasePattern {
+ type: "ArrayPattern";
+ elements: Array;
+}
+
+export interface RestElement extends BasePattern {
+ type: "RestElement";
+ argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+ type: "AssignmentPattern";
+ left: Pattern;
+ right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+ superClass?: Expression | null;
+ body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+ type: "ClassBody";
+ body: Array;
+}
+
+export interface MethodDefinition extends BaseNode {
+ 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;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+ type: "ClassExpression";
+ id?: Identifier | null;
+}
+
+export interface MetaProperty extends BaseExpression {
+ type: "MetaProperty";
+ meta: Identifier;
+ property: Identifier;
+}
+
+export type ModuleDeclaration =
+ ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration |
+ ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode { }
+
+export type ModuleSpecifier =
+ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier |
+ ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+ local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+ type: "ImportDeclaration";
+ specifiers: Array;
+ source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+ type: "ImportSpecifier";
+ imported: Identifier;
+}
+
+export interface ImportExpression extends BaseExpression {
+ type: "ImportExpression";
+ source: Expression;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+ type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+ type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+ type: "ExportNamedDeclaration";
+ declaration?: Declaration | null;
+ specifiers: Array;
+ source?: Literal | null;
+}
+
+export interface ExportSpecifier extends BaseModuleSpecifier {
+ type: "ExportSpecifier";
+ exported: Identifier;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+ type: "ExportDefaultDeclaration";
+ declaration: Declaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+ type: "ExportAllDeclaration";
+ source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+ type: "AwaitExpression";
+ argument: Expression;
+}
diff --git a/node_modules/@types/estree/package.json b/node_modules/@types/estree/package.json
new file mode 100644
index 0000000..59eb482
--- /dev/null
+++ b/node_modules/@types/estree/package.json
@@ -0,0 +1,25 @@
+{
+ "name": "@types/estree",
+ "version": "0.0.48",
+ "description": "TypeScript definitions for ESTree AST specification",
+ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
+ "license": "MIT",
+ "contributors": [
+ {
+ "name": "RReverser",
+ "url": "https://github.com/RReverser",
+ "githubUsername": "RReverser"
+ }
+ ],
+ "main": "",
+ "types": "index.d.ts",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+ "directory": "types/estree"
+ },
+ "scripts": {},
+ "dependencies": {},
+ "typesPublisherContentHash": "474f09de11b819537a7e8519b411dcbd4a51eb978402550a42a6cca2fe689bde",
+ "typeScriptVersion": "3.6"
+}
\ No newline at end of file
diff --git a/node_modules/@vitejs/plugin-vue/CHANGELOG.md b/node_modules/@vitejs/plugin-vue/CHANGELOG.md
new file mode 100644
index 0000000..58e05a6
--- /dev/null
+++ b/node_modules/@vitejs/plugin-vue/CHANGELOG.md
@@ -0,0 +1,210 @@
+# [1.6.0](https://github.com/vitejs/vite/compare/plugin-vue@1.5.0...plugin-vue@1.6.0) (2021-08-24)
+
+
+### Features
+
+* **plugin-vue:** latest ref transform support ([533b002](https://github.com/vitejs/vite/commit/533b0029adc912257251b5021879ab1d676a16ab))
+* **plugin-vue:** warn compiler-sfc version mismatch ([e7263b9](https://github.com/vitejs/vite/commit/e7263b98f2e174198b322d26c6a7207d706a6639))
+
+
+
+# [1.5.0](https://github.com/vitejs/vite/compare/plugin-vue@1.4.0...plugin-vue@1.5.0) (2021-08-24)
+
+
+
+# [1.4.0](https://github.com/vitejs/vite/compare/plugin-vue@1.3.0...plugin-vue@1.4.0) (2021-08-07)
+
+### Features
+
+* Custom Elements mode behavior changed: now only inlines the CSS and no longer exports the custom element constructor (exports the component as in normal mode). Users now need to explicitly call `defineCustomElement` on the component. This allows the custom element to be defined using an async version of the source component.
+
+### Bug Fixes
+
+* revert update dependency slash to v4 ([#4118](https://github.com/vitejs/vite/issues/4118)) ([#4519](https://github.com/vitejs/vite/issues/4519)) ([9b4fe1f](https://github.com/vitejs/vite/commit/9b4fe1fa68c522878d1bdef87d7aa02ae08e986f))
+
+
+
+# [1.3.0](https://github.com/vitejs/vite/compare/plugin-vue@1.2.5...plugin-vue@1.3.0) (2021-07-27)
+
+
+### Bug Fixes
+
+* reuse the old preprocessor after changing the lang attr ([#4224](https://github.com/vitejs/vite/issues/4224)) ([7a3c6e6](https://github.com/vitejs/vite/commit/7a3c6e616385cbc069620ae583d6739a972c0ead))
+
+
+### Features
+
+* **plugin-vue:** support importing vue files as custom elements ([3a3af6e](https://github.com/vitejs/vite/commit/3a3af6eeafbc9fc686fc909ec6a61c61283316fc))
+
+
+
+## [1.2.5](https://github.com/vitejs/vite/compare/plugin-vue@1.2.4...plugin-vue@1.2.5) (2021-07-12)
+
+
+
+## [1.2.4](https://github.com/vitejs/vite/compare/plugin-vue@1.2.3...plugin-vue@1.2.4) (2021-06-27)
+
+
+### Bug Fixes
+
+* **ssr:** normalize manifest filenames ([#3706](https://github.com/vitejs/vite/issues/3706)) ([aa8ca3f](https://github.com/vitejs/vite/commit/aa8ca3f35218c9fb48f87d3f6f4681d379ee45ca)), closes [#3303](https://github.com/vitejs/vite/issues/3303)
+
+
+
+## [1.2.3](https://github.com/vitejs/vite/compare/plugin-vue@1.2.2...plugin-vue@1.2.3) (2021-06-01)
+
+
+### Bug Fixes
+
+* **plugin-vue:** rewrite default after ts compiled ([#3591](https://github.com/vitejs/vite/issues/3591)) ([ea5bafa](https://github.com/vitejs/vite/commit/ea5bafaefbafd858389f88e537cb3473b4669802))
+
+
+
+## [1.2.2](https://github.com/vitejs/vite/compare/plugin-vue@1.2.1...plugin-vue@1.2.2) (2021-04-24)
+
+
+### Bug Fixes
+
+* **plugin-vue:** add newline character before class components, fix [#2787](https://github.com/vitejs/vite/issues/2787) ([#2933](https://github.com/vitejs/vite/issues/2933)) ([8fe828e](https://github.com/vitejs/vite/commit/8fe828e9be9e9de67463af6f5dc35ebdbfdbda28))
+* **plugin-vue:** avoid duplicate import, fix [#2640](https://github.com/vitejs/vite/issues/2640) ([#2897](https://github.com/vitejs/vite/issues/2897)) ([011438d](https://github.com/vitejs/vite/commit/011438d16dc42408d5229b842d67dba28868566b))
+* **plugin-vue:** respect `hmr: false` server config, fix [#2790](https://github.com/vitejs/vite/issues/2790) ([#2797](https://github.com/vitejs/vite/issues/2797)) ([27e0c3f](https://github.com/vitejs/vite/commit/27e0c3fffd32a0ff90d06a909a5d5cc7d73f44b0))
+
+
+
+## [1.2.1](https://github.com/vitejs/vite/compare/plugin-vue@1.2.0...plugin-vue@1.2.1) (2021-03-31)
+
+
+### Bug Fixes
+
+* **plugin-vue:** allow to overwrite feature flags ([#2675](https://github.com/vitejs/vite/issues/2675)) ([a4acc16](https://github.com/vitejs/vite/commit/a4acc161e10fb6d122f808ad6211feef389d41a9))
+
+
+
+# [1.2.0](https://github.com/vitejs/vite/compare/plugin-vue@1.1.5...plugin-vue@1.2.0) (2021-03-26)
+
+
+### Features
+
+* **plugin-vue:** enable :slotted usage detection ([c40c49f](https://github.com/vitejs/vite/commit/c40c49f6fa806406364f4982fe45a69db15c204f))
+
+
+
+## [1.1.5](https://github.com/vitejs/vite/compare/plugin-vue@1.1.4...plugin-vue@1.1.5) (2021-02-26)
+
+
+### Bug Fixes
+
+* **plugin-vue:** fix hmr when emptying sfc file ([#2142](https://github.com/vitejs/vite/issues/2142)) ([493b942](https://github.com/vitejs/vite/commit/493b94259d6a499e03684d6001fea1a96d56810c)), closes [#2128](https://github.com/vitejs/vite/issues/2128)
+* **plugin-vue:** handle default rewrite edge case for commented class ([2900a9a](https://github.com/vitejs/vite/commit/2900a9a6a501628588b31f7453e2fe5a71fe45ce)), closes [#2277](https://github.com/vitejs/vite/issues/2277)
+* **plugin-vue:** import vue file as raw correctly ([#1923](https://github.com/vitejs/vite/issues/1923)) ([5b56d70](https://github.com/vitejs/vite/commit/5b56d70c1d173d4c5e3d9532f9c3bc6f8bfc020c))
+
+
+
+## [1.1.4](https://github.com/vitejs/vite/compare/plugin-vue@1.1.3...plugin-vue@1.1.4) (2021-01-30)
+
+
+### Bug Fixes
+
+* **plugin-vue:** handle block src pointing to dependency files ([bb7da3f](https://github.com/vitejs/vite/commit/bb7da3f0f07da6558f0e81bd82ede4cfe1785a56)), closes [#1812](https://github.com/vitejs/vite/issues/1812)
+
+
+
+## [1.1.3](https://github.com/vitejs/vite/compare/plugin-vue@1.1.2...plugin-vue@1.1.3) (2021-01-29)
+
+
+### Bug Fixes
+
+* **plugin-vue:** special handling for class default export in sfc ([d3397e6](https://github.com/vitejs/vite/commit/d3397e61cd9d0761606506dcc176a1cbc845d8b5)), closes [#1476](https://github.com/vitejs/vite/issues/1476)
+
+
+
+## [1.1.2](https://github.com/vitejs/vite/compare/plugin-vue@1.1.1...plugin-vue@1.1.2) (2021-01-24)
+
+
+
+## [1.1.1](https://github.com/vitejs/vite/compare/plugin-vue@1.1.0...plugin-vue@1.1.1) (2021-01-23)
+
+
+### Bug Fixes
+
+* avoid eager hmr api access ([fa37456](https://github.com/vitejs/vite/commit/fa37456584a09b52b39a61760a6d130e261886ff))
+
+
+### Features
+
+* support `base` option during dev, deprecate `build.base` ([#1556](https://github.com/vitejs/vite/issues/1556)) ([809d4bd](https://github.com/vitejs/vite/commit/809d4bd3bf62d3bc6b35f182178922d2ab2175f1))
+
+
+
+# [1.1.0](https://github.com/vitejs/vite/compare/plugin-vue@1.0.6...plugin-vue@1.1.0) (2021-01-19)
+
+
+### Features
+
+* ssr manifest for preload inference ([107e79e](https://github.com/vitejs/vite/commit/107e79e7b7d422f0d1dbe8b7b435636df7c6281c))
+* **plugin-vue:** support for vite core new ssr impl ([a93ab23](https://github.com/vitejs/vite/commit/a93ab23491ee9fee78345ddc20567e1b0ceec2a7))
+
+
+
+## [1.0.6](https://github.com/vitejs/vite/compare/plugin-vue@1.0.5...plugin-vue@1.0.6) (2021-01-15)
+
+
+### Bug Fixes
+
+* **plugin-vue:** sfc src import respect alias ([#1544](https://github.com/vitejs/vite/issues/1544)) ([d8754de](https://github.com/vitejs/vite/commit/d8754deeb16ef0d86b17dfa2a3394d0919bcd72e)), closes [#1542](https://github.com/vitejs/vite/issues/1542)
+
+
+
+## [1.0.5](https://github.com/vitejs/vite/compare/plugin-vue@1.0.4...plugin-vue@1.0.5) (2021-01-09)
+
+
+### Bug Fixes
+
+* **plugin-vue:** default pug doctype ([756a0f2](https://github.com/vitejs/vite/commit/756a0f26911e5bff9c1ea3f780a0a1eccd1f1cfd)), closes [#1383](https://github.com/vitejs/vite/issues/1383)
+* **plugin-vue:** pass on script and style options to compiler-sfc ([0503d42](https://github.com/vitejs/vite/commit/0503d42aaddbc4b8428c94ede07cf7b84f800cef)), closes [#1450](https://github.com/vitejs/vite/issues/1450)
+
+
+
+## [1.0.4](https://github.com/vitejs/vite/compare/plugin-vue@1.0.3...plugin-vue@1.0.4) (2021-01-04)
+
+
+### Bug Fixes
+
+* **plugin-vue:** mark SFC compiler options as `Partial` ([#1316](https://github.com/vitejs/vite/issues/1316)) ([331484c](https://github.com/vitejs/vite/commit/331484c2600e96543aa8007b4940d023cb5cc19f))
+
+
+### Features
+
+* **plugin-vue:** export vue query parse API ([#1303](https://github.com/vitejs/vite/issues/1303)) ([56bcb0c](https://github.com/vitejs/vite/commit/56bcb0c475a5dff31527cad6dcd7c61fde424f5e))
+
+
+
+## [1.0.3](https://github.com/vitejs/vite/compare/plugin-vue@1.0.2...plugin-vue@1.0.3) (2021-01-02)
+
+
+### Bug Fixes
+
+* **plugin-vue:** custom block prev handling ([8dbc2b4](https://github.com/vitejs/vite/commit/8dbc2b47dd8fea4a953fb05057edb47122e2dcb7))
+
+
+### Code Refactoring
+
+* **hmr:** pass context object to `handleHotUpdate` plugin hook ([b314771](https://github.com/vitejs/vite/commit/b3147710e96a8f88ab81b2e45dbf7e7174ad976c))
+
+
+### BREAKING CHANGES
+
+* **hmr:** `handleHotUpdate` plugin hook now receives a single
+`HmrContext` argument instead of multiple args.
+
+
+
+## [1.0.2](https://github.com/vitejs/vite/compare/plugin-vue@1.0.2...plugin-vue@1.0.2) (2021-01-02)
+
+
+### Bug Fixes
+
+* **plugin-vue:** avoid throwing on never requested file ([48a24c1](https://github.com/vitejs/vite/commit/48a24c1fa1f64e89ca853635580911859ef5881b))
+* **plugin-vue:** custom block prev handling ([8dbc2b4](https://github.com/vitejs/vite/commit/8dbc2b47dd8fea4a953fb05057edb47122e2dcb7))
+* avoid self referencing type in plugin-vue ([9cccdaa](https://github.com/vitejs/vite/commit/9cccdaa0935ca664c8a709a89ebd1f2216565546))
+* **plugin-vue:** ensure id on descriptor ([91217f6](https://github.com/vitejs/vite/commit/91217f6d968485303e71128bb79ad4400b9b4412))
diff --git a/node_modules/@vitejs/plugin-vue/LICENSE b/node_modules/@vitejs/plugin-vue/LICENSE
new file mode 100644
index 0000000..b3d494d
--- /dev/null
+++ b/node_modules/@vitejs/plugin-vue/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present, Yuxi (Evan) You and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@vitejs/plugin-vue/README.md b/node_modules/@vitejs/plugin-vue/README.md
new file mode 100644
index 0000000..ebc660c
--- /dev/null
+++ b/node_modules/@vitejs/plugin-vue/README.md
@@ -0,0 +1,110 @@
+# @vitejs/plugin-vue [](https://npmjs.com/package/@vitejs/plugin-vue)
+
+Note: requires `@vue/compiler-sfc` as peer dependency. This is largely a port of `rollup-plugin-vue` with some vite-specific tweaks.
+
+```js
+// vite.config.js
+import vue from '@vitejs/plugin-vue'
+
+export default {
+ plugins: [vue()]
+}
+```
+
+## Options
+
+```ts
+export interface Options {
+ include?: string | RegExp | (string | RegExp)[]
+ exclude?: string | RegExp | (string | RegExp)[]
+
+ ssr?: boolean
+ isProduction?: boolean
+
+ /**
+ * Transform Vue SFCs into custom elements (requires Vue >= 3.2.0)
+ * - `true` -> all `*.vue` imports are converted into custom elements
+ * - `string | RegExp` -> matched files are converted into custom elements
+ *
+ * @default /\.ce\.vue$/
+ */
+ customElement?: boolean | string | RegExp | (string | RegExp)[]
+
+ // options to pass on to @vue/compiler-sfc
+ script?: Partial
+ template?: Partial
+ style?: Partial
+}
+```
+
+## Example for passing options to `@vue/compiler-dom`:
+
+```ts
+import vue from '@vitejs/plugin-vue'
+
+export default {
+ plugins: [
+ vue({
+ template: {
+ compilerOptions: {
+ // ...
+ }
+ }
+ })
+ ]
+}
+```
+
+## Example for transforming custom blocks
+
+```ts
+import vue from '@vitejs/plugin-vue'
+
+const vueI18nPlugin = {
+ name: 'vue-i18n',
+ transform(code, id) {
+ if (!/vue&type=i18n/.test(id)) {
+ return
+ }
+ if (/\.ya?ml$/.test(id)) {
+ code = JSON.stringify(require('js-yaml').safeLoad(code.trim()))
+ }
+ return `export default Comp => {
+ Comp.i18n = ${code}
+ }`
+ }
+}
+
+export default {
+ plugins: [vue(), vueI18nPlugin]
+}
+```
+
+## Using Vue SFCs as Custom Elements
+
+> Requires `vue@^3.2.0` & `@vitejs/plugin-vue@^1.4.0`
+
+Vue 3.2 introduces the `defineCustomElement` method, which works with SFCs. By default, `