>(type: T, n: Node | null | undefined, required: Partial): n is P
+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
+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
+export function matchesPattern(node: Node | null | undefined, match: string | ReadonlyArray, allowPartial?: boolean): node is MemberExpression
+export function validate(n: Node | null | undefined, key: K, value: T[K]): void;
+export function validate(n: Node, key: string, value: any): void;
diff --git "a/\346\235\216\344\275\263\351\276\204/vue\344\275\234\344\270\232/20220421\345\224\257\345\223\201\344\274\232\350\267\257\347\224\261\357\274\210\347\202\271\345\207\273\350\257\246\346\203\205\351\241\265)/vuepro/node_modules/@babel/types/lib/index.d.ts" "b/\346\235\216\344\275\263\351\276\204/vue\344\275\234\344\270\232/20220421\345\224\257\345\223\201\344\274\232\350\267\257\347\224\261\357\274\210\347\202\271\345\207\273\350\257\246\346\203\205\351\241\265)/vuepro/node_modules/@babel/types/lib/index.d.ts"
new file mode 100644
index 0000000000000000000000000000000000000000..791ddba9545ed476828dbd70eb28d1336b651abf
--- /dev/null
+++ "b/\346\235\216\344\275\263\351\276\204/vue\344\275\234\344\270\232/20220421\345\224\257\345\223\201\344\274\232\350\267\257\347\224\261\357\274\210\347\202\271\345\207\273\350\257\246\346\203\205\351\241\265)/vuepro/node_modules/@babel/types/lib/index.d.ts"
@@ -0,0 +1,2927 @@
+interface BaseComment {
+ value: string;
+ start: number;
+ end: number;
+ loc: SourceLocation;
+ type: "CommentBlock" | "CommentLine";
+}
+interface CommentBlock extends BaseComment {
+ type: "CommentBlock";
+}
+interface CommentLine extends BaseComment {
+ type: "CommentLine";
+}
+declare type Comment = CommentBlock | CommentLine;
+interface SourceLocation {
+ start: {
+ line: number;
+ column: number;
+ };
+ end: {
+ line: number;
+ column: number;
+ };
+}
+interface BaseNode {
+ leadingComments: ReadonlyArray | null;
+ innerComments: ReadonlyArray | null;
+ trailingComments: ReadonlyArray | null;
+ start: number | null;
+ end: number | null;
+ loc: SourceLocation | null;
+ type: Node["type"];
+ range?: [number, number];
+ extra?: Record;
+}
+declare type CommentTypeShorthand = "leading" | "inner" | "trailing";
+declare type Node = AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | BinaryExpression | BindExpression | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | ExpressionStatement | File | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | LogicalExpression | MemberExpression | MetaProperty | MixedTypeAnnotation | ModuleExpression | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral$1 | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | PrivateName | Program | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral$1 | RestElement | RestProperty$1 | ReturnStatement | SequenceExpression | SpreadElement | SpreadProperty$1 | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSStringKeyword | TSSymbolKeyword | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnionTypeAnnotation | UpdateExpression | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidTypeAnnotation | WhileStatement | WithStatement | YieldExpression;
+interface ArrayExpression extends BaseNode {
+ type: "ArrayExpression";
+ elements: Array;
+}
+interface AssignmentExpression extends BaseNode {
+ type: "AssignmentExpression";
+ operator: string;
+ left: LVal;
+ right: Expression;
+}
+interface BinaryExpression extends BaseNode {
+ type: "BinaryExpression";
+ operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
+ left: Expression | PrivateName;
+ right: Expression;
+}
+interface InterpreterDirective extends BaseNode {
+ type: "InterpreterDirective";
+ value: string;
+}
+interface Directive extends BaseNode {
+ type: "Directive";
+ value: DirectiveLiteral;
+}
+interface DirectiveLiteral extends BaseNode {
+ type: "DirectiveLiteral";
+ value: string;
+}
+interface BlockStatement extends BaseNode {
+ type: "BlockStatement";
+ body: Array;
+ directives: Array;
+}
+interface BreakStatement extends BaseNode {
+ type: "BreakStatement";
+ label?: Identifier | null;
+}
+interface CallExpression extends BaseNode {
+ type: "CallExpression";
+ callee: Expression | V8IntrinsicIdentifier;
+ arguments: Array;
+ optional?: true | false | null;
+ typeArguments?: TypeParameterInstantiation | null;
+ typeParameters?: TSTypeParameterInstantiation | null;
+}
+interface CatchClause extends BaseNode {
+ type: "CatchClause";
+ param?: Identifier | ArrayPattern | ObjectPattern | null;
+ body: BlockStatement;
+}
+interface ConditionalExpression extends BaseNode {
+ type: "ConditionalExpression";
+ test: Expression;
+ consequent: Expression;
+ alternate: Expression;
+}
+interface ContinueStatement extends BaseNode {
+ type: "ContinueStatement";
+ label?: Identifier | null;
+}
+interface DebuggerStatement extends BaseNode {
+ type: "DebuggerStatement";
+}
+interface DoWhileStatement extends BaseNode {
+ type: "DoWhileStatement";
+ test: Expression;
+ body: Statement;
+}
+interface EmptyStatement extends BaseNode {
+ type: "EmptyStatement";
+}
+interface ExpressionStatement extends BaseNode {
+ type: "ExpressionStatement";
+ expression: Expression;
+}
+interface File extends BaseNode {
+ type: "File";
+ program: Program;
+ comments?: Array | null;
+ tokens?: Array | null;
+}
+interface ForInStatement extends BaseNode {
+ type: "ForInStatement";
+ left: VariableDeclaration | LVal;
+ right: Expression;
+ body: Statement;
+}
+interface ForStatement extends BaseNode {
+ type: "ForStatement";
+ init?: VariableDeclaration | Expression | null;
+ test?: Expression | null;
+ update?: Expression | null;
+ body: Statement;
+}
+interface FunctionDeclaration extends BaseNode {
+ type: "FunctionDeclaration";
+ id?: Identifier | null;
+ params: Array;
+ body: BlockStatement;
+ generator?: boolean;
+ async?: boolean;
+ declare?: boolean | null;
+ returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface FunctionExpression extends BaseNode {
+ type: "FunctionExpression";
+ id?: Identifier | null;
+ params: Array;
+ body: BlockStatement;
+ generator?: boolean;
+ async?: boolean;
+ returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
+ typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface Identifier extends BaseNode {
+ type: "Identifier";
+ name: string;
+ decorators?: Array | null;
+ optional?: boolean | null;
+ typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface IfStatement extends BaseNode {
+ type: "IfStatement";
+ test: Expression;
+ consequent: Statement;
+ alternate?: Statement | null;
+}
+interface LabeledStatement extends BaseNode {
+ type: "LabeledStatement";
+ label: Identifier;
+ body: Statement;
+}
+interface StringLiteral extends BaseNode {
+ type: "StringLiteral";
+ value: string;
+}
+interface NumericLiteral extends BaseNode {
+ type: "NumericLiteral";
+ value: number;
+}
+/**
+ * @deprecated Use `NumericLiteral`
+ */
+interface NumberLiteral$1 extends BaseNode {
+ type: "NumberLiteral";
+ value: number;
+}
+interface NullLiteral extends BaseNode {
+ type: "NullLiteral";
+}
+interface BooleanLiteral extends BaseNode {
+ type: "BooleanLiteral";
+ value: boolean;
+}
+interface RegExpLiteral extends BaseNode {
+ type: "RegExpLiteral";
+ pattern: string;
+ flags: string;
+}
+/**
+ * @deprecated Use `RegExpLiteral`
+ */
+interface RegexLiteral$1 extends BaseNode {
+ type: "RegexLiteral";
+ pattern: string;
+ flags: string;
+}
+interface LogicalExpression extends BaseNode {
+ type: "LogicalExpression";
+ operator: "||" | "&&" | "??";
+ left: Expression;
+ right: Expression;
+}
+interface MemberExpression extends BaseNode {
+ type: "MemberExpression";
+ object: Expression;
+ property: Expression | Identifier | PrivateName;
+ computed: boolean;
+ optional?: true | false | null;
+}
+interface NewExpression extends BaseNode {
+ type: "NewExpression";
+ callee: Expression | V8IntrinsicIdentifier;
+ arguments: Array;
+ optional?: true | false | null;
+ typeArguments?: TypeParameterInstantiation | null;
+ typeParameters?: TSTypeParameterInstantiation | null;
+}
+interface Program extends BaseNode {
+ type: "Program";
+ body: Array;
+ directives: Array;
+ sourceType: "script" | "module";
+ interpreter?: InterpreterDirective | null;
+ sourceFile: string;
+}
+interface ObjectExpression extends BaseNode {
+ type: "ObjectExpression";
+ properties: Array;
+}
+interface ObjectMethod extends BaseNode {
+ type: "ObjectMethod";
+ kind: "method" | "get" | "set";
+ key: Expression | Identifier | StringLiteral | NumericLiteral;
+ params: Array;
+ body: BlockStatement;
+ computed: boolean;
+ generator?: boolean;
+ async?: boolean;
+ decorators?: Array
+
+ 
