@vue.ts/complex-types 1.0.0-beta.1 → 1.0.0-beta.3

package/README.md

@@ -14,10 +14,6 @@ $ yarn add -D @vue.ts/complex-types
 $ pnpm add -D @vue.ts/complex-types
 ```
 
-## TODOs
-
-- [ ] Add more tests
-
 ## 🚀 Usage
 
 <details>

package/dist/astro.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 
 //#region src/astro.d.ts
 declare const _default: (options: Options) => {

package/dist/astro.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createVitePlugin } from "unplugin";
 
 //#region src/astro.ts

package/dist/esbuild.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as esbuild0 from "esbuild";
 

package/dist/esbuild.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createEsbuildPlugin } from "unplugin";
 
 //#region src/esbuild.ts

package/dist/farm.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as _farmfe_core0 from "@farmfe/core";
 

package/dist/farm.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createFarmPlugin } from "unplugin";
 
 //#region src/farm.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import * as unplugin0 from "unplugin";
 import { UnpluginFactory } from "unplugin";
 

package/dist/index.js

@@ -1,3 +1,3 @@
-import { src_default, unplugin, unpluginFactory } from "./src-CI8-WIu4.js";
+import { src_default, unplugin, unpluginFactory } from "./src-C2cWUkxC.js";
 
 export { src_default as default, unplugin, unpluginFactory };

package/dist/nuxt.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as _nuxt_schema0 from "@nuxt/schema";
 

package/dist/nuxt.js

@@ -1,6 +1,6 @@
-import "./src-CI8-WIu4.js";
-import { vite_default } from "./vite-Dyi1m2wg.js";
-import { webpack_default } from "./webpack-CFfuQfGw.js";
+import "./src-C2cWUkxC.js";
+import { vite_default } from "./vite-kxApzRU8.js";
+import { webpack_default } from "./webpack-DB3Ln7vl.js";
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
 
 //#region src/nuxt.ts

package/dist/rolldown.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as rolldown0 from "rolldown";
 

package/dist/rolldown.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createRolldownPlugin } from "unplugin";
 
 //#region src/rolldown.ts

package/dist/rollup.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as rollup0 from "rollup";
 

package/dist/rollup.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createRollupPlugin } from "unplugin";
 
 //#region src/rollup.ts

package/dist/rspack.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 
 //#region src/rspack.d.ts

package/dist/rspack.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createRspackPlugin } from "unplugin";
 
 //#region src/rspack.ts

package/dist/src-C2cWUkxC.js

@@ -0,0 +1,192 @@
+import { createUnplugin } from "unplugin";
+import { ensureLanguage, getLanguage } from "@vue.ts/language";
+import { createFilter, normalizePath } from "@vue.ts/shared";
+import MagicString from "magic-string";
+import ts from "typescript";
+import { join } from "node:path";
+
+//#region src/core/utils.ts
+const resolveOptions = (rawOptions) => ({
+	include: rawOptions.include ?? ["**/*.vue"],
+	exclude: rawOptions.exclude ?? ["node_modules/**"],
+	tsconfigPath: rawOptions.tsconfigPath ?? join(process.cwd(), "tsconfig.json"),
+	defineEmits: rawOptions.defineEmits ?? true,
+	defineProps: rawOptions.defineProps ?? true
+});
+const quotesReg = /"/g;
+const escapeQuotes = (s) => s.replace(quotesReg, "\\\"");
+
+//#endregion
+//#region src/core/printer.ts
+var Printer = class {
+	constructor(checker) {
+		this.checker = checker;
+	}
+	typeToString(type) {
+		return this.checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+	}
+	printOuterUnionOrIntersection(type, separator, inner) {
+		return [...new Set(type.types.map((t) => this.printType(t, inner)).filter(Boolean))].join(separator);
+	}
+	isUnionUndefined(union) {
+		return union.types.some((t) => t.flags & ts.TypeFlags.Undefined);
+	}
+	printPrimitiveType(type) {
+		if (type.flags & ts.TypeFlags.BooleanLiteral) return "boolean";
+		else if (type.flags & ts.TypeFlags.String || type.isStringLiteral()) return "string";
+		else if (type.flags & ts.TypeFlags.Number || type.isNumberLiteral()) return "number";
+		else if (type.flags & ts.TypeFlags.BigInt) return "bigint";
+		else if (type.flags & ts.TypeFlags.Any) return "any";
+		else if (type.flags & ts.TypeFlags.Unknown) return "unknown";
+		else if (type.flags & ts.TypeFlags.Null) return "null";
+		return "";
+	}
+	printType(type, inner = false) {
+		if (type.isUnion()) return this.printOuterUnionOrIntersection(type, " | ", inner);
+		else if (type.isIntersection()) return this.printOuterUnionOrIntersection(type, " & ", inner);
+		if (this.typeToString(type).endsWith("[]")) return this.typeToString(type);
+		else if (type.flags & ts.TypeFlags.Object) {
+			const decl = type.getSymbol()?.declarations?.[0];
+			if (decl && ts.isFunctionTypeNode(decl)) return "Function";
+			if (inner) return "object";
+			const properties = type.getProperties();
+			const props = {};
+			for (const prop of properties) {
+				const propType = this.checker.getTypeOfSymbol(prop);
+				props[prop.getName()] = {
+					value: this.printType(this.checker.getTypeOfSymbol(prop), true),
+					isOptional: propType.isUnion() ? this.isUnionUndefined(propType) : !!(propType.flags & ts.TypeFlags.Undefined)
+				};
+			}
+			const parts = [];
+			for (const [propName, propData] of Object.entries(props)) {
+				const questionMark = propData.isOptional ? "?" : "";
+				parts.push(`"${propName}"${questionMark}: ${propData.value},`);
+			}
+			return Object.keys(props).length > 0 ? `{\n${parts.join("\n")}\n}` : "";
+		} else if (type.isLiteral() || type.flags & ts.TypeFlags.BooleanLiteral || type.flags & ts.TypeFlags.String || type.flags & ts.TypeFlags.Number || type.flags & ts.TypeFlags.BigInt || type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown || type.flags & ts.TypeFlags.Null) return this.printPrimitiveType(type);
+		else if (type.flags & ts.TypeFlags.Undefined) return "";
+		else if (type.flags & ts.TypeFlags.Conditional) return `${this.printType(type.resolvedTrueType)} | ${this.printType(type.resolvedFalseType)}`;
+		else if (type.isTypeParameter()) {
+			const symbol = type.getSymbol();
+			const decl = symbol?.declarations?.[0];
+			if (!decl || !ts.isTypeParameterDeclaration(decl)) return "";
+			const ref = ts.getEffectiveConstraintOfTypeParameter(decl);
+			if (!ref) return "";
+			const refType = this.checker.getTypeAtLocation(ref);
+			return this.printType(refType);
+		}
+		return this.typeToString(type);
+	}
+	printPropsTypeArg(node) {
+		const type = this.checker.getTypeAtLocation(node);
+		return this.printType(type);
+	}
+	printEventsByCallSignatures(callSignatures) {
+		return callSignatures.map((c) => {
+			const parameters = c.getParameters();
+			const event = parameters[0];
+			return this.typeToString(this.checker.getTypeOfSymbol(event));
+		});
+	}
+	printEventsByMembers(members) {
+		return members.map((m) => `"${escapeQuotes(m.getName())}"`);
+	}
+	printEventsRuntimeArg(node) {
+		const parts = [];
+		const type = this.checker.getTypeAtLocation(node);
+		const callSignatures = type.getCallSignatures();
+		const members = type.getProperties();
+		if (callSignatures.length > 0 && members.length > 0) throw new Error("[@vue.ts/complex-types] You may not use old style `defineEmits` and `defineEmits` shorthand together.");
+		if (members.length > 0) parts.push(...this.printEventsByMembers(members));
+		else parts.push(...this.printEventsByCallSignatures(callSignatures));
+		return `[${parts.join(", ")}]`;
+	}
+};
+
+//#endregion
+//#region src/core/transformers/defineEmits.ts
+const transformDefineEmits = (printer, s, id) => {
+	const normalizedFilepath = normalizePath(id);
+	const language = getLanguage();
+	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
+	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
+	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
+	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
+	const scriptSetupDefineEmitsNode = language.findNodeByRange(scriptSetupAst, (scriptSetupRanges) => scriptSetupRanges.defineEmits?.callExp);
+	const virtualFileDefineEmitsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Emit");
+	if (!scriptSetupDefineEmitsNode || !virtualFileDefineEmitsTypeNode) return;
+	const offset = scriptSetupBlock.startTagEnd;
+	const defineEmitsRuntimeArg = ts.isCallExpression(scriptSetupDefineEmitsNode) && scriptSetupDefineEmitsNode.arguments[0];
+	if (defineEmitsRuntimeArg) throw new Error("[@vue.ts/complex-types] `defineEmits` cannot accept both runtime argument and type argument.");
+	const tokens = scriptSetupDefineEmitsNode.getChildren(scriptSetupAst);
+	const lessThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.LessThanToken);
+	const greaterThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.GreaterThanToken);
+	const openParenToken = tokens.find((t) => t.kind === ts.SyntaxKind.OpenParenToken);
+	if (!lessThanToken || !greaterThanToken || !openParenToken) return;
+	const defineEmitsTypeArgRange = [offset + lessThanToken.pos, offset + greaterThanToken.end];
+	const runtimeArgPos = offset + openParenToken.end;
+	const printedRuntimeArg = printer.printEventsRuntimeArg(virtualFileDefineEmitsTypeNode);
+	s.remove(...defineEmitsTypeArgRange);
+	s.appendRight(runtimeArgPos, printedRuntimeArg);
+};
+
+//#endregion
+//#region src/core/transformers/defineProps.ts
+const transformDefineProps = (printer, s, id) => {
+	const normalizedFilepath = normalizePath(id);
+	const language = getLanguage();
+	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
+	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
+	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
+	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
+	const scriptSetupDefinePropsTypeRange = language.parseScriptSetupRanges(scriptSetupAst).defineProps?.typeArg;
+	const virtualFileDefinePropsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Props");
+	if (!scriptSetupDefinePropsTypeRange || !virtualFileDefinePropsTypeNode) return;
+	const printedType = printer.printPropsTypeArg(virtualFileDefinePropsTypeNode);
+	const offset = scriptSetupBlock.startTagEnd;
+	s.overwrite(offset + scriptSetupDefinePropsTypeRange.start, offset + scriptSetupDefinePropsTypeRange.end, printedType);
+};
+
+//#endregion
+//#region src/core/transformers/index.ts
+const transformers = [["defineEmits", transformDefineEmits], ["defineProps", transformDefineProps]];
+const getTransformers = (options) => transformers.filter(([key]) => !!options[key]);
+
+//#endregion
+//#region src/core/transform.ts
+function transform(code, id, options) {
+	const s = new MagicString(code);
+	const language = getLanguage();
+	const typeChecker = language.__internal__.typeChecker;
+	const printer = new Printer(typeChecker);
+	const transformers$1 = getTransformers(options);
+	for (const [, transform$1] of transformers$1) transform$1(printer, s, id);
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: true })
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const unpluginFactory = (options = {}) => {
+	const resolvedOptions = resolveOptions(options);
+	const filter = createFilter(resolvedOptions.include, resolvedOptions.exclude);
+	return {
+		name: "@vue.ts/complex-types",
+		buildStart() {
+			const resolvedOptions$1 = resolveOptions(options);
+			ensureLanguage(resolvedOptions$1.tsconfigPath);
+		},
+		transform(code, id) {
+			if (!filter(id)) return;
+			return transform(code, id, resolvedOptions);
+		}
+	};
+};
+const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
+var src_default = unplugin;
+
+//#endregion
+export { src_default, unplugin, unpluginFactory };

package/dist/{types-CFmCIAvs.d.ts → types-afZXKowK.d.ts}

@@ -2,7 +2,7 @@ import MagicString from "magic-string";
 import ts from "typescript";
 import { FilterPattern } from "@rollup/pluginutils";
 
-//#region ../common/src/types.d.ts
+//#region ../shared/src/types.d.ts
 interface BaseOptions {
   include?: FilterPattern;
   exclude?: FilterPattern;
@@ -12,27 +12,12 @@ interface BaseOptions {
 declare class Printer {
   private checker;
   constructor(checker: ts.TypeChecker);
-  private getBaseType;
   private typeToString;
-  private printIntersectionTypeNode;
-  private printUnionTypeNode;
-  private printTypeLiteralNode;
-  private printTypeByType;
-  private printIdentifier;
-  private printInterfaceDeclaration;
-  private printEnumDeclaration;
-  private printClassDeclaration;
-  private printFunctionTypeNode;
-  private printConstructorTypeNode;
-  private printTypeQueryNode;
-  private printArrayTypeNode;
-  private printTupleTypeNode;
-  private printConditionalTypeNode;
-  private printIndexedAccessTypeNode;
-  private printHeritageClause;
-  private printImportSpecifier;
-  private isKeywordTypeNode;
-  print(node: ts.Node): string;
+  private printOuterUnionOrIntersection;
+  private isUnionUndefined;
+  private printPrimitiveType;
+  private printType;
+  printPropsTypeArg(node: ts.Node): string;
   private printEventsByCallSignatures;
   private printEventsByMembers;
   printEventsRuntimeArg(node: ts.Node): string;

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-import { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms } from "./types-CFmCIAvs.js";
+import { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 export { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms };

package/dist/{vite-Dyi1m2wg.js → vite-kxApzRU8.js}

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createVitePlugin } from "unplugin";
 
 //#region src/vite.ts

package/dist/vite.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as vite0 from "vite";
 

package/dist/vite.js

@@ -1,4 +1,4 @@
-import "./src-CI8-WIu4.js";
-import { vite_default } from "./vite-Dyi1m2wg.js";
+import "./src-C2cWUkxC.js";
+import { vite_default } from "./vite-kxApzRU8.js";
 
 export { vite_default as default };

package/dist/{webpack-CFfuQfGw.js → webpack-DB3Ln7vl.js}

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { unpluginFactory } from "./src-C2cWUkxC.js";
 import { createWebpackPlugin } from "unplugin";
 
 //#region src/webpack.ts

package/dist/webpack.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { Options } from "./types-afZXKowK.js";
 import "./types-u_Hr5uXA.js";
 import * as webpack0 from "webpack";
 

package/dist/webpack.js

@@ -1,4 +1,4 @@
-import "./src-CI8-WIu4.js";
-import { webpack_default } from "./webpack-CFfuQfGw.js";
+import "./src-C2cWUkxC.js";
+import { webpack_default } from "./webpack-DB3Ln7vl.js";
 
 export { webpack_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue.ts/complex-types",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "author": "Ray <i@mk1.io> (@so1ve)",
   "type": "module",
   "description": "Resolve complex types in Vue SFCs.",
@@ -65,8 +65,8 @@
     "@nuxt/kit": "^3.17.6",
     "magic-string": "^0.30.17",
     "unplugin": "^2.3.5",
-    "@vue.ts/language": "1.0.0-beta.1",
-    "@vue.ts/common": "1.0.0-beta.1"
+    "@vue.ts/language": "1.0.0-beta.3",
+    "@vue.ts/shared": "1.0.0-beta.3"
   },
   "devDependencies": {
     "@nuxt/schema": "^3.17.6",
@@ -83,9 +83,9 @@
     "esbuild": "*",
     "rolldown": "*",
     "rollup": "^3",
-    "typescript": "^5.2.2",
+    "typescript": ">=5.5",
     "vite": ">=3",
-    "vue": "^3.3.7",
+    "vue": ">=3",
     "webpack": "^4 || ^5"
   },
   "peerDependenciesMeta": {

package/dist/src-CI8-WIu4.js

@@ -1,354 +0,0 @@
-import { createUnplugin } from "unplugin";
-import { createFilter, normalizePath } from "@vue.ts/common";
-import { ensureLanguage, getLanguage } from "@vue.ts/language";
-import MagicString from "magic-string";
-import ts from "typescript";
-import { join } from "node:path";
-
-//#region src/core/utils.ts
-const resolveOptions = (rawOptions) => ({
-	include: rawOptions.include ?? ["**/*.vue"],
-	exclude: rawOptions.exclude ?? ["node_modules/**"],
-	tsconfigPath: rawOptions.tsconfigPath ?? join(process.cwd(), "tsconfig.json"),
-	defineEmits: rawOptions.defineEmits ?? true,
-	defineProps: rawOptions.defineProps ?? true
-});
-const quotesReg = /"/g;
-const escapeQuotes = (s) => s.replace(quotesReg, "\\\"");
-
-//#endregion
-//#region src/core/printer.ts
-var Printer = class {
-	constructor(checker) {
-		this.checker = checker;
-	}
-	getBaseType(nodeOrType) {
-		if ("kind" in nodeOrType) nodeOrType = this.checker.getTypeAtLocation(nodeOrType);
-		return this.checker.getBaseConstraintOfType(nodeOrType) ?? this.checker.getBaseTypeOfLiteralType(nodeOrType);
-	}
-	typeToString(type) {
-		return this.checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
-	}
-	printIntersectionTypeNode(node) {
-		return node.types.map((t) => this.print(t)).join(" & ");
-	}
-	printUnionTypeNode(node) {
-		return node.types.map((t) => this.print(t)).join(" | ");
-	}
-	printTypeLiteralNode(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertySignature(member)) {
-			const stringBaseType = member.type ? this.typeToString(this.getBaseType(member.type)) : "any";
-			parts.push([
-				member.name.getText(),
-				member.questionToken?.getText(),
-				": ",
-				stringBaseType
-			].filter(Boolean).join(""));
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printTypeByType(node) {
-		const type = this.checker.getTypeAtLocation(node);
-		const properties = type.getProperties();
-		const parts = ["{"];
-		const isMapped = ts.isMappedTypeNode(node);
-		for (const property of properties) {
-			const questionToken = isMapped ? node.questionToken?.getText() ?? "" : property.flags & ts.SymbolFlags.Optional ? "?" : "";
-			const valueType = this.checker.getTypeOfSymbol(property);
-			const stringValueType = this.typeToString(this.getBaseType(valueType));
-			parts.push(`${this.checker.symbolToString(property)}${questionToken}: ${stringValueType}`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printIdentifier(node) {
-		const symbol = this.checker.getSymbolAtLocation(node);
-		if (!symbol) return node.getText();
-		const declarations = symbol.getDeclarations();
-		if (!declarations || declarations.length === 0) return node.getText();
-		return this.print(declarations[0]);
-	}
-	printInterfaceDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertySignature(member)) {
-			const stringBaseType = member.type ? this.print(member.type) : "any";
-			parts.push([
-				member.name?.getText(),
-				member.questionToken?.getText(),
-				": ",
-				stringBaseType
-			].filter(Boolean).join(""));
-		} else if (ts.isMethodSignature(member)) {
-			const signature = this.checker.getSignatureFromDeclaration(member);
-			const returnType = signature ? this.typeToString(signature.getReturnType()) : "any";
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`${member.name?.getText()}(${parameters}): ${returnType}`);
-		}
-		parts.push("}");
-		let result = parts.join("\n");
-		if (node.heritageClauses && node.heritageClauses.length > 0) result = node.heritageClauses.map((clause) => this.print(clause)).join(" & ");
-		return result;
-	}
-	printEnumDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) {
-			const name = member.name.getText();
-			if (member.initializer) {
-				const value = member.initializer.getText();
-				parts.push(`${name}: ${value}`);
-			} else parts.push(`${name}: number`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printClassDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertyDeclaration(member)) {
-			const name = member.name?.getText();
-			const typeAnnotation = member.type ? this.typeToString(this.getBaseType(member.type)) : "any";
-			const optional = member.questionToken ? "?" : "";
-			parts.push(`${name}${optional}: ${typeAnnotation}`);
-		} else if (ts.isMethodDeclaration(member)) {
-			const name = member.name?.getText();
-			const signature = this.checker.getSignatureFromDeclaration(member);
-			const returnType = signature ? this.typeToString(signature.getReturnType()) : "any";
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`${name}(${parameters}): ${returnType}`);
-		} else if (ts.isConstructorDeclaration(member)) {
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`constructor(${parameters}): void`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printFunctionTypeNode(node) {
-		const parameters = node.parameters.map((param) => {
-			const paramType = param.type ? this.print(param.type) : "any";
-			const optional = param.questionToken ? "?" : "";
-			const rest = param.dotDotDotToken ? "..." : "";
-			return `${rest}${param.name.getText()}${optional}: ${paramType}`;
-		}).join(", ");
-		const returnType = node.type ? this.print(node.type) : "any";
-		return `(${parameters}) => ${returnType}`;
-	}
-	printConstructorTypeNode(node) {
-		const parameters = node.parameters.map((param) => {
-			const paramType = param.type ? this.print(param.type) : "any";
-			const optional = param.questionToken ? "?" : "";
-			const rest = param.dotDotDotToken ? "..." : "";
-			return `${rest}${param.name.getText()}${optional}: ${paramType}`;
-		}).join(", ");
-		const returnType = node.type ? this.print(node.type) : "any";
-		return `new (${parameters}) => ${returnType}`;
-	}
-	printTypeQueryNode(node) {
-		const exprName = node.exprName.getText();
-		return `typeof ${exprName}`;
-	}
-	printArrayTypeNode(node) {
-		return `${this.print(node.elementType)}[]`;
-	}
-	printTupleTypeNode(node) {
-		const elements = node.elements.map((element) => {
-			if (ts.isRestTypeNode(element)) return `...${this.print(element.type)}`;
-			if (ts.isOptionalTypeNode(element)) return `${this.print(element.type)}?`;
-			if (ts.isNamedTupleMember(element)) {
-				const type = this.print(element.type);
-				const optional = element.questionToken ? "?" : "";
-				const rest = element.dotDotDotToken ? "..." : "";
-				return `${rest}${element.name.getText()}${optional}: ${type}`;
-			}
-			return this.print(element);
-		});
-		return `[${elements.join(", ")}]`;
-	}
-	printConditionalTypeNode(node) {
-		const checkType = this.print(node.checkType);
-		const extendsType = this.print(node.extendsType);
-		const trueType = this.print(node.trueType);
-		const falseType = this.print(node.falseType);
-		return `${checkType} extends ${extendsType} ? ${trueType} : ${falseType}`;
-	}
-	printIndexedAccessTypeNode(node) {
-		const objectType = this.print(node.objectType);
-		const indexType = this.print(node.indexType);
-		return `${objectType}[${indexType}]`;
-	}
-	printHeritageClause(node) {
-		if (node.token === ts.SyntaxKind.ExtendsKeyword) {
-			const parts = [];
-			for (const type of node.types) if (ts.isExpressionWithTypeArguments(type)) if (type.expression && type.typeArguments) parts.push(this.print(type));
-			else parts.push(this.print(type.expression));
-			return parts.join(" & ");
-		}
-		return "";
-	}
-	printImportSpecifier(node) {
-		const name = node.propertyName ? node.propertyName.getText() : node.name.getText();
-		const symbol = this.checker.getSymbolAtLocation(node.name);
-		if (!symbol) return name;
-		const aliasedSymbol = this.checker.getAliasedSymbol(symbol);
-		const targetSymbol = aliasedSymbol || symbol;
-		const declarations = targetSymbol.getDeclarations();
-		if (!declarations || declarations.length === 0) return name;
-		const declaration = declarations.find((decl) => ts.isTypeAliasDeclaration(decl) || ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isEnumDeclaration(decl) || ts.isVariableDeclaration(decl));
-		if (declaration) return this.print(declaration);
-		return name;
-	}
-	isKeywordTypeNode(node) {
-		return node.kind === ts.SyntaxKind.StringKeyword || node.kind === ts.SyntaxKind.NumberKeyword || node.kind === ts.SyntaxKind.BooleanKeyword || node.kind === ts.SyntaxKind.ObjectKeyword || node.kind === ts.SyntaxKind.UndefinedKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.VoidKeyword || node.kind === ts.SyntaxKind.AnyKeyword || node.kind === ts.SyntaxKind.UnknownKeyword || node.kind === ts.SyntaxKind.NeverKeyword || node.kind === ts.SyntaxKind.SymbolKeyword || node.kind === ts.SyntaxKind.BigIntKeyword;
-	}
-	print(node) {
-		if (ts.isIdentifier(node)) return this.printIdentifier(node);
-		else if (ts.isIntersectionTypeNode(node)) return this.printIntersectionTypeNode(node);
-		else if (ts.isUnionTypeNode(node)) return this.printUnionTypeNode(node);
-		else if (ts.isTypeLiteralNode(node)) return this.printTypeLiteralNode(node);
-		else if (ts.isTypeReferenceNode(node)) return this.print(node.typeName);
-		else if (ts.isInterfaceDeclaration(node)) return this.printInterfaceDeclaration(node);
-		else if (ts.isTypeAliasDeclaration(node)) return node.type ? this.print(node.type) : "any";
-		else if (ts.isEnumDeclaration(node)) return this.printEnumDeclaration(node);
-		else if (ts.isClassDeclaration(node)) return this.printClassDeclaration(node);
-		else if (ts.isFunctionTypeNode(node)) return this.printFunctionTypeNode(node);
-		else if (ts.isConstructorTypeNode(node)) return this.printConstructorTypeNode(node);
-		else if (ts.isTypeQueryNode(node)) return this.printTypeQueryNode(node);
-		else if (ts.isArrayTypeNode(node)) return this.printArrayTypeNode(node);
-		else if (ts.isTupleTypeNode(node)) return this.printTupleTypeNode(node);
-		else if (ts.isConditionalTypeNode(node)) return this.printConditionalTypeNode(node);
-		else if (ts.isIndexedAccessTypeNode(node)) return this.printIndexedAccessTypeNode(node);
-		else if (ts.isParenthesizedTypeNode(node)) return this.print(node.type);
-		else if (ts.isHeritageClause(node)) return this.printHeritageClause(node);
-		else if (ts.isTypeAliasDeclaration(node) && node.type) return this.print(node.type);
-		else if (ts.isInterfaceDeclaration(node)) return this.printInterfaceDeclaration(node);
-		else if (ts.isVariableDeclaration(node) && node.type) return this.print(node.type);
-		else if (ts.isImportSpecifier(node)) return this.printImportSpecifier(node);
-		else if (ts.isTypeParameterDeclaration(node)) {
-			if (node.constraint) return this.print(node.constraint);
-			else if (node.default) return this.print(node.default);
-			return "{}";
-		} else if (ts.isParameter(node) && node.type) return this.print(node.type);
-		else if (ts.isLiteralTypeNode(node) || ts.isThisTypeNode(node) || ts.isPropertyAccessExpression(node) || this.isKeywordTypeNode(node)) return node.getText();
-		else if (ts.isMappedTypeNode(node) || ts.isExpressionWithTypeArguments(node)) return this.printTypeByType(node);
-		else {
-			console.error(`[@vue.ts/complex-types] \`${ts.SyntaxKind[node.kind]}\` is not supported.`);
-			return node.getText();
-		}
-	}
-	printEventsByCallSignatures(callSignatures) {
-		return callSignatures.map((c) => {
-			const parameters = c.getParameters();
-			const event = parameters[0];
-			return this.typeToString(this.checker.getTypeOfSymbol(event));
-		});
-	}
-	printEventsByMembers(members) {
-		return members.map((m) => `"${escapeQuotes(m.getName())}"`);
-	}
-	printEventsRuntimeArg(node) {
-		const parts = [];
-		const type = this.checker.getTypeAtLocation(node);
-		const callSignatures = type.getCallSignatures();
-		const members = type.getProperties();
-		if (callSignatures.length > 0 && members.length > 0) throw new Error("[@vue.ts/complex-types] You may not use old style `defineEmits` and `defineEmits` shorthand together.");
-		if (members.length > 0) parts.push(...this.printEventsByMembers(members));
-		else parts.push(...this.printEventsByCallSignatures(callSignatures));
-		return `[${parts.join(", ")}]`;
-	}
-};
-
-//#endregion
-//#region src/core/transformers/defineEmits.ts
-const transformDefineEmits = (printer, s, id) => {
-	const normalizedFilepath = normalizePath(id);
-	const language = getLanguage();
-	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
-	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
-	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
-	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
-	const scriptSetupDefineEmitsNode = language.findNodeByRange(scriptSetupAst, (scriptSetupRanges) => scriptSetupRanges.defineEmits?.callExp);
-	const virtualFileDefineEmitsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Emit");
-	if (!scriptSetupDefineEmitsNode || !virtualFileDefineEmitsTypeNode) return;
-	const offset = scriptSetupBlock.startTagEnd;
-	const defineEmitsRuntimeArg = ts.isCallExpression(scriptSetupDefineEmitsNode) && scriptSetupDefineEmitsNode.arguments[0];
-	if (defineEmitsRuntimeArg) throw new Error("[@vue.ts/complex-types] `defineEmits` cannot accept both runtime argument and type argument.");
-	const tokens = scriptSetupDefineEmitsNode.getChildren(scriptSetupAst);
-	const lessThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.LessThanToken);
-	const greaterThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.GreaterThanToken);
-	const openParenToken = tokens.find((t) => t.kind === ts.SyntaxKind.OpenParenToken);
-	if (!lessThanToken || !greaterThanToken || !openParenToken) return;
-	const defineEmitsTypeArgRange = [offset + lessThanToken.pos, offset + greaterThanToken.end];
-	const runtimeArgPos = offset + openParenToken.end;
-	const printedRuntimeArg = printer.printEventsRuntimeArg(virtualFileDefineEmitsTypeNode);
-	s.remove(...defineEmitsTypeArgRange);
-	s.appendRight(runtimeArgPos, printedRuntimeArg);
-};
-
-//#endregion
-//#region src/core/transformers/defineProps.ts
-const transformDefineProps = (printer, s, id) => {
-	const normalizedFilepath = normalizePath(id);
-	const language = getLanguage();
-	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
-	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
-	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
-	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
-	const scriptSetupDefinePropsTypeRange = language.parseScriptSetupRanges(scriptSetupAst).defineProps?.typeArg;
-	const virtualFileDefinePropsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Props");
-	if (!scriptSetupDefinePropsTypeRange || !virtualFileDefinePropsTypeNode) return;
-	const printedType = printer.print(virtualFileDefinePropsTypeNode);
-	const offset = scriptSetupBlock.startTagEnd;
-	s.overwrite(offset + scriptSetupDefinePropsTypeRange.start, offset + scriptSetupDefinePropsTypeRange.end, printedType);
-};
-
-//#endregion
-//#region src/core/transformers/index.ts
-const transformers = [["defineEmits", transformDefineEmits], ["defineProps", transformDefineProps]];
-const getTransformers = (options) => transformers.filter(([key]) => !!options[key]);
-
-//#endregion
-//#region src/core/transform.ts
-function transform(code, id, options) {
-	const s = new MagicString(code);
-	const language = getLanguage();
-	const typeChecker = language.__internal__.typeChecker;
-	const printer = new Printer(typeChecker);
-	const transformers$1 = getTransformers(options);
-	for (const [, transform$1] of transformers$1) transform$1(printer, s, id);
-	return {
-		code: s.toString(),
-		map: s.generateMap({ hires: true })
-	};
-}
-
-//#endregion
-//#region src/index.ts
-const unpluginFactory = (options = {}) => {
-	const resolvedOptions = resolveOptions(options);
-	const filter = createFilter(resolvedOptions.include, resolvedOptions.exclude);
-	return {
-		name: "@vue.ts/complex-types",
-		buildStart() {
-			const resolvedOptions$1 = resolveOptions(options);
-			ensureLanguage(resolvedOptions$1.tsconfigPath);
-		},
-		transform(code, id) {
-			if (!filter(id)) return;
-			return transform(code, id, resolvedOptions);
-		}
-	};
-};
-const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
-var src_default = unplugin;
-
-//#endregion
-export { src_default, unplugin, unpluginFactory };