@voidzero-dev/vite-plus-core 0.2.5 → 0.2.6

package/dist/tsdown/{dist-Pjag7IPt.js → dist-CxIM8o7n.js}

@@ -1,6 +1,8 @@
-import { r as createDebug } from "./main-BlTcyuFi.js";
-import { _ as filename_dts_to, b as replaceTemplateName, c as RE_CSS, d as RE_JS, f as RE_JSON, g as RE_VUE, h as RE_TS, l as RE_DTS, m as RE_ROLLDOWN_RUNTIME, o as at, p as RE_NODE_MODULES, s as ee, u as RE_DTS_MAP, v as filename_js_to_dts, x as resolveTemplateFn, y as filename_to_dts } from "./build-BlM3pDGJ-C8Uovnt4.js";
-import { i as __require$1, n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-BusiAGCd.js";
+import { r as createDebug } from "./main-BdzlWPt6.js";
+import { C as filename_to_dts, S as filename_js_to_dts, T as resolveTemplateFn, _ as RE_JSON, b as RE_TS, g as RE_JS, h as RE_DTS_MAP, m as RE_DTS, p as RE_CSS, v as RE_NODE_MODULES, w as replaceTemplateName, x as filename_dts_to, y as RE_ROLLDOWN_RUNTIME } from "./target-CNxIDvSz-eoHNdJNs.js";
+import { n as ee, t as at } from "./dist-DCMiHFrJ.js";
+import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-CA76SkkZ.js";
+import { t as requireTS } from "./load-tsc-BKULZsrs-BFmeD6Bu.js";
 import { createRequire } from "node:module";
 import process from "node:process";
 import { styleText } from "node:util";
@@ -12,1431 +14,8 @@ import { importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filte
 import { tmpdir } from "node:os";
 import { ResolverFactory, isolatedDeclarationSync } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
 import { print } from "yuku-codegen";
-import { parse as parse$1, walk } from "yuku-parser";
-//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/index.mjs
-const span = {
-	start: 0,
-	end: 0
-};
-const isComputedKey = (key) => key.type !== "Identifier" && key.type !== "PrivateIdentifier";
-const b = {
-	identifier(name, opts = {}) {
-		return {
-			type: "Identifier",
-			name,
-			...opts,
-			...span
-		};
-	},
-	privateIdentifier(name) {
-		return {
-			type: "PrivateIdentifier",
-			name,
-			...span
-		};
-	},
-	stringLiteral(value) {
-		return {
-			type: "Literal",
-			value,
-			raw: JSON.stringify(value),
-			...span
-		};
-	},
-	numericLiteral(value) {
-		return {
-			type: "Literal",
-			value,
-			raw: String(value),
-			...span
-		};
-	},
-	booleanLiteral(value) {
-		return {
-			type: "Literal",
-			value,
-			raw: String(value),
-			...span
-		};
-	},
-	nullLiteral() {
-		return {
-			type: "Literal",
-			value: null,
-			raw: "null",
-			...span
-		};
-	},
-	bigIntLiteral(value) {
-		return {
-			type: "Literal",
-			value,
-			raw: `${value}n`,
-			bigint: String(value),
-			...span
-		};
-	},
-	regExpLiteral(pattern, flags = "") {
-		let value = null;
-		try {
-			value = new RegExp(pattern, flags);
-		} catch {}
-		return {
-			type: "Literal",
-			value,
-			raw: `/${pattern}/${flags}`,
-			regex: {
-				pattern,
-				flags
-			},
-			...span
-		};
-	},
-	templateLiteral(quasis, expressions) {
-		return {
-			type: "TemplateLiteral",
-			quasis,
-			expressions,
-			...span
-		};
-	},
-	templateElement(cooked, tail = false) {
-		return {
-			type: "TemplateElement",
-			value: {
-				raw: cooked,
-				cooked
-			},
-			tail,
-			...span
-		};
-	},
-	thisExpression() {
-		return {
-			type: "ThisExpression",
-			...span
-		};
-	},
-	super() {
-		return {
-			type: "Super",
-			...span
-		};
-	},
-	arrayPattern(elements) {
-		return {
-			type: "ArrayPattern",
-			elements,
-			...span
-		};
-	},
-	objectPattern(properties) {
-		return {
-			type: "ObjectPattern",
-			properties,
-			...span
-		};
-	},
-	assignmentPattern(left, right) {
-		return {
-			type: "AssignmentPattern",
-			left,
-			right,
-			...span
-		};
-	},
-	restElement(argument) {
-		return {
-			type: "RestElement",
-			argument,
-			...span
-		};
-	},
-	/** A member of an `ObjectExpression`. For an `ObjectPattern` member, use {@link bindingProperty}. */
-	objectProperty(key, value, opts = {}) {
-		return {
-			type: "Property",
-			kind: opts.kind ?? "init",
-			key,
-			value,
-			method: opts.method ?? false,
-			shorthand: opts.shorthand ?? false,
-			computed: opts.computed ?? isComputedKey(key),
-			...span
-		};
-	},
-	/** A member of an `ObjectPattern`, whose value is a binding target. For an `ObjectExpression` member, use {@link objectProperty}. */
-	bindingProperty(key, value, opts = {}) {
-		return {
-			type: "Property",
-			kind: "init",
-			key,
-			value,
-			method: false,
-			shorthand: opts.shorthand ?? false,
-			computed: opts.computed ?? isComputedKey(key),
-			...span
-		};
-	},
-	arrayExpression(elements = []) {
-		return {
-			type: "ArrayExpression",
-			elements,
-			...span
-		};
-	},
-	objectExpression(properties = []) {
-		return {
-			type: "ObjectExpression",
-			properties,
-			...span
-		};
-	},
-	spreadElement(argument) {
-		return {
-			type: "SpreadElement",
-			argument,
-			...span
-		};
-	},
-	sequenceExpression(expressions) {
-		return {
-			type: "SequenceExpression",
-			expressions,
-			...span
-		};
-	},
-	parenthesizedExpression(expression) {
-		return {
-			type: "ParenthesizedExpression",
-			expression,
-			...span
-		};
-	},
-	unaryExpression(operator, argument) {
-		return {
-			type: "UnaryExpression",
-			operator,
-			prefix: true,
-			argument,
-			...span
-		};
-	},
-	updateExpression(operator, argument, prefix = false) {
-		return {
-			type: "UpdateExpression",
-			operator,
-			argument,
-			prefix,
-			...span
-		};
-	},
-	binaryExpression(operator, left, right) {
-		return {
-			type: "BinaryExpression",
-			operator,
-			left,
-			right,
-			...span
-		};
-	},
-	logicalExpression(operator, left, right) {
-		return {
-			type: "LogicalExpression",
-			operator,
-			left,
-			right,
-			...span
-		};
-	},
-	assignmentExpression(operator, left, right) {
-		return {
-			type: "AssignmentExpression",
-			operator,
-			left,
-			right,
-			...span
-		};
-	},
-	conditionalExpression(test, consequent, alternate) {
-		return {
-			type: "ConditionalExpression",
-			test,
-			consequent,
-			alternate,
-			...span
-		};
-	},
-	yieldExpression(argument = null, delegate = false) {
-		return {
-			type: "YieldExpression",
-			delegate,
-			argument,
-			...span
-		};
-	},
-	awaitExpression(argument) {
-		return {
-			type: "AwaitExpression",
-			argument,
-			...span
-		};
-	},
-	memberExpression(object, property, opts = {}) {
-		return {
-			type: "MemberExpression",
-			object,
-			property,
-			computed: opts.computed ?? isComputedKey(property),
-			optional: opts.optional ?? false,
-			...span
-		};
-	},
-	callExpression(callee, args = [], opts = {}) {
-		return {
-			type: "CallExpression",
-			callee,
-			arguments: args,
-			optional: opts.optional ?? false,
-			...opts,
-			...span
-		};
-	},
-	newExpression(callee, args = [], opts = {}) {
-		return {
-			type: "NewExpression",
-			callee,
-			arguments: args,
-			...opts,
-			...span
-		};
-	},
-	chainExpression(expression) {
-		return {
-			type: "ChainExpression",
-			expression,
-			...span
-		};
-	},
-	taggedTemplateExpression(tag, quasi, opts = {}) {
-		return {
-			type: "TaggedTemplateExpression",
-			tag,
-			quasi,
-			...opts,
-			...span
-		};
-	},
-	metaProperty(meta, property) {
-		return {
-			type: "MetaProperty",
-			meta: b.identifier(meta),
-			property: b.identifier(property),
-			...span
-		};
-	},
-	importExpression(source, opts = {}) {
-		return {
-			type: "ImportExpression",
-			source,
-			options: opts.options ?? null,
-			phase: opts.phase ?? null,
-			...span
-		};
-	},
-	arrowFunctionExpression(params, body, opts = {}) {
-		return {
-			type: "ArrowFunctionExpression",
-			id: null,
-			generator: false,
-			async: opts.async ?? false,
-			params,
-			body,
-			expression: body.type !== "BlockStatement",
-			...opts,
-			...span
-		};
-	},
-	functionExpression(params, body, opts = {}) {
-		return {
-			type: "FunctionExpression",
-			id: opts.id ?? null,
-			generator: opts.generator ?? false,
-			async: opts.async ?? false,
-			params,
-			body,
-			expression: false,
-			...span
-		};
-	},
-	functionDeclaration(id, params, body, opts = {}) {
-		return {
-			type: "FunctionDeclaration",
-			id,
-			generator: opts.generator ?? false,
-			async: opts.async ?? false,
-			params,
-			body,
-			expression: false,
-			...span
-		};
-	},
-	classDeclaration(id, body, opts = {}) {
-		return {
-			type: "ClassDeclaration",
-			decorators: opts.decorators ?? [],
-			id,
-			superClass: opts.superClass ?? null,
-			body,
-			...opts,
-			...span
-		};
-	},
-	classExpression(id, body, opts = {}) {
-		return {
-			type: "ClassExpression",
-			decorators: opts.decorators ?? [],
-			id,
-			superClass: opts.superClass ?? null,
-			body,
-			...span
-		};
-	},
-	classBody(body = []) {
-		return {
-			type: "ClassBody",
-			body,
-			...span
-		};
-	},
-	methodDefinition(key, value, opts = {}) {
-		return {
-			type: "MethodDefinition",
-			decorators: [],
-			key,
-			value,
-			kind: opts.kind ?? "method",
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	propertyDefinition(key, value = null, opts = {}) {
-		return {
-			type: "PropertyDefinition",
-			decorators: opts.decorators ?? [],
-			key,
-			value,
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	accessorProperty(key, value = null, opts = {}) {
-		return {
-			type: "AccessorProperty",
-			decorators: [],
-			key,
-			value,
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	tsAbstractMethodDefinition(key, value, opts = {}) {
-		return {
-			type: "TSAbstractMethodDefinition",
-			decorators: [],
-			key,
-			value,
-			kind: opts.kind ?? "method",
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	tsAbstractPropertyDefinition(key, value = null, opts = {}) {
-		return {
-			type: "TSAbstractPropertyDefinition",
-			decorators: [],
-			key,
-			value,
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	tsAbstractAccessorProperty(key, value = null, opts = {}) {
-		return {
-			type: "TSAbstractAccessorProperty",
-			decorators: [],
-			key,
-			value,
-			computed: opts.computed ?? isComputedKey(key),
-			static: opts.static ?? false,
-			...span
-		};
-	},
-	staticBlock(body = []) {
-		return {
-			type: "StaticBlock",
-			body,
-			...span
-		};
-	},
-	decorator(expression) {
-		return {
-			type: "Decorator",
-			expression,
-			...span
-		};
-	},
-	expressionStatement(expression) {
-		return {
-			type: "ExpressionStatement",
-			expression,
-			...span
-		};
-	},
-	directive(value) {
-		return {
-			type: "ExpressionStatement",
-			expression: b.stringLiteral(value),
-			directive: value,
-			...span
-		};
-	},
-	blockStatement(body = []) {
-		return {
-			type: "BlockStatement",
-			body,
-			...span
-		};
-	},
-	emptyStatement() {
-		return {
-			type: "EmptyStatement",
-			...span
-		};
-	},
-	debuggerStatement() {
-		return {
-			type: "DebuggerStatement",
-			...span
-		};
-	},
-	returnStatement(argument = null) {
-		return {
-			type: "ReturnStatement",
-			argument,
-			...span
-		};
-	},
-	ifStatement(test, consequent, alternate = null) {
-		return {
-			type: "IfStatement",
-			test,
-			consequent,
-			alternate,
-			...span
-		};
-	},
-	switchStatement(discriminant, cases) {
-		return {
-			type: "SwitchStatement",
-			discriminant,
-			cases,
-			...span
-		};
-	},
-	switchCase(test, consequent) {
-		return {
-			type: "SwitchCase",
-			test,
-			consequent,
-			...span
-		};
-	},
-	throwStatement(argument) {
-		return {
-			type: "ThrowStatement",
-			argument,
-			...span
-		};
-	},
-	tryStatement(block, handler = null, finalizer = null) {
-		return {
-			type: "TryStatement",
-			block,
-			handler,
-			finalizer,
-			...span
-		};
-	},
-	catchClause(param, body) {
-		return {
-			type: "CatchClause",
-			param,
-			body,
-			...span
-		};
-	},
-	whileStatement(test, body) {
-		return {
-			type: "WhileStatement",
-			test,
-			body,
-			...span
-		};
-	},
-	doWhileStatement(body, test) {
-		return {
-			type: "DoWhileStatement",
-			body,
-			test,
-			...span
-		};
-	},
-	forStatement(init, test, update, body) {
-		return {
-			type: "ForStatement",
-			init,
-			test,
-			update,
-			body,
-			...span
-		};
-	},
-	forInStatement(left, right, body) {
-		return {
-			type: "ForInStatement",
-			left,
-			right,
-			body,
-			...span
-		};
-	},
-	forOfStatement(left, right, body, isAwait = false) {
-		return {
-			type: "ForOfStatement",
-			left,
-			right,
-			body,
-			await: isAwait,
-			...span
-		};
-	},
-	labeledStatement(label, body) {
-		return {
-			type: "LabeledStatement",
-			label,
-			body,
-			...span
-		};
-	},
-	breakStatement(label = null) {
-		return {
-			type: "BreakStatement",
-			label,
-			...span
-		};
-	},
-	continueStatement(label = null) {
-		return {
-			type: "ContinueStatement",
-			label,
-			...span
-		};
-	},
-	withStatement(object, body) {
-		return {
-			type: "WithStatement",
-			object,
-			body,
-			...span
-		};
-	},
-	variableDeclaration(kind, declarations) {
-		return {
-			type: "VariableDeclaration",
-			kind,
-			declarations,
-			...span
-		};
-	},
-	variableDeclarator(id, init = null) {
-		return {
-			type: "VariableDeclarator",
-			id,
-			init,
-			...span
-		};
-	},
-	importDeclaration(specifiers, source, opts = {}) {
-		return {
-			type: "ImportDeclaration",
-			specifiers,
-			source,
-			phase: opts.phase ?? null,
-			attributes: opts.attributes ?? [],
-			...opts,
-			...span
-		};
-	},
-	importSpecifier(imported, local) {
-		return {
-			type: "ImportSpecifier",
-			imported,
-			local,
-			...span
-		};
-	},
-	importDefaultSpecifier(local) {
-		return {
-			type: "ImportDefaultSpecifier",
-			local,
-			...span
-		};
-	},
-	importNamespaceSpecifier(local) {
-		return {
-			type: "ImportNamespaceSpecifier",
-			local,
-			...span
-		};
-	},
-	importAttribute(key, value) {
-		return {
-			type: "ImportAttribute",
-			key,
-			value,
-			...span
-		};
-	},
-	exportNamedDeclaration(declaration, specifiers = [], opts = {}) {
-		return {
-			type: "ExportNamedDeclaration",
-			declaration,
-			specifiers,
-			source: opts.source ?? null,
-			attributes: opts.attributes ?? [],
-			...opts,
-			...span
-		};
-	},
-	exportDefaultDeclaration(declaration) {
-		return {
-			type: "ExportDefaultDeclaration",
-			declaration,
-			...span
-		};
-	},
-	exportAllDeclaration(source, opts = {}) {
-		return {
-			type: "ExportAllDeclaration",
-			exported: opts.exported ?? null,
-			source,
-			attributes: opts.attributes ?? [],
-			...opts,
-			...span
-		};
-	},
-	exportSpecifier(local, exported) {
-		return {
-			type: "ExportSpecifier",
-			local,
-			exported,
-			...span
-		};
-	},
-	jsxIdentifier(name) {
-		return {
-			type: "JSXIdentifier",
-			name,
-			...span
-		};
-	},
-	jsxNamespacedName(namespace, name) {
-		return {
-			type: "JSXNamespacedName",
-			namespace,
-			name,
-			...span
-		};
-	},
-	jsxMemberExpression(object, property) {
-		return {
-			type: "JSXMemberExpression",
-			object,
-			property,
-			...span
-		};
-	},
-	jsxElement(openingElement, children = [], closingElement = null) {
-		return {
-			type: "JSXElement",
-			openingElement,
-			children,
-			closingElement,
-			...span
-		};
-	},
-	jsxOpeningElement(name, attributes = [], selfClosing = false) {
-		return {
-			type: "JSXOpeningElement",
-			name,
-			attributes,
-			selfClosing,
-			...span
-		};
-	},
-	jsxClosingElement(name) {
-		return {
-			type: "JSXClosingElement",
-			name,
-			...span
-		};
-	},
-	jsxOpeningFragment() {
-		return {
-			type: "JSXOpeningFragment",
-			...span
-		};
-	},
-	jsxClosingFragment() {
-		return {
-			type: "JSXClosingFragment",
-			...span
-		};
-	},
-	jsxFragment(children = []) {
-		return {
-			type: "JSXFragment",
-			openingFragment: b.jsxOpeningFragment(),
-			children,
-			closingFragment: b.jsxClosingFragment(),
-			...span
-		};
-	},
-	jsxAttribute(name, value = null) {
-		return {
-			type: "JSXAttribute",
-			name,
-			value,
-			...span
-		};
-	},
-	jsxSpreadAttribute(argument) {
-		return {
-			type: "JSXSpreadAttribute",
-			argument,
-			...span
-		};
-	},
-	jsxExpressionContainer(expression) {
-		return {
-			type: "JSXExpressionContainer",
-			expression,
-			...span
-		};
-	},
-	jsxEmptyExpression() {
-		return {
-			type: "JSXEmptyExpression",
-			...span
-		};
-	},
-	jsxText(value) {
-		return {
-			type: "JSXText",
-			value,
-			raw: value,
-			...span
-		};
-	},
-	jsxSpreadChild(expression) {
-		return {
-			type: "JSXSpreadChild",
-			expression,
-			...span
-		};
-	},
-	tsTypeAnnotation(typeAnnotation) {
-		return {
-			type: "TSTypeAnnotation",
-			typeAnnotation,
-			...span
-		};
-	},
-	tsAnyKeyword: () => ({
-		type: "TSAnyKeyword",
-		...span
-	}),
-	tsUnknownKeyword: () => ({
-		type: "TSUnknownKeyword",
-		...span
-	}),
-	tsNeverKeyword: () => ({
-		type: "TSNeverKeyword",
-		...span
-	}),
-	tsVoidKeyword: () => ({
-		type: "TSVoidKeyword",
-		...span
-	}),
-	tsNullKeyword: () => ({
-		type: "TSNullKeyword",
-		...span
-	}),
-	tsUndefinedKeyword: () => ({
-		type: "TSUndefinedKeyword",
-		...span
-	}),
-	tsStringKeyword: () => ({
-		type: "TSStringKeyword",
-		...span
-	}),
-	tsNumberKeyword: () => ({
-		type: "TSNumberKeyword",
-		...span
-	}),
-	tsBigIntKeyword: () => ({
-		type: "TSBigIntKeyword",
-		...span
-	}),
-	tsBooleanKeyword: () => ({
-		type: "TSBooleanKeyword",
-		...span
-	}),
-	tsSymbolKeyword: () => ({
-		type: "TSSymbolKeyword",
-		...span
-	}),
-	tsObjectKeyword: () => ({
-		type: "TSObjectKeyword",
-		...span
-	}),
-	tsIntrinsicKeyword: () => ({
-		type: "TSIntrinsicKeyword",
-		...span
-	}),
-	tsThisType: () => ({
-		type: "TSThisType",
-		...span
-	}),
-	tsTypeReference(typeName, typeArguments = null) {
-		return {
-			type: "TSTypeReference",
-			typeName,
-			typeArguments,
-			...span
-		};
-	},
-	tsQualifiedName(left, right) {
-		return {
-			type: "TSQualifiedName",
-			left,
-			right,
-			...span
-		};
-	},
-	tsTypeQuery(exprName, typeArguments = null) {
-		return {
-			type: "TSTypeQuery",
-			exprName,
-			typeArguments,
-			...span
-		};
-	},
-	tsImportType(source, opts = {}) {
-		return {
-			type: "TSImportType",
-			source,
-			options: opts.options ?? null,
-			qualifier: opts.qualifier ?? null,
-			typeArguments: opts.typeArguments ?? null,
-			...span
-		};
-	},
-	tsTypeParameter(name, opts = {}) {
-		return {
-			type: "TSTypeParameter",
-			name,
-			constraint: opts.constraint ?? null,
-			default: opts.default ?? null,
-			in: opts.in ?? false,
-			out: opts.out ?? false,
-			const: opts.const ?? false,
-			...span
-		};
-	},
-	tsTypeParameterDeclaration(params) {
-		return {
-			type: "TSTypeParameterDeclaration",
-			params,
-			...span
-		};
-	},
-	tsTypeParameterInstantiation(params) {
-		return {
-			type: "TSTypeParameterInstantiation",
-			params,
-			...span
-		};
-	},
-	tsLiteralType(literal) {
-		return {
-			type: "TSLiteralType",
-			literal,
-			...span
-		};
-	},
-	tsTemplateLiteralType(quasis, types) {
-		return {
-			type: "TSTemplateLiteralType",
-			quasis,
-			types,
-			...span
-		};
-	},
-	tsArrayType(elementType) {
-		return {
-			type: "TSArrayType",
-			elementType,
-			...span
-		};
-	},
-	tsIndexedAccessType(objectType, indexType) {
-		return {
-			type: "TSIndexedAccessType",
-			objectType,
-			indexType,
-			...span
-		};
-	},
-	tsTupleType(elementTypes) {
-		return {
-			type: "TSTupleType",
-			elementTypes,
-			...span
-		};
-	},
-	tsNamedTupleMember(label, elementType, optional = false) {
-		return {
-			type: "TSNamedTupleMember",
-			label,
-			elementType,
-			optional,
-			...span
-		};
-	},
-	tsOptionalType(typeAnnotation) {
-		return {
-			type: "TSOptionalType",
-			typeAnnotation,
-			...span
-		};
-	},
-	tsRestType(typeAnnotation) {
-		return {
-			type: "TSRestType",
-			typeAnnotation,
-			...span
-		};
-	},
-	tsJSDocNullableType(typeAnnotation, postfix = false) {
-		return {
-			type: "TSJSDocNullableType",
-			typeAnnotation,
-			postfix,
-			...span
-		};
-	},
-	tsJSDocNonNullableType(typeAnnotation, postfix = false) {
-		return {
-			type: "TSJSDocNonNullableType",
-			typeAnnotation,
-			postfix,
-			...span
-		};
-	},
-	tsJSDocUnknownType() {
-		return {
-			type: "TSJSDocUnknownType",
-			...span
-		};
-	},
-	tsUnionType(types) {
-		return {
-			type: "TSUnionType",
-			types,
-			...span
-		};
-	},
-	tsIntersectionType(types) {
-		return {
-			type: "TSIntersectionType",
-			types,
-			...span
-		};
-	},
-	tsConditionalType(checkType, extendsType, trueType, falseType) {
-		return {
-			type: "TSConditionalType",
-			checkType,
-			extendsType,
-			trueType,
-			falseType,
-			...span
-		};
-	},
-	tsInferType(typeParameter) {
-		return {
-			type: "TSInferType",
-			typeParameter,
-			...span
-		};
-	},
-	tsTypeOperator(operator, typeAnnotation) {
-		return {
-			type: "TSTypeOperator",
-			operator,
-			typeAnnotation,
-			...span
-		};
-	},
-	tsParenthesizedType(typeAnnotation) {
-		return {
-			type: "TSParenthesizedType",
-			typeAnnotation,
-			...span
-		};
-	},
-	tsFunctionType(params, returnType, typeParameters = null) {
-		return {
-			type: "TSFunctionType",
-			typeParameters,
-			params,
-			returnType,
-			...span
-		};
-	},
-	tsConstructorType(params, returnType, opts = {}) {
-		return {
-			type: "TSConstructorType",
-			abstract: opts.abstract ?? false,
-			typeParameters: opts.typeParameters ?? null,
-			params,
-			returnType,
-			...span
-		};
-	},
-	tsTypePredicate(parameterName, typeAnnotation = null, asserts = false) {
-		return {
-			type: "TSTypePredicate",
-			parameterName,
-			typeAnnotation,
-			asserts,
-			...span
-		};
-	},
-	tsTypeLiteral(members) {
-		return {
-			type: "TSTypeLiteral",
-			members,
-			...span
-		};
-	},
-	tsMappedType(key, constraint, opts = {}) {
-		return {
-			type: "TSMappedType",
-			key,
-			constraint,
-			nameType: opts.nameType ?? null,
-			typeAnnotation: opts.typeAnnotation ?? null,
-			optional: opts.optional ?? false,
-			readonly: opts.readonly ?? null,
-			...span
-		};
-	},
-	tsPropertySignature(key, opts = {}) {
-		return {
-			type: "TSPropertySignature",
-			key,
-			typeAnnotation: opts.typeAnnotation ?? null,
-			computed: opts.computed ?? isComputedKey(key),
-			optional: opts.optional ?? false,
-			readonly: opts.readonly ?? false,
-			accessibility: null,
-			static: false,
-			...span
-		};
-	},
-	tsMethodSignature(key, params, opts = {}) {
-		return {
-			type: "TSMethodSignature",
-			key,
-			computed: opts.computed ?? isComputedKey(key),
-			optional: opts.optional ?? false,
-			kind: opts.kind ?? "method",
-			typeParameters: opts.typeParameters ?? null,
-			params,
-			returnType: opts.returnType ?? null,
-			accessibility: null,
-			readonly: false,
-			static: false,
-			...span
-		};
-	},
-	tsCallSignatureDeclaration(params, returnType = null, typeParameters = null) {
-		return {
-			type: "TSCallSignatureDeclaration",
-			typeParameters,
-			params,
-			returnType,
-			...span
-		};
-	},
-	tsConstructSignatureDeclaration(params, returnType = null, typeParameters = null) {
-		return {
-			type: "TSConstructSignatureDeclaration",
-			typeParameters,
-			params,
-			returnType,
-			...span
-		};
-	},
-	tsIndexSignature(parameters, typeAnnotation, opts = {}) {
-		return {
-			type: "TSIndexSignature",
-			parameters,
-			typeAnnotation,
-			readonly: opts.readonly ?? false,
-			static: opts.static ?? false,
-			accessibility: null,
-			...span
-		};
-	},
-	tsTypeAliasDeclaration(id, typeAnnotation, opts = {}) {
-		return {
-			type: "TSTypeAliasDeclaration",
-			id,
-			typeParameters: opts.typeParameters ?? null,
-			typeAnnotation,
-			declare: opts.declare ?? false,
-			...span
-		};
-	},
-	tsInterfaceDeclaration(id, body, opts = {}) {
-		return {
-			type: "TSInterfaceDeclaration",
-			id,
-			typeParameters: opts.typeParameters ?? null,
-			extends: opts.extends ?? [],
-			body,
-			declare: opts.declare ?? false,
-			...span
-		};
-	},
-	tsInterfaceBody(body) {
-		return {
-			type: "TSInterfaceBody",
-			body,
-			...span
-		};
-	},
-	tsInterfaceHeritage(expression, typeArguments = null) {
-		return {
-			type: "TSInterfaceHeritage",
-			expression,
-			typeArguments,
-			...span
-		};
-	},
-	tsClassImplements(expression, typeArguments = null) {
-		return {
-			type: "TSClassImplements",
-			expression,
-			typeArguments,
-			...span
-		};
-	},
-	tsEnumDeclaration(id, body, opts = {}) {
-		return {
-			type: "TSEnumDeclaration",
-			id,
-			body,
-			const: opts.const ?? false,
-			declare: opts.declare ?? false,
-			...span
-		};
-	},
-	tsEnumBody(members) {
-		return {
-			type: "TSEnumBody",
-			members,
-			...span
-		};
-	},
-	tsEnumMember(id, initializer = null) {
-		return {
-			type: "TSEnumMember",
-			id,
-			initializer,
-			computed: false,
-			...span
-		};
-	},
-	tsModuleDeclaration(id, body, opts = {}) {
-		return {
-			type: "TSModuleDeclaration",
-			id,
-			body,
-			kind: opts.kind ?? "module",
-			declare: opts.declare ?? false,
-			global: opts.global ?? false,
-			...span
-		};
-	},
-	tsModuleBlock(body = []) {
-		return {
-			type: "TSModuleBlock",
-			body,
-			...span
-		};
-	},
-	tsParameterProperty(parameter, opts = {}) {
-		return {
-			type: "TSParameterProperty",
-			decorators: opts.decorators ?? [],
-			parameter,
-			override: opts.override ?? false,
-			readonly: opts.readonly ?? false,
-			accessibility: opts.accessibility ?? null,
-			static: false,
-			...span
-		};
-	},
-	tsAsExpression(expression, typeAnnotation) {
-		return {
-			type: "TSAsExpression",
-			expression,
-			typeAnnotation,
-			...span
-		};
-	},
-	tsSatisfiesExpression(expression, typeAnnotation) {
-		return {
-			type: "TSSatisfiesExpression",
-			expression,
-			typeAnnotation,
-			...span
-		};
-	},
-	tsTypeAssertion(typeAnnotation, expression) {
-		return {
-			type: "TSTypeAssertion",
-			typeAnnotation,
-			expression,
-			...span
-		};
-	},
-	tsNonNullExpression(expression) {
-		return {
-			type: "TSNonNullExpression",
-			expression,
-			...span
-		};
-	},
-	tsInstantiationExpression(expression, typeArguments) {
-		return {
-			type: "TSInstantiationExpression",
-			expression,
-			typeArguments,
-			...span
-		};
-	},
-	tsExportAssignment(expression) {
-		return {
-			type: "TSExportAssignment",
-			expression,
-			...span
-		};
-	},
-	tsNamespaceExportDeclaration(id) {
-		return {
-			type: "TSNamespaceExportDeclaration",
-			id,
-			...span
-		};
-	},
-	tsImportEqualsDeclaration(id, moduleReference, importKind = "value") {
-		return {
-			type: "TSImportEqualsDeclaration",
-			id,
-			moduleReference,
-			importKind,
-			...span
-		};
-	},
-	tsExternalModuleReference(expression) {
-		return {
-			type: "TSExternalModuleReference",
-			expression,
-			...span
-		};
-	},
-	tsDeclareFunction(id, params, opts = {}) {
-		return {
-			type: "TSDeclareFunction",
-			id,
-			generator: opts.generator ?? false,
-			async: opts.async ?? false,
-			params,
-			body: null,
-			expression: false,
-			declare: opts.declare ?? false,
-			typeParameters: opts.typeParameters ?? null,
-			returnType: opts.returnType ?? null,
-			...span
-		};
-	},
-	tsEmptyBodyFunctionExpression(params, opts = {}) {
-		return {
-			type: "TSEmptyBodyFunctionExpression",
-			id: opts.id ?? null,
-			generator: false,
-			async: false,
-			params,
-			body: null,
-			expression: false,
-			declare: false,
-			typeParameters: opts.typeParameters ?? null,
-			returnType: opts.returnType ?? null,
-			...span
-		};
-	},
-	hashbang(value) {
-		return {
-			type: "Hashbang",
-			value,
-			...span
-		};
-	},
-	program(body = [], opts = {}) {
-		return {
-			type: "Program",
-			sourceType: opts.sourceType ?? "module",
-			hashbang: opts.hashbang ?? null,
-			body,
-			...span
-		};
-	}
-};
-/**
-* Node types grouped under a shared alias. Membership is by node `type`, and
-* each group backs an alias guard such as `is.Expression` or `is.Function`.
-*/
+import { parse as parse$1 } from "yuku-parser";
+//#region ../../node_modules/.pnpm/yuku-ast@0.7.0/node_modules/yuku-ast/dist/index.js
 const ALIAS_GROUPS = {
 	Expression: [
 		"Identifier",
@@ -1525,42 +104,41 @@ const ALIAS_GROUPS = {
 	Function: [
 		"FunctionDeclaration",
 		"FunctionExpression",
-		"ArrowFunctionExpression",
 		"TSDeclareFunction",
-		"TSEmptyBodyFunctionExpression"
+		"TSEmptyBodyFunctionExpression",
+		"ArrowFunctionExpression"
 	],
 	Class: ["ClassDeclaration", "ClassExpression"],
 	Method: ["MethodDefinition", "TSAbstractMethodDefinition"],
 	Loop: [
-		"ForStatement",
+		"DoWhileStatement",
 		"ForInStatement",
 		"ForOfStatement",
-		"WhileStatement",
-		"DoWhileStatement"
+		"ForStatement",
+		"WhileStatement"
 	],
 	Pattern: [
-		"Identifier",
 		"ArrayPattern",
 		"ObjectPattern",
 		"AssignmentPattern",
 		"RestElement"
 	],
 	JSX: [
-		"JSXElement",
-		"JSXOpeningElement",
+		"JSXAttribute",
 		"JSXClosingElement",
-		"JSXFragment",
-		"JSXOpeningFragment",
 		"JSXClosingFragment",
+		"JSXElement",
+		"JSXEmptyExpression",
+		"JSXExpressionContainer",
+		"JSXFragment",
 		"JSXIdentifier",
-		"JSXNamespacedName",
 		"JSXMemberExpression",
-		"JSXAttribute",
+		"JSXNamespacedName",
+		"JSXOpeningElement",
+		"JSXOpeningFragment",
 		"JSXSpreadAttribute",
-		"JSXExpressionContainer",
-		"JSXEmptyExpression",
-		"JSXText",
-		"JSXSpreadChild"
+		"JSXSpreadChild",
+		"JSXText"
 	],
 	TSType: [
 		"TSAnyKeyword",
@@ -1602,48 +180,448 @@ const ALIAS_GROUPS = {
 		"TSMappedType"
 	]
 };
-/**
-* Every concrete node `type` in the AST. Drives the per-type guards in `is`.
-* The compile-time checks below keep it exhaustive: a node type added to or
-* removed from the parser fails to build until this list is brought in line.
-*/
-const NODE_TYPES = [
-	"Program",
-	"Hashbang",
-	"Identifier",
-	"PrivateIdentifier",
-	"Literal",
-	"TemplateElement",
-	"Super",
-	"ThisExpression",
-	"ArrayPattern",
-	"ObjectPattern",
-	"AssignmentPattern",
-	"RestElement",
-	"Property",
+Object.keys(ALIAS_GROUPS);
+const KEYS = Object.create(null);
+function ck(type, keys) {
+	const prev = KEYS[type];
+	if (prev === void 0) KEYS[type] = keys;
+	else for (const k of keys) if (!prev.includes(k)) prev.push(k);
+}
+ck("SequenceExpression", ["expressions"]);
+ck("ParenthesizedExpression", ["expression"]);
+ck("ArrowFunctionExpression", [
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+ck("FunctionDeclaration", [
+	"id",
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+ck("FunctionExpression", [
+	"id",
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+ck("TSDeclareFunction", [
+	"id",
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+ck("TSEmptyBodyFunctionExpression", [
+	"id",
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+ck("BlockStatement", ["body"]);
+ck("BlockStatement", ["body"]);
+ck("BinaryExpression", ["left", "right"]);
+ck("LogicalExpression", ["left", "right"]);
+ck("ConditionalExpression", [
+	"test",
+	"consequent",
+	"alternate"
+]);
+ck("UnaryExpression", ["argument"]);
+ck("UpdateExpression", ["argument"]);
+ck("AssignmentExpression", ["left", "right"]);
+ck("ArrayExpression", ["elements"]);
+ck("ObjectExpression", ["properties"]);
+ck("SpreadElement", ["argument"]);
+ck("Property", ["key", "value"]);
+ck("MemberExpression", ["object", "property"]);
+ck("CallExpression", [
+	"callee",
+	"typeArguments",
+	"arguments"
+]);
+ck("ChainExpression", ["expression"]);
+ck("TaggedTemplateExpression", [
+	"tag",
+	"typeArguments",
+	"quasi"
+]);
+ck("NewExpression", [
+	"callee",
+	"typeArguments",
+	"arguments"
+]);
+ck("AwaitExpression", ["argument"]);
+ck("YieldExpression", ["argument"]);
+ck("MetaProperty", ["meta", "property"]);
+ck("Decorator", ["expression"]);
+ck("ClassDeclaration", [
+	"decorators",
+	"id",
+	"typeParameters",
+	"superClass",
+	"superTypeArguments",
+	"implements",
+	"body"
+]);
+ck("ClassExpression", [
+	"decorators",
+	"id",
+	"typeParameters",
+	"superClass",
+	"superTypeArguments",
+	"implements",
+	"body"
+]);
+ck("ClassBody", ["body"]);
+ck("MethodDefinition", [
+	"decorators",
+	"key",
+	"value"
+]);
+ck("TSAbstractMethodDefinition", [
+	"decorators",
+	"key",
+	"value"
+]);
+ck("PropertyDefinition", [
+	"decorators",
+	"key",
+	"typeAnnotation",
+	"value"
+]);
+ck("AccessorProperty", [
+	"decorators",
+	"key",
+	"typeAnnotation",
+	"value"
+]);
+ck("TSAbstractPropertyDefinition", [
+	"decorators",
+	"key",
+	"typeAnnotation",
+	"value"
+]);
+ck("TSAbstractAccessorProperty", [
+	"decorators",
+	"key",
+	"typeAnnotation",
+	"value"
+]);
+ck("StaticBlock", ["body"]);
+ck("Super", []);
+ck("Literal", []);
+ck("Literal", []);
+ck("Literal", []);
+ck("Literal", []);
+ck("Literal", []);
+ck("ThisExpression", []);
+ck("Literal", []);
+ck("TemplateLiteral", ["quasis", "expressions"]);
+ck("TemplateElement", []);
+ck("Identifier", []);
+ck("PrivateIdentifier", []);
+ck("Identifier", ["decorators", "typeAnnotation"]);
+ck("Identifier", []);
+ck("Identifier", []);
+ck("ExpressionStatement", ["expression"]);
+ck("IfStatement", [
+	"test",
+	"consequent",
+	"alternate"
+]);
+ck("SwitchStatement", ["discriminant", "cases"]);
+ck("SwitchCase", ["test", "consequent"]);
+ck("ForStatement", [
+	"init",
+	"test",
+	"update",
+	"body"
+]);
+ck("ForInStatement", [
+	"left",
+	"right",
+	"body"
+]);
+ck("ForOfStatement", [
+	"left",
+	"right",
+	"body"
+]);
+ck("WhileStatement", ["test", "body"]);
+ck("DoWhileStatement", ["body", "test"]);
+ck("BreakStatement", ["label"]);
+ck("ContinueStatement", ["label"]);
+ck("LabeledStatement", ["label", "body"]);
+ck("WithStatement", ["object", "body"]);
+ck("ReturnStatement", ["argument"]);
+ck("ThrowStatement", ["argument"]);
+ck("TryStatement", [
+	"block",
+	"handler",
+	"finalizer"
+]);
+ck("CatchClause", ["param", "body"]);
+ck("DebuggerStatement", []);
+ck("EmptyStatement", []);
+ck("VariableDeclaration", ["declarations"]);
+ck("VariableDeclarator", ["id", "init"]);
+ck("ExpressionStatement", ["expression"]);
+ck("AssignmentPattern", [
+	"decorators",
+	"left",
+	"typeAnnotation",
+	"right"
+]);
+ck("RestElement", [
+	"decorators",
+	"argument",
+	"typeAnnotation"
+]);
+ck("ArrayPattern", [
+	"decorators",
+	"elements",
+	"typeAnnotation"
+]);
+ck("ObjectPattern", [
+	"decorators",
+	"properties",
+	"typeAnnotation"
+]);
+ck("Property", ["key", "value"]);
+ck("Program", ["hashbang", "body"]);
+ck("ImportExpression", ["source", "options"]);
+ck("ImportDeclaration", [
+	"specifiers",
+	"source",
+	"attributes"
+]);
+ck("ImportSpecifier", ["imported", "local"]);
+ck("ImportDefaultSpecifier", ["local"]);
+ck("ImportNamespaceSpecifier", ["local"]);
+ck("ImportAttribute", ["key", "value"]);
+ck("ExportNamedDeclaration", [
+	"declaration",
+	"specifiers",
+	"source",
+	"attributes"
+]);
+ck("ExportDefaultDeclaration", ["declaration"]);
+ck("ExportAllDeclaration", [
+	"exported",
+	"source",
+	"attributes"
+]);
+ck("ExportSpecifier", ["local", "exported"]);
+ck("TSTypeAnnotation", ["typeAnnotation"]);
+ck("TSAnyKeyword", []);
+ck("TSUnknownKeyword", []);
+ck("TSNeverKeyword", []);
+ck("TSVoidKeyword", []);
+ck("TSNullKeyword", []);
+ck("TSUndefinedKeyword", []);
+ck("TSStringKeyword", []);
+ck("TSNumberKeyword", []);
+ck("TSBigIntKeyword", []);
+ck("TSBooleanKeyword", []);
+ck("TSSymbolKeyword", []);
+ck("TSObjectKeyword", []);
+ck("TSIntrinsicKeyword", []);
+ck("TSThisType", []);
+ck("TSTypeReference", ["typeName", "typeArguments"]);
+ck("TSQualifiedName", ["left", "right"]);
+ck("TSTypeQuery", ["exprName", "typeArguments"]);
+ck("TSImportType", [
+	"source",
+	"options",
+	"qualifier",
+	"typeArguments"
+]);
+ck("TSTypeParameter", [
+	"name",
+	"constraint",
+	"default"
+]);
+ck("TSTypeParameterDeclaration", ["params"]);
+ck("TSTypeParameterInstantiation", ["params"]);
+ck("TSLiteralType", ["literal"]);
+ck("TSTemplateLiteralType", ["quasis", "types"]);
+ck("TSArrayType", ["elementType"]);
+ck("TSIndexedAccessType", ["objectType", "indexType"]);
+ck("TSTupleType", ["elementTypes"]);
+ck("TSNamedTupleMember", ["label", "elementType"]);
+ck("TSOptionalType", ["typeAnnotation"]);
+ck("TSRestType", ["typeAnnotation"]);
+ck("TSJSDocNullableType", ["typeAnnotation"]);
+ck("TSJSDocNonNullableType", ["typeAnnotation"]);
+ck("TSJSDocUnknownType", []);
+ck("TSUnionType", ["types"]);
+ck("TSIntersectionType", ["types"]);
+ck("TSConditionalType", [
+	"checkType",
+	"extendsType",
+	"trueType",
+	"falseType"
+]);
+ck("TSInferType", ["typeParameter"]);
+ck("TSTypeOperator", ["typeAnnotation"]);
+ck("TSParenthesizedType", ["typeAnnotation"]);
+ck("TSFunctionType", [
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+ck("TSConstructorType", [
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+ck("TSTypePredicate", ["parameterName", "typeAnnotation"]);
+ck("TSTypeLiteral", ["members"]);
+ck("TSMappedType", [
+	"key",
+	"constraint",
+	"nameType",
+	"typeAnnotation"
+]);
+ck("TSPropertySignature", ["key", "typeAnnotation"]);
+ck("TSMethodSignature", [
+	"key",
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+ck("TSCallSignatureDeclaration", [
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+ck("TSConstructSignatureDeclaration", [
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+ck("TSIndexSignature", ["parameters", "typeAnnotation"]);
+ck("TSTypeAliasDeclaration", [
+	"id",
+	"typeParameters",
+	"typeAnnotation"
+]);
+ck("TSInterfaceDeclaration", [
+	"id",
+	"typeParameters",
+	"extends",
+	"body"
+]);
+ck("TSInterfaceBody", ["body"]);
+ck("TSInterfaceHeritage", ["expression", "typeArguments"]);
+ck("TSClassImplements", ["expression", "typeArguments"]);
+ck("TSEnumDeclaration", ["id", "body"]);
+ck("TSEnumBody", ["members"]);
+ck("TSEnumMember", ["id", "initializer"]);
+ck("TSModuleDeclaration", ["id", "body"]);
+ck("TSModuleBlock", ["body"]);
+ck("TSModuleDeclaration", ["id", "body"]);
+ck("TSParameterProperty", ["decorators", "parameter"]);
+ck("Identifier", ["typeAnnotation"]);
+ck("TSAsExpression", ["expression", "typeAnnotation"]);
+ck("TSSatisfiesExpression", ["expression", "typeAnnotation"]);
+ck("TSTypeAssertion", ["typeAnnotation", "expression"]);
+ck("TSNonNullExpression", ["expression"]);
+ck("TSInstantiationExpression", ["expression", "typeArguments"]);
+ck("TSExportAssignment", ["expression"]);
+ck("TSNamespaceExportDeclaration", ["id"]);
+ck("TSImportEqualsDeclaration", ["id", "moduleReference"]);
+ck("TSExternalModuleReference", ["expression"]);
+ck("JSXElement", [
+	"openingElement",
+	"children",
+	"closingElement"
+]);
+ck("JSXOpeningElement", [
+	"name",
+	"typeArguments",
+	"attributes"
+]);
+ck("JSXClosingElement", ["name"]);
+ck("JSXFragment", [
+	"openingFragment",
+	"children",
+	"closingFragment"
+]);
+ck("JSXOpeningFragment", []);
+ck("JSXClosingFragment", []);
+ck("JSXIdentifier", []);
+ck("JSXNamespacedName", ["namespace", "name"]);
+ck("JSXMemberExpression", ["object", "property"]);
+ck("JSXAttribute", ["name", "value"]);
+ck("JSXSpreadAttribute", ["argument"]);
+ck("JSXExpressionContainer", ["expression"]);
+ck("JSXEmptyExpression", []);
+ck("JSXText", []);
+ck("JSXSpreadChild", ["expression"]);
+ck("Hashbang", []);
+const CHILD_KEYS = KEYS;
+const NODE_TYPES = [.../* @__PURE__ */ new Set([
 	"SequenceExpression",
 	"ParenthesizedExpression",
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"BlockStatement",
+	"BlockStatement",
 	"BinaryExpression",
 	"LogicalExpression",
 	"ConditionalExpression",
 	"UnaryExpression",
 	"UpdateExpression",
 	"AssignmentExpression",
-	"YieldExpression",
-	"AwaitExpression",
 	"ArrayExpression",
 	"ObjectExpression",
 	"SpreadElement",
+	"Property",
 	"MemberExpression",
 	"CallExpression",
 	"ChainExpression",
 	"TaggedTemplateExpression",
 	"NewExpression",
+	"AwaitExpression",
+	"YieldExpression",
 	"MetaProperty",
-	"ImportExpression",
+	"Decorator",
+	"ClassDeclaration",
+	"ClassExpression",
+	"ClassBody",
+	"MethodDefinition",
+	"TSAbstractMethodDefinition",
+	"PropertyDefinition",
+	"AccessorProperty",
+	"TSAbstractPropertyDefinition",
+	"TSAbstractAccessorProperty",
+	"StaticBlock",
+	"Super",
+	"Literal",
+	"Literal",
+	"Literal",
+	"Literal",
+	"Literal",
+	"ThisExpression",
+	"Literal",
 	"TemplateLiteral",
+	"TemplateElement",
+	"Identifier",
+	"PrivateIdentifier",
+	"Identifier",
+	"Identifier",
+	"Identifier",
 	"ExpressionStatement",
-	"BlockStatement",
 	"IfStatement",
 	"SwitchStatement",
 	"SwitchCase",
@@ -1664,22 +642,14 @@ const NODE_TYPES = [
 	"EmptyStatement",
 	"VariableDeclaration",
 	"VariableDeclarator",
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"TSDeclareFunction",
-	"TSEmptyBodyFunctionExpression",
-	"ArrowFunctionExpression",
-	"ClassDeclaration",
-	"ClassExpression",
-	"ClassBody",
-	"MethodDefinition",
-	"TSAbstractMethodDefinition",
-	"PropertyDefinition",
-	"TSAbstractPropertyDefinition",
-	"AccessorProperty",
-	"TSAbstractAccessorProperty",
-	"StaticBlock",
-	"Decorator",
+	"ExpressionStatement",
+	"AssignmentPattern",
+	"RestElement",
+	"ArrayPattern",
+	"ObjectPattern",
+	"Property",
+	"Program",
+	"ImportExpression",
 	"ImportDeclaration",
 	"ImportSpecifier",
 	"ImportDefaultSpecifier",
@@ -1689,21 +659,6 @@ const NODE_TYPES = [
 	"ExportDefaultDeclaration",
 	"ExportAllDeclaration",
 	"ExportSpecifier",
-	"JSXElement",
-	"JSXOpeningElement",
-	"JSXClosingElement",
-	"JSXFragment",
-	"JSXOpeningFragment",
-	"JSXClosingFragment",
-	"JSXIdentifier",
-	"JSXNamespacedName",
-	"JSXMemberExpression",
-	"JSXAttribute",
-	"JSXSpreadAttribute",
-	"JSXExpressionContainer",
-	"JSXEmptyExpression",
-	"JSXText",
-	"JSXSpreadChild",
 	"TSTypeAnnotation",
 	"TSAnyKeyword",
 	"TSUnknownKeyword",
@@ -1763,7 +718,9 @@ const NODE_TYPES = [
 	"TSEnumMember",
 	"TSModuleDeclaration",
 	"TSModuleBlock",
+	"TSModuleDeclaration",
 	"TSParameterProperty",
+	"Identifier",
 	"TSAsExpression",
 	"TSSatisfiesExpression",
 	"TSTypeAssertion",
@@ -1772,17 +729,150 @@ const NODE_TYPES = [
 	"TSExportAssignment",
 	"TSNamespaceExportDeclaration",
 	"TSImportEqualsDeclaration",
-	"TSExternalModuleReference"
-];
+	"TSExternalModuleReference",
+	"JSXElement",
+	"JSXOpeningElement",
+	"JSXClosingElement",
+	"JSXFragment",
+	"JSXOpeningFragment",
+	"JSXClosingFragment",
+	"JSXIdentifier",
+	"JSXNamespacedName",
+	"JSXMemberExpression",
+	"JSXAttribute",
+	"JSXSpreadAttribute",
+	"JSXExpressionContainer",
+	"JSXEmptyExpression",
+	"JSXText",
+	"JSXSpreadChild",
+	"Hashbang"
+])];
+/**
+* One constructor per node type, its fields derived from the node type
+* itself. `start` and `end` default to 0, which `ctx.replace` treats
+* as span-less and fills from the replaced node.
+*
+* @example
+* b.Identifier({ name: "x" })
+* b.ExpressionStatement({ expression: b.Identifier({ name: "x" }) })
+*/
+const b = Object.fromEntries(NODE_TYPES.map((type) => [type, (fields) => ({
+	type,
+	start: 0,
+	end: 0,
+	...fields
+})]));
+/**
+* The walk context: one reused object exposing the current position and
+* the tree mutation operations. Valid only during the visit that
+* receives it, do not store it. Underscore members are engine state.
+*/
+var WalkContext = class {
+	_ancestors = [];
+	_node = null;
+	_key = null;
+	_list = null;
+	_frame = null;
+	_skip = false;
+	_stopped = false;
+	_removed = false;
+	_replacement = null;
+	/** State threaded through the walk, the third `walk` argument. */
+	state;
+	/** The node being visited. */
+	get node() {
+		return this._node;
+	}
+	/** The node holding {@link node}, or null at the walk root. */
+	get parent() {
+		const a = this._ancestors;
+		return a.length === 0 ? null : a[a.length - 1];
+	}
+	/** The field on {@link parent} holding {@link node}, or null at the root. */
+	get key() {
+		return this._key;
+	}
+	/** Index within an array field, or null in a plain field. */
+	get index() {
+		return this._list === null ? null : this._frame.i;
+	}
+	/** Ancestors from the walk root down to {@link parent}. */
+	ancestors() {
+		return [...this._ancestors];
+	}
+	/** Do not descend into the current node's children. */
+	skip() {
+		this._skip = true;
+	}
+	/** Stop the walk entirely. */
+	stop() {
+		this._stopped = true;
+	}
+	/**
+	* Replace the current node. The walk continues into the replacement's
+	* children and `leave` fires for the replacement's type. A synthetic
+	* node with `start === 0 && end === 0` inherits the original span,
+	* for source maps. Throws at the walk root.
+	*/
+	replace(node) {
+		if (node === null || typeof node !== "object" || typeof node.type !== "string") throw new TypeError("replace: expected an AST node");
+		if (this.parent === null) throw new TypeError("replace: cannot replace the walk root");
+		if (node.start === 0 && node.end === 0) {
+			node.start = this.node.start;
+			node.end = this.node.end;
+		}
+		this._replacement = node;
+	}
+	/**
+	* Remove the current node from its parent: spliced from array fields,
+	* nulled in plain fields. Children are not walked and `leave` does
+	* not fire. Throws at the walk root.
+	*/
+	remove() {
+		if (this.parent === null) throw new TypeError("remove: cannot remove the walk root");
+		this._removed = true;
+	}
+	/** Insert a sibling before the current node, not visited. Array fields only. */
+	insertBefore(node) {
+		this.#insert(node, 0);
+		this._frame.i++;
+	}
+	/** Insert a sibling after the current node, visited by the walk. Array fields only. */
+	insertAfter(node) {
+		this.#insert(node, 1);
+	}
+	#insert(node, offset) {
+		if (this._list === null) throw new TypeError("insertBefore/insertAfter require a node in an array field");
+		this._list.splice(this._frame.i + offset, 0, node);
+	}
+};
+const IDENTIFIER_NAME = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+/**
+* True if `name` is a valid ECMAScript `IdentifierName`, the grammar an
+* identifier token must satisfy. Validates a raw string, not a node.
+* Reserved words are syntactically identifier names, so
+* `isIdentifierName("class")` is true, see {@link isValidIdentifier}.
+*/
+function isIdentifierName(name) {
+	return IDENTIFIER_NAME.test(name);
+}
 function aliasGuard(name) {
 	const set = new Set(ALIAS_GROUPS[name]);
 	return (node) => node != null && set.has(node.type);
 }
+/**
+* Type guards, one per concrete node `type` plus alias and shape
+* guards. Every guard accepts `null` and `undefined` and narrows.
+*
+* @example
+* is.CallExpression(node)
+* is.Identifier(node, "require")
+* is.Expression(node)
+* is.StringLiteral(node)
+*/
 const is = {
 	...Object.fromEntries(NODE_TYPES.map((type) => [type, (node) => node != null && node.type === type])),
-	/** True when `node`'s `type` is one of `types`, narrowing to that union. */
-	oneOf: (node, types) => node != null && types.includes(node.type),
-	/** An `Identifier`, optionally with the exact `name` (e.g. `is.Identifier(node, "this")`). */
+	oneOf: (node, types) => node != null && types.some((type) => type === node.type),
 	Identifier: (node, name) => node?.type === "Identifier" && (name === void 0 || node.name === name),
 	Expression: aliasGuard("Expression"),
 	Statement: aliasGuard("Statement"),
@@ -1806,38 +896,195 @@ const is = {
 	PrivateFieldExpression: (node) => node?.type === "MemberExpression" && node.property.type === "PrivateIdentifier",
 	Directive: (node) => node?.type === "ExpressionStatement" && node.directive != null
 };
-//#endregion
-//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/identifier.mjs
-const IDENTIFIER_NAME = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+function createDispatch(visitors) {
+	let enter = null;
+	let leave = null;
+	const concrete$1 = /* @__PURE__ */ new Map();
+	const add = (type, handler) => {
+		const hooks = typeof handler === "function" ? { enter: handler } : handler;
+		let entry = concrete$1.get(type);
+		if (entry === void 0) {
+			entry = {
+				enter: [],
+				leave: []
+			};
+			concrete$1.set(type, entry);
+		}
+		if (hooks.enter) entry.enter.push(hooks.enter);
+		if (hooks.leave) entry.leave.unshift(hooks.leave);
+	};
+	for (const [name, value] of Object.entries(visitors)) {
+		if (value == null) continue;
+		if (name === "enter") enter = value;
+		else if (name === "leave") leave = value;
+		else if (name in ALIAS_GROUPS) for (const type of ALIAS_GROUPS[name]) add(type, value);
+	}
+	for (const [name, value] of Object.entries(visitors)) {
+		if (value == null || name === "enter" || name === "leave" || name in ALIAS_GROUPS) continue;
+		add(name, value);
+	}
+	return {
+		enter,
+		leave,
+		typed: (type) => concrete$1.get(type)
+	};
+}
 /**
-* Returns `true` if `name` is a valid ECMAScript `IdentifierName`: the grammar
-* an identifier token must satisfy. Validates a raw string, not an AST node.
-*
-* @example
-* isIdentifierName("foo");     // true
-* isIdentifierName("$_0");     // true
-* isIdentifierName("π");       // true
-* isIdentifierName("class");   // true  - syntactically an IdentifierName
-* isIdentifierName("1foo");    // false - starts with a digit
-* isIdentifierName("foo-bar"); // false - `-` is not an identifier character
-* isIdentifierName("");        // false
+* Walk an AST depth-first, dispatching to typed visitors and mutating
+* in place. Traversal order is driven by tables generated from the
+* parser's AST definition, so it can never drift. Returns the root.
 */
-function isIdentifierName(name) {
-	return IDENTIFIER_NAME.test(name);
+function walk(root, visitors, state) {
+	_walk(root, visitors, state, new WalkContext());
+	return root;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/yuku-ast@0.1.7/node_modules/yuku-ast/dist/utils.mjs
 /**
-* The static name a node denotes: an `Identifier`'s `name`, or a string
-* `Literal`'s `value`. Returns `null` for anything else, and for `null` or
-* `undefined`, so the common `Identifier | StringLiteral` name slots (a
-* `ModuleExportName`, or a static property or member key) read in one call.
-*
-* @example
-* nameOf(b.identifier("x")) // "x"
-* nameOf(b.stringLiteral("y")) // "y"
-* nameOf(b.numericLiteral(1)) // null
+* The async counterpart of {@link walk}: identical traversal order and
+* mutation semantics, with every handler awaited before the walk moves
+* on. Resolves to the root.
 */
+async function walkAsync(root, visitors, state) {
+	await _walkAsync(root, visitors, state, new WalkContext());
+	return root;
+}
+function position(ctx, node, key, list, frame) {
+	ctx._node = node;
+	ctx._key = key;
+	ctx._list = list;
+	ctx._frame = frame;
+}
+function applyReplace(ctx, parent, key, list, frame) {
+	const next = ctx._replacement;
+	ctx._replacement = null;
+	if (list !== null) list[frame.i] = next;
+	else parent[key] = next;
+	return next;
+}
+function applyRemove(ctx, parent, key, list, frame) {
+	ctx._removed = false;
+	if (list !== null) {
+		list.splice(frame.i, 1);
+		frame.i--;
+	} else parent[key] = null;
+}
+function _walk(root, visitors, state, ctx) {
+	const d = createDispatch(visitors);
+	ctx.state = state;
+	const ancestors = ctx._ancestors;
+	(function visit(node, key, list, frame) {
+		let typed = d.typed(node.type);
+		const parent = ctx.parent;
+		position(ctx, node, key, list, frame);
+		if (d.enter !== null) {
+			d.enter(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (typed !== void 0) for (const handler of typed.enter) {
+			handler(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (ctx._removed) {
+			applyRemove(ctx, parent, key, list, frame);
+			return true;
+		}
+		if (ctx._replacement !== null) {
+			node = applyReplace(ctx, parent, key, list, frame);
+			typed = d.typed(node.type);
+		}
+		const skipped = ctx._skip;
+		ctx._skip = false;
+		if (!skipped) {
+			const keys = CHILD_KEYS[node.type];
+			if (keys !== void 0 && keys.length > 0) {
+				ancestors.push(node);
+				for (let k = 0; k < keys.length; k++) {
+					const key2 = keys[k];
+					const value = node[key2];
+					if (value === null || value === void 0 || typeof value !== "object") continue;
+					if (Array.isArray(value)) {
+						const childFrame = { i: 0 };
+						for (; childFrame.i < value.length; childFrame.i++) {
+							const item = value[childFrame.i];
+							if (item !== null && !visit(item, key2, value, childFrame)) return false;
+						}
+					} else if (!visit(value, key2, null, null)) return false;
+				}
+				ancestors.pop();
+			}
+		}
+		position(ctx, node, key, list, frame);
+		if (typed !== void 0) for (const handler of typed.leave) {
+			handler(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (d.leave !== null) {
+			d.leave(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (ctx._removed) applyRemove(ctx, parent, key, list, frame);
+		else if (ctx._replacement !== null) applyReplace(ctx, parent, key, list, frame);
+		return true;
+	})(root, null, null, null);
+}
+async function _walkAsync(root, visitors, state, ctx) {
+	const d = createDispatch(visitors);
+	ctx.state = state;
+	const ancestors = ctx._ancestors;
+	await (async function visit(node, key, list, frame) {
+		let typed = d.typed(node.type);
+		const parent = ctx.parent;
+		position(ctx, node, key, list, frame);
+		if (d.enter !== null) {
+			await d.enter(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (typed !== void 0) for (const handler of typed.enter) {
+			await handler(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (ctx._removed) {
+			applyRemove(ctx, parent, key, list, frame);
+			return true;
+		}
+		if (ctx._replacement !== null) {
+			node = applyReplace(ctx, parent, key, list, frame);
+			typed = d.typed(node.type);
+		}
+		const skipped = ctx._skip;
+		ctx._skip = false;
+		if (!skipped) {
+			const keys = CHILD_KEYS[node.type];
+			if (keys !== void 0 && keys.length > 0) {
+				ancestors.push(node);
+				for (let k = 0; k < keys.length; k++) {
+					const key2 = keys[k];
+					const value = node[key2];
+					if (value === null || value === void 0 || typeof value !== "object") continue;
+					if (Array.isArray(value)) {
+						const childFrame = { i: 0 };
+						for (; childFrame.i < value.length; childFrame.i++) {
+							const item = value[childFrame.i];
+							if (item !== null && !await visit(item, key2, value, childFrame)) return false;
+						}
+					} else if (!await visit(value, key2, null, null)) return false;
+				}
+				ancestors.pop();
+			}
+		}
+		position(ctx, node, key, list, frame);
+		if (typed !== void 0) for (const handler of typed.leave) {
+			await handler(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (d.leave !== null) {
+			await d.leave(node, ctx);
+			if (ctx._stopped) return false;
+		}
+		if (ctx._removed) applyRemove(ctx, parent, key, list, frame);
+		else if (ctx._replacement !== null) applyReplace(ctx, parent, key, list, frame);
+		return true;
+	})(root, null, null, null);
+}
 function nameOf(node) {
 	if (node == null) return null;
 	if (node.type === "Identifier") return node.name;
@@ -1957,7 +1204,7 @@ function ensureValue(value) {
 	return value && ALLOW_EXTENSIONS.has(extname(value)) ? value.replaceAll("\\", "/") : null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.27.9_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolver_9f43f644337e3a4030148b21b794fdcf/node_modules/rolldown-plugin-dts/dist/index.mjs
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.27.12_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolve_d94a4da753642eee691447f5bf042e95/node_modules/rolldown-plugin-dts/dist/index.mjs
 function createDtsInputPlugin({ sideEffects }) {
 	return {
 		name: "rolldown-plugin-dts:dts-input",
@@ -1990,1056 +1237,1218 @@ function createDtsInputPlugin({ sideEffects }) {
 		}
 	};
 }
-function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
-	let declarationIdx = 0;
-	const declarationMap = /* @__PURE__ */ new Map();
-	const commentsMap = /* @__PURE__ */ new Map();
-	const moduleExportsMap = /* @__PURE__ */ new Map();
-	const warnedCjsDtsInputs = /* @__PURE__ */ new Set();
+const require$1 = createRequire(import.meta.url);
+const debug$5 = createDebug("rolldown-plugin-dts:tsgo");
+function isTS70Installed() {
+	try {
+		const { versionMajorMinor } = require$1("typescript");
+		return versionMajorMinor === "7.0";
+	} catch {}
+	return false;
+}
+const spawnAsync = (...args) => new Promise((resolve, reject) => {
+	const child = spawn(...args);
+	child.on("close", () => resolve());
+	child.on("error", (error) => reject(error));
+});
+let tsgoPathCache;
+async function getTsgoPathFromNodeModules(logger) {
+	if (tsgoPathCache) return tsgoPathCache;
+	const pkgName = isTS70Installed() ? "typescript" : "@typescript/native-preview";
+	const tsgoPkg = import.meta.resolve(`${pkgName}/package.json`);
+	const { default: { version } } = await import(tsgoPkg, { with: { type: "json" } });
+	logger.info(`Emit types with ${styleText("underline", `${pkgName}@${version}`)}`);
+	const { default: getExePath } = await import(new URL("lib/getExePath.js", tsgoPkg).href);
+	return tsgoPathCache = getExePath();
+}
+async function runTsgo(logger, rootDir, tsconfig, sourcemap, tsgoPath) {
+	debug$5("[tsgo] rootDir", rootDir);
+	let tsgo;
+	if (tsgoPath) {
+		tsgo = tsgoPath;
+		debug$5("[tsgo] using custom path", tsgo);
+	} else {
+		tsgo = await getTsgoPathFromNodeModules(logger);
+		debug$5("[tsgo] using tsgo from node_modules", tsgo);
+	}
+	const tsgoDist = await mkdtemp(path.join(tmpdir(), "rolldown-plugin-dts-"));
+	debug$5("[tsgo] tsgoDist", tsgoDist);
+	const args = [
+		"--noEmit",
+		"false",
+		"--declaration",
+		"--emitDeclarationOnly",
+		"-p",
+		tsconfig,
+		"--outDir",
+		tsgoDist,
+		"--rootDir",
+		rootDir,
+		"--noCheck",
+		...sourcemap ? ["--declarationMap"] : []
+	];
+	debug$5("[tsgo] args %o", args);
+	await spawnAsync(tsgo, args, { stdio: "inherit" });
+	return {
+		path: tsgoDist,
+		async dispose() {
+			if (debug$5.enabled) debug$5("[tsgo] skip cleanup of tsgoDist", tsgoDist);
+			else {
+				debug$5("[tsgo] disposing tsgoDist", tsgoDist);
+				await rm(tsgoDist, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+			}
+		}
+	};
+}
+const debug$4 = createDebug("rolldown-plugin-dts:generate");
+const WORKER_URL = "./tsc-worker.mjs";
+const EMPTY_STUB = `export {}`;
+function createGeneratePlugin({ generator, entry, tsconfig, tsconfigRaw, build, incremental, cwd, oxc, emitDtsOnly, volarContext, parallel, eager, tsgo, newContext, emitJs, sourcemap, logger }) {
+	const entryIncludes = entry?.filter((p) => p[0] !== "!");
+	const entryIgnores = entry?.filter((p) => p[0] === "!").map((p) => p.slice(1));
+	const entryMatcher = entry ? (file) => entryIncludes.some((p) => path.matchesGlob(file, p)) && !entryIgnores.some((p) => path.matchesGlob(file, p)) : void 0;
+	const dtsMap = /* @__PURE__ */ new Map();
+	/**
+	* A map of input id to output file name
+	*
+	* @example
+	*
+	* inputAlias = new Map([
+	*   ['/absolute/path/to/src/source_file.ts', 'dist/foo/index'],
+	* ])
+	*/
+	const inputAliasMap = /* @__PURE__ */ new Map();
+	let tscWorker;
+	let tscModule;
+	let tscContext;
+	let tsgoContext;
+	const rootDir = tsconfig ? path.dirname(tsconfig) : cwd;
 	return {
-		name: "rolldown-plugin-dts:fake-js",
+		name: "rolldown-plugin-dts:generate",
+		async buildStart(options) {
+			if (generator === "tsgo") tsgoContext = await runTsgo(logger, rootDir, tsconfig, sourcemap, tsgo.path);
+			else if (generator === "tsc") if (parallel) tscWorker = createTscWorker();
+			else {
+				tscModule = await import("./tsc-zcbB6ZVY.js");
+				if (newContext) tscContext = createContext();
+			}
+			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
+				debug$4("resolving input alias %s -> %s", name, id);
+				let resolved = await this.resolve(id);
+				if (!id.startsWith("./")) resolved ||= await this.resolve(`./${id}`);
+				const resolvedId = resolved?.id || id;
+				debug$4("resolved input alias %s -> %s", id, resolvedId);
+				inputAliasMap.set(resolvedId, name);
+			}
+		},
 		outputOptions(options) {
-			if (options.format === "cjs" || options.format === "commonjs") throw new Error("[rolldown-plugin-dts] Cannot bundle dts files with `cjs` format.");
-			const { chunkFileNames, entryFileNames } = options;
 			return {
 				...options,
-				sourcemap: options.sourcemap || sourcemap,
-				chunkFileNames(chunk) {
-					const nameTemplate = resolveTemplateFn(chunk.isEntry ? entryFileNames || "[name].js" : chunkFileNames || "[name]-[hash].js", chunk);
+				entryFileNames(chunk) {
+					const { entryFileNames } = options;
+					const nameTemplate = resolveTemplateFn(entryFileNames || "[name].js", chunk);
 					if (chunk.name.endsWith(".d")) {
-						const renderedNameWithoutD = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name.slice(0, -2)));
-						if (RE_DTS.test(renderedNameWithoutD)) return renderedNameWithoutD;
-						const renderedName = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name));
-						if (RE_DTS.test(renderedName)) return renderedName;
+						if (RE_DTS.test(nameTemplate)) return replaceTemplateName(nameTemplate, chunk.name.slice(0, -2));
+						if (RE_JS.test(nameTemplate)) return nameTemplate.replace(RE_JS, ".$1ts");
 					}
 					return nameTemplate;
 				}
 			};
 		},
-		transform: {
-			filter: { id: RE_DTS },
-			handler: transform
-		},
-		renderChunk,
-		generateBundle(options, bundle) {
-			for (const chunk of Object.values(bundle)) {
-				if (!RE_DTS_MAP.test(chunk.fileName)) continue;
-				if (sourcemap) {
-					if (chunk.type === "chunk" || typeof chunk.source !== "string") continue;
-					const map = JSON.parse(chunk.source);
-					map.sourcesContent = void 0;
-					chunk.source = JSON.stringify(map);
-				} else delete bundle[chunk.fileName];
-			}
-		}
-	};
-	async function transform(code, id) {
-		let file;
-		try {
-			file = parse$1(code, {
-				lang: "dts",
-				sourceType: "module",
-				attachComments: true
-			});
-		} catch (error) {
-			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
-		}
-		const { program } = file;
-		moduleExportsMap.set(id, await collectModuleExports(this, program.body, id));
-		const identifierMap = Object.create(null);
-		if (!warnedCjsDtsInputs.has(id) && program.body.some(isCjsDtsInputSyntax)) {
-			warnedCjsDtsInputs.add(id);
-			this.warn(`${id} uses CommonJS dts syntax. ${RE_NODE_MODULES.test(id) ? `CommonJS dts modules cannot be bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `rolldown-plugin-dts does not support bundling CommonJS dts input.`}`);
-		}
-		const directives = collectReferenceDirectives(file.comments);
-		if (directives.length) commentsMap.set(id, directives);
-		const appendStmts = [];
-		const namespaceStmts = /* @__PURE__ */ new Map();
-		for (const [i, stmt] of program.body.entries()) {
-			const setStmt = (stmt) => program.body[i] = stmt;
-			if (rewriteImportExport(stmt, setStmt)) continue;
-			const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
-			if (sideEffect && stmt.type === "TSModuleDeclaration" && is.StringLiteral(stmt.id) && stmt.id.value[0] === ".") this.warn(`\`declare module ${JSON.stringify(stmt.id.value)}\` will be kept as-is in the output. Relative module declaration may cause unexpected issues. Found in ${id}.`);
-			if (sideEffect && id.endsWith(".vue.d.ts") && code.slice(stmt.start, stmt.end).includes("__VLS_")) continue;
-			const isDefaultExport = stmt.type === "ExportDefaultDeclaration";
-			const isExportDecl = is.oneOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && !!stmt.declaration;
-			const decl = isExportDecl ? stmt.declaration : stmt;
-			const setDecl = isExportDecl ? (decl) => stmt.declaration = decl : setStmt;
-			if (decl.type !== "TSDeclareFunction" && !is.Declaration(decl)) continue;
-			if (is.oneOf(decl, [
-				"TSEnumDeclaration",
-				"ClassDeclaration",
-				"FunctionDeclaration",
-				"TSDeclareFunction",
-				"TSModuleDeclaration",
-				"VariableDeclaration"
-			])) decl.declare = true;
-			const bindings = [];
-			if (decl.type === "VariableDeclaration") bindings.push(...decl.declarations.map((decl) => decl.id));
-			else if ("id" in decl && decl.id) {
-				let binding = decl.id;
-				if (binding.type === "TSQualifiedName") binding = getIdFromTSEntityName(binding);
-				if (sideEffect) binding = b.identifier(`_${getIdentifierIndex(identifierMap, "")}`);
-				if (binding.type !== "Identifier") throw new Error(`Unexpected ${binding.type} declaration id`);
-				bindings.push(binding);
-			} else {
-				const binding = b.identifier("export_default");
-				bindings.push(binding);
-				decl.id = binding;
-			}
-			const params = collectParams(decl);
-			const childrenSet = /* @__PURE__ */ new Set();
-			const deps = await collectDependencies(this, decl, id, namespaceStmts, childrenSet, identifierMap);
-			const children = Array.from(childrenSet).filter((child) => bindings.every((b) => child !== b));
-			if (decl !== stmt) decl.comments = stmt.comments;
-			const declarationId = registerDeclaration({
-				decl,
-				deps,
-				bindings,
-				params,
-				children
-			});
-			const declarationIdNode = b.numericLiteral(declarationId);
-			const depsBody = b.arrayExpression(deps);
-			const depsNode = b.arrowFunctionExpression(params.map(({ name }) => b.identifier(name)), depsBody);
-			const childrenNode = b.arrayExpression(children.map((node) => {
-				const placeholder = b.stringLiteral("");
-				placeholder.start = node.start;
-				placeholder.end = node.end;
-				return placeholder;
-			}));
-			const sideEffectNode = sideEffect && b.callExpression(b.identifier("sideEffect"), [bindings[0]]);
-			const runtimeArrayNode = runtimeBindingArrayExpression([
-				declarationIdNode,
-				depsNode,
-				childrenNode,
-				...sideEffectNode ? [sideEffectNode] : []
-			]);
-			const runtimeAssignment = b.variableDeclaration("var", [b.variableDeclarator(b.arrayPattern(bindings.map((binding) => ({
-				...binding,
-				typeAnnotation: null
-			}))), runtimeArrayNode)]);
-			if (isDefaultExport) {
-				appendStmts.push(b.exportNamedDeclaration(null, [b.exportSpecifier(bindings[0], b.identifier("default"))]));
-				setStmt(runtimeAssignment);
-			} else setDecl(runtimeAssignment);
-		}
-		if (sideEffects) appendStmts.push(b.expressionStatement(b.callExpression(b.identifier("sideEffect"), [])));
-		program.body = [
-			...Array.from(namespaceStmts.values()).map(({ stmt }) => stmt),
-			...program.body,
-			...appendStmts
-		];
-		const result = print(program, {
-			comments: false,
-			...sourcemap && { sourceMaps: {
-				source: code,
-				sourceFileName: id
-			} }
-		});
-		return {
-			code: result.code,
-			map: result.map ?? null
-		};
-	}
-	function renderChunk(code, chunk) {
-		if (!RE_DTS.test(chunk.fileName)) return;
-		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
-		let file;
-		try {
-			file = parse$1(code, {
-				lang: "ts",
-				sourceType: "module",
-				attachComments: true
-			});
-		} catch (error) {
-			throw new Error(`Failed to parse generated code for chunk ${chunk.fileName}. This may be caused by a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
-		}
-		const { program } = file;
-		program.body = patchTsNamespace(program.body);
-		program.body = patchReExport(program.body);
-		program.body = program.body.map((node) => {
-			if (isHelperImport(node)) return null;
-			if (node.type === "ExpressionStatement") return null;
-			const newNode = patchImportExport(node, exportInfo, cjsDefault);
-			if (newNode || newNode === false) return newNode;
-			if (node.type !== "VariableDeclaration") return node;
-			if (!isRuntimeBindingVariableDeclaration(node)) return null;
-			const decl = node.declarations[0];
-			const [declarationIdNode, depsFn, children] = decl.init.elements;
-			const declarationId = declarationIdNode.value;
-			const declaration = getDeclaration(declarationId);
-			if (sourcemap) walk(declaration.decl, { enter(node) {
-				node.start = void 0;
-				node.end = void 0;
-			} });
-			for (const [i, id] of decl.id.elements.entries()) {
-				const transformedBinding = {
-					...id,
-					typeAnnotation: declaration.bindings[i].typeAnnotation
-				};
-				overwriteNode(declaration.bindings[i], transformedBinding);
-			}
-			if (sourcemap) for (const [i, child] of children.elements.entries()) Object.assign(declaration.children[i], {
-				start: child.start,
-				end: child.end
-			});
-			const transformedParams = depsFn.params;
-			for (const [i, transformedParam] of transformedParams.entries()) {
-				const transformedName = transformedParam.name;
-				for (const originalTypeParam of declaration.params[i].typeParams) originalTypeParam.name = transformedName;
+		resolveId(id) {
+			if (dtsMap.has(id)) {
+				debug$4("resolve dts id %s", id);
+				return { id };
 			}
-			const transformedDeps = depsFn.body.elements;
-			for (const [i, originalDep] of declaration.deps.entries()) {
-				let transformedDep = transformedDeps[i];
-				if (transformedDep.type === "UnaryExpression" && transformedDep.operator === "void") {
-					const undefinedDep = b.identifier("undefined");
-					undefinedDep.start = transformedDep.start;
-					undefinedDep.end = transformedDep.end;
-					transformedDep = undefinedDep;
-				} else if (isInfer(transformedDep)) transformedDep.name = "__Infer";
-				if (originalDep.replace) originalDep.replace(transformedDep);
-				else Object.assign(originalDep, transformedDep);
+		},
+		transform: {
+			order: "pre",
+			filter: { id: {
+				include: [
+					RE_JS,
+					RE_TS,
+					RE_JSON,
+					...volarContext.patterns
+				],
+				exclude: [
+					RE_DTS,
+					RE_NODE_MODULES,
+					RE_ROLLDOWN_RUNTIME
+				]
+			} },
+			handler(code, id) {
+				const jsFile = RE_JS.test(id);
+				if (!jsFile || emitJs) {
+					const mod = this.getModuleInfo(id);
+					const isEntry = entryMatcher ? entryMatcher(path.relative(cwd, id)) : !!mod?.isEntry;
+					const dtsId = filename_to_dts(id, volarContext);
+					dtsMap.set(dtsId, {
+						code,
+						id,
+						isEntry,
+						jsFile
+					});
+					debug$4("register dts source: %s", id);
+					if (isEntry) {
+						const name = inputAliasMap.get(id);
+						this.emitFile({
+							type: "chunk",
+							id: dtsId,
+							name: name ? `${name}.d` : void 0
+						});
+					}
+				}
+				if (emitDtsOnly) {
+					if (RE_JSON.test(id)) return "{}";
+					return EMPTY_STUB;
+				}
 			}
-			return inheritNodeComments(node, declaration.decl);
-		}).filter((node) => !!node);
-		if (program.body.length === 0) return {
-			code: "export { };",
-			map: null
-		};
-		const comments = /* @__PURE__ */ new Set();
-		const commentsValue = /* @__PURE__ */ new Set();
-		for (const id of chunk.moduleIds) {
-			const preserveComments = commentsMap.get(id);
-			if (preserveComments) {
-				preserveComments.forEach((c) => {
-					const id = c.type + c.value;
-					if (commentsValue.has(id)) return;
-					commentsValue.add(id);
-					comments.add(c);
-				});
-				commentsMap.delete(id);
+		},
+		load: {
+			filter: { id: {
+				include: [RE_DTS],
+				exclude: [RE_NODE_MODULES]
+			} },
+			async handler(dtsId) {
+				const module = dtsMap.get(dtsId);
+				if (!module) return;
+				const { code, id, jsFile } = module;
+				if (jsFile && await access(dtsId).then(() => true).catch(() => false)) {
+					debug$4("dts file already exists for %s, skipping generation", id);
+					return;
+				}
+				let dtsCode;
+				let map;
+				debug$4("generate dts %s from %s", dtsId, id);
+				if (generator === "tsgo") {
+					if (volarContext.isVolarFile(id)) throw new Error(`tsgo does not support .${path.extname(id)} file.`);
+					const dtsPath = path.resolve(tsgoContext.path, path.relative(path.resolve(rootDir), filename_to_dts(id, volarContext)));
+					if (!existsSync(dtsPath)) {
+						debug$4("[tsgo]", dtsPath, "is missing");
+						throw new Error(`tsgo did not generate dts file for ${id}, please check your tsconfig.`);
+					}
+					dtsCode = await readFile(dtsPath, "utf8");
+					const mapPath = `${dtsPath}.map`;
+					if (existsSync(mapPath)) {
+						const mapRaw = await readFile(mapPath, "utf8");
+						map = {
+							...JSON.parse(mapRaw),
+							sources: [id]
+						};
+					}
+				} else if (generator === "oxc" && !volarContext.isVolarFile(id)) {
+					const result = isolatedDeclarationSync(id, code, oxc);
+					if (result.errors.length) {
+						const [error] = result.errors;
+						return this.error({
+							message: error.message,
+							frame: error.codeframe || void 0
+						});
+					}
+					dtsCode = result.code;
+					if (result.map) {
+						map = result.map;
+						map.sourcesContent = void 0;
+					}
+				} else {
+					const options = {
+						tsconfig,
+						tsconfigRaw,
+						build,
+						incremental,
+						cwd,
+						entries: eager ? void 0 : Array.from(dtsMap.values()).filter((v) => v.isEntry).map((v) => v.id),
+						id,
+						sourcemap,
+						volarContext,
+						context: tscContext
+					};
+					let result;
+					if (parallel) result = await tscWorker.emit(options);
+					else result = tscModule.tscEmit(options);
+					if (result.error) return this.error(result.error);
+					dtsCode = result.code;
+					map = result.map;
+					if (dtsCode && RE_JSON.test(id)) if (dtsCode.includes("declare const _exports")) {
+						if (dtsCode.includes("declare const _exports: {") && !dtsCode.includes("\n}[];")) {
+							const exports = collectJsonExports(dtsCode);
+							let i = 0;
+							dtsCode += exports.map((e) => {
+								const valid = `_${e.replaceAll(/[^\w$]/g, "_")}${i++}`;
+								const jsonKey = JSON.stringify(e);
+								return `declare let ${valid}: typeof _exports[${jsonKey}]\nexport { ${valid} as ${jsonKey} }`;
+							}).join("\n");
+						}
+					} else {
+						const exportMap = collectJsonExportMap(dtsCode);
+						dtsCode += `
+declare namespace __json_default_export {
+  export { ${Array.from(exportMap.entries()).map(([exported, local]) => exported === local ? exported : `${local} as ${exported}`).join(", ")} }
+}
+export { __json_default_export as default }`;
+					}
+				}
+				return {
+					code: dtsCode || "",
+					map
+				};
 			}
+		},
+		generateBundle: emitDtsOnly ? (options, bundle) => {
+			for (const fileName of Object.keys(bundle)) if (bundle[fileName].type === "chunk" && !RE_DTS.test(fileName) && !RE_DTS_MAP.test(fileName)) delete bundle[fileName];
+		} : void 0,
+		async buildEnd() {
+			tscWorker?.kill();
+			tscWorker = void 0;
+			await tsgoContext?.dispose();
+			tsgoContext = void 0;
+			if (newContext) tscContext = void 0;
+		},
+		watchChange(id) {
+			if (tscModule) invalidateContextFile(tscContext || globalContext, id);
 		}
-		if (comments.size) {
-			program.body[0].comments ||= [];
-			program.body[0].comments.unshift(...Array.from(comments, (c) => ({
-				type: c.type,
-				value: c.value,
-				position: "before",
-				sameLine: false
-			})));
-		}
-		const result = print(program, {
-			comments: true,
-			...sourcemap && { sourceMaps: {
-				source: code,
-				sourceFileName: chunk.fileName
-			} }
-		});
-		return {
-			code: result.code,
-			map: result.map ?? null
-		};
-	}
-	function registerDeclaration(info) {
-		const declarationId = declarationIdx++;
-		declarationMap.set(declarationId, info);
-		return declarationId;
-	}
-	function getDeclaration(declarationId) {
-		return declarationMap.get(declarationId);
-	}
-}
-async function collectModuleExports(context, nodes, id) {
-	const info = {
-		typeOnlyLocals: /* @__PURE__ */ new Set(),
-		exports: /* @__PURE__ */ new Map(),
-		reExports: [],
-		exportAlls: []
 	};
-	for (const node of nodes) collectTypeOnlyLocals(node, info.typeOnlyLocals);
-	for (const node of nodes) await collectExportInfo(context, node, id, info);
-	return info;
-}
-function collectTypeOnlyLocals(node, typeOnlyLocals) {
-	if (node.type !== "ImportDeclaration") return;
-	for (const specifier of node.specifiers) if (node.importKind === "type" || "importKind" in specifier && specifier.importKind === "type") typeOnlyLocals.add(specifier.local.name);
-}
-function collectDeclarationNames(node) {
-	if (node.type === "VariableDeclaration") return node.declarations.flatMap((decl) => collectPatternNames(decl.id));
-	if ("id" in node && node.id) {
-		if (node.id.type !== "Identifier" && node.id.type !== "TSQualifiedName") return [];
-		const id = getIdFromTSEntityName(node.id);
-		return id.type === "Identifier" ? [id.name] : [];
-	}
-	return [];
 }
-function collectPatternNames(node) {
-	if (!node) return [];
-	if (node.type === "Identifier") return [node.name];
-	if (node.type === "RestElement") return collectPatternNames(node.argument);
-	if (node.type === "AssignmentPattern") return collectPatternNames(node.left);
-	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => collectPatternNames(element));
-	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => {
-		if (property.type === "RestElement") return collectPatternNames(property.argument);
-		return collectPatternNames(property.value);
+function createTscWorker() {
+	const childProcess = fork(new URL(WORKER_URL, import.meta.url), {
+		stdio: "inherit",
+		serialization: "advanced"
+	});
+	const pending = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	childProcess.on("message", (response) => {
+		const handler = pending.get(response.id);
+		if (!handler) return;
+		pending.delete(response.id);
+		if (response.error) handler.reject(response.error);
+		else handler.resolve(response.result);
+	});
+	childProcess.on("exit", (code) => {
+		for (const handler of pending.values()) handler.reject(/* @__PURE__ */ new Error(`tsc worker exited with code ${code}`));
+		pending.clear();
 	});
-	return [];
-}
-function isTypeOnlyExport(node, specifier) {
-	return node.exportKind === "type" || specifier.exportKind === "type";
-}
-async function collectExportInfo(context, node, id, info) {
-	if (node.type === "ExportNamedDeclaration") {
-		if (node.declaration) {
-			for (const name of collectDeclarationNames(node.declaration)) info.exports.set(name, false);
-			return;
-		}
-		const source = await resolveExportSource(context, node.source, id);
-		for (const specifier of node.specifiers) {
-			const typeOnly = isTypeOnlyExport(node, specifier);
-			const exported = nameOf(specifier.exported);
-			const local = nameOf(specifier.local);
-			if (source) info.reExports.push({
-				source,
-				local,
-				exported,
-				typeOnly
-			});
-			else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
-		}
-		return;
-	}
-	if (node.type === "ExportDefaultDeclaration") {
-		info.exports.set("default", false);
-		return;
-	}
-	if (node.type === "ExportAllDeclaration") {
-		if (node.exported) {
-			info.exports.set(nameOf(node.exported), node.exportKind === "type");
-			return;
-		}
-		info.exportAlls.push({
-			source: await resolveExportSource(context, node.source, id),
-			rawSource: node.source.value,
-			typeOnly: node.exportKind === "type"
-		});
-	}
-}
-async function resolveExportSource(context, source, importer) {
-	if (!source) return;
-	const resolved = await context.resolve(source.value, importer);
-	if (!resolved || resolved.external) return;
-	return resolved.id;
-}
-function collectChunkExportInfo(chunk, moduleExportsMap) {
-	const exportsByModule = resolveAllModuleExports(moduleExportsMap);
-	const roots = chunk.facadeModuleId && moduleExportsMap.has(chunk.facadeModuleId) ? [chunk.facadeModuleId] : chunk.moduleIds;
-	const mergedExports = /* @__PURE__ */ new Map();
-	const typeOnlyExportAllSources = /* @__PURE__ */ new Set();
-	for (const root of roots) {
-		const exports = exportsByModule.get(root);
-		if (exports) for (const [name, typeOnly] of exports) setExportTypeOnly(mergedExports, name, typeOnly);
-		const moduleExports = moduleExportsMap.get(root);
-		if (!moduleExports) continue;
-		for (const exportAll of moduleExports.exportAlls) {
-			if (!exportAll.typeOnly || exportAll.source) continue;
-			typeOnlyExportAllSources.add(exportAll.rawSource);
-		}
-	}
-	const typeOnlyNames = /* @__PURE__ */ new Set();
-	for (const [name, typeOnly] of mergedExports) if (typeOnly) typeOnlyNames.add(name);
 	return {
-		typeOnlyNames,
-		typeOnlyExportAllSources
+		emit: (options) => new Promise((resolve, reject) => {
+			const id = nextId++;
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			childProcess.send({
+				id,
+				options
+			});
+		}),
+		kill: () => childProcess.kill()
 	};
 }
-function resolveAllModuleExports(moduleExportsMap) {
-	const exportsByModule = /* @__PURE__ */ new Map();
-	for (const [id, info] of moduleExportsMap) exportsByModule.set(id, new Map(info.exports));
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const [id, info] of moduleExportsMap) {
-			const exports = exportsByModule.get(id);
-			for (const reExport of info.reExports) {
-				const sourceTypeOnly = (reExport.source ? exportsByModule.get(reExport.source) : void 0)?.get(reExport.local) ?? false;
-				if (setExportTypeOnly(exports, reExport.exported, reExport.typeOnly || sourceTypeOnly)) changed = true;
-			}
-			for (const exportAll of info.exportAlls) {
-				if (!exportAll.source) continue;
-				const sourceExports = exportsByModule.get(exportAll.source);
-				if (!sourceExports) continue;
-				for (const [name, typeOnly] of sourceExports) {
-					if (name === "default") continue;
-					if (setExportTypeOnly(exports, name, exportAll.typeOnly || typeOnly)) changed = true;
-				}
-			}
+function collectJsonExportMap(code) {
+	const exportMap = /* @__PURE__ */ new Map();
+	const { program } = parse$1(code, {
+		sourceType: "module",
+		lang: "dts"
+	});
+	for (const decl of program.body) if (decl.type === "ExportNamedDeclaration") {
+		if (decl.declaration) {
+			if (decl.declaration.type === "VariableDeclaration") {
+				for (const vdecl of decl.declaration.declarations) if (vdecl.id.type === "Identifier") exportMap.set(vdecl.id.name, vdecl.id.name);
+			} else if (decl.declaration.type === "TSModuleDeclaration" && decl.declaration.id.type === "Identifier") exportMap.set(decl.declaration.id.name, decl.declaration.id.name);
+		} else if (decl.specifiers.length) {
+			for (const spec of decl.specifiers) if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") exportMap.set(spec.exported.name, spec.local.type === "Identifier" ? spec.local.name : spec.exported.name);
 		}
 	}
-	return exportsByModule;
-}
-function setExportTypeOnly(exports, name, typeOnly) {
-	const current = exports.get(name);
-	if (current === false || current === typeOnly) return false;
-	if (current === void 0 || !typeOnly) {
-		exports.set(name, typeOnly);
-		return true;
-	}
-	return false;
+	return exportMap;
 }
-/**
-* Collects all TSTypeParameter nodes from the given node and groups them by
-* their name. One name can associate with one or more type parameters. These
-* names will be used as the parameter name in the generated JavaScript
-* dependency function.
-*/
-function collectParams(node) {
-	const typeParams = [];
-	walk(node, { leave(node) {
-		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => name));
-	} });
-	const paramMap = /* @__PURE__ */ new Map();
-	for (const typeParam of typeParams) {
-		const name = typeParam.name;
-		const group = paramMap.get(name);
-		if (group) group.push(typeParam);
-		else paramMap.set(name, [typeParam]);
-	}
-	return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
-		name,
-		typeParams
-	}));
+/** `declare const _exports` mode */
+function collectJsonExports(code) {
+	const exports = [];
+	const { program } = parse$1(code, {
+		sourceType: "module",
+		lang: "dts"
+	});
+	const members = program.body[0].declarations[0].id.typeAnnotation.typeAnnotation.members;
+	for (const member of members) if (member.key.type === "Identifier") exports.push(member.key.name);
+	else if (is.StringLiteral(member.key)) exports.push(member.key.value);
+	return exports;
 }
-async function collectDependencies(context, node, importer, namespaceStmts, children, identifierMap) {
-	const deps = /* @__PURE__ */ new Set();
-	const seen = /* @__PURE__ */ new Set();
-	const preserveImportTypeCache = /* @__PURE__ */ new Map();
-	const importSources = /* @__PURE__ */ new Set();
-	walk(node, { TSImportType(node) {
-		importSources.add(node.source.value);
-	} });
-	if (importSources.size) await Promise.all(Array.from(importSources, async (source) => {
-		const resolved = await context.resolve(source, importer);
-		preserveImportTypeCache.set(source, !resolved || !!resolved.external);
-	}));
-	const inferredStack = [];
-	let currentInferred = /* @__PURE__ */ new Set();
-	function isInferred(node) {
-		return node.type === "Identifier" && currentInferred.has(node.name);
-	}
-	walk(node, {
-		enter(node) {
-			if (node.type === "TSConditionalType") {
-				const inferred = collectInferredNames(node.extendsType);
-				inferredStack.push(inferred);
-			}
-		},
-		leave(node, path) {
-			const { parent } = path;
-			if (node.type === "TSConditionalType") inferredStack.pop();
-			else if (parent?.type === "TSConditionalType") {
-				const trueBranch = parent.trueType === node;
-				currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
-			} else currentInferred = /* @__PURE__ */ new Set();
-			if (node.type === "ExportNamedDeclaration") {
-				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
-			} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
-			else if (node.type === "ClassDeclaration") {
-				if (node.superClass) addDependency(node.superClass);
-				if (node.implements) for (const implement of node.implements) addDependency(implement.expression);
-			} else if (is.oneOf(node, [
-				"Property",
-				"PropertyDefinition",
-				"TSAbstractPropertyDefinition",
-				"MethodDefinition",
-				"TSAbstractMethodDefinition",
-				"TSPropertySignature",
-				"TSMethodSignature"
-			])) {
-				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
-				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
-			} else switch (node.type) {
-				case "TSTypeReference":
-					addDependency(TSEntityNameToRuntime(node.typeName));
-					break;
-				case "TSTypeQuery":
-					if (seen.has(node.exprName)) return;
-					if (node.exprName.type === "TSImportType") break;
-					addDependency(TSEntityNameToRuntime(node.exprName));
-					break;
-				case "TSImportType": {
-					seen.add(node);
-					const { source, qualifier } = node;
-					const dep = importNamespace(node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
-					if (dep) addDependency(dep);
-					break;
+function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
+	let declarationIdx = 0;
+	const declarationMap = /* @__PURE__ */ new Map();
+	const commentsMap = /* @__PURE__ */ new Map();
+	const moduleExportsMap = /* @__PURE__ */ new Map();
+	const warnedCjsDtsInputs = /* @__PURE__ */ new Set();
+	return {
+		name: "rolldown-plugin-dts:fake-js",
+		outputOptions(options) {
+			if (options.format === "cjs" || options.format === "commonjs") throw new Error("[rolldown-plugin-dts] Cannot bundle dts files with `cjs` format.");
+			const { chunkFileNames, entryFileNames } = options;
+			return {
+				...options,
+				sourcemap: options.sourcemap || sourcemap,
+				chunkFileNames(chunk) {
+					const nameTemplate = resolveTemplateFn(chunk.isEntry ? entryFileNames || "[name].js" : chunkFileNames || "[name]-[hash].js", chunk);
+					if (chunk.name.endsWith(".d")) {
+						const renderedNameWithoutD = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name.slice(0, -2)));
+						if (RE_DTS.test(renderedNameWithoutD)) return renderedNameWithoutD;
+						const renderedName = filename_js_to_dts(replaceTemplateName(nameTemplate, chunk.name));
+						if (RE_DTS.test(renderedName)) return renderedName;
+					}
+					return nameTemplate;
 				}
+			};
+		},
+		transform: {
+			filter: { id: RE_DTS },
+			handler: transform
+		},
+		renderChunk,
+		generateBundle(options, bundle) {
+			for (const chunk of Object.values(bundle)) {
+				if (!RE_DTS_MAP.test(chunk.fileName)) continue;
+				if (sourcemap) {
+					if (chunk.type === "chunk" || typeof chunk.source !== "string") continue;
+					const map = JSON.parse(chunk.source);
+					map.sourcesContent = void 0;
+					chunk.source = JSON.stringify(map);
+				} else delete bundle[chunk.fileName];
 			}
-			if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
 		}
-	});
-	return Array.from(deps);
-	function addDependency(node) {
-		if (isThisExpression(node) || isInferred(node)) return;
-		deps.add(node);
-	}
-}
-function importNamespace(node, imported, source, namespaceStmts, identifierMap, preserveCache) {
-	if (preserveCache.get(source.value) ?? true) return;
-	const sourceText = source.value.replaceAll(/\W/g, "_");
-	const localName = `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`;
-	let local = b.identifier(localName);
-	if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
-	else namespaceStmts.set(source.value, {
-		stmt: b.importDeclaration([b.importNamespaceSpecifier(local)], source),
-		local
-	});
-	if (imported) {
-		const importedLeft = getIdFromTSEntityName(imported);
-		if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
-		overwriteNode(importedLeft, b.tsQualifiedName(local, { ...importedLeft }));
-		local = imported;
+	};
+	async function transform(code, id) {
+		let file;
+		try {
+			file = parse$1(code, {
+				lang: "dts",
+				sourceType: "module",
+				attachComments: true
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
+		}
+		const { program } = file;
+		moduleExportsMap.set(id, await collectModuleExports(this, program.body, id));
+		const identifierMap = Object.create(null);
+		if (!warnedCjsDtsInputs.has(id) && program.body.some(isCjsDtsInputSyntax)) {
+			warnedCjsDtsInputs.add(id);
+			this.warn(`${id} uses CommonJS dts syntax. ${RE_NODE_MODULES.test(id) ? `CommonJS dts modules cannot be bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `rolldown-plugin-dts does not support bundling CommonJS dts input.`}`);
+		}
+		const directives = collectReferenceDirectives(file.comments);
+		if (directives.length) commentsMap.set(id, directives);
+		const appendStmts = [];
+		const namespaceStmts = /* @__PURE__ */ new Map();
+		for (const [i, stmt] of program.body.entries()) {
+			const setStmt = (stmt) => program.body[i] = stmt;
+			if (rewriteImportExport(stmt, setStmt)) continue;
+			const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
+			if (sideEffect && stmt.type === "TSModuleDeclaration" && is.StringLiteral(stmt.id) && stmt.id.value[0] === ".") this.warn(`\`declare module ${JSON.stringify(stmt.id.value)}\` will be kept as-is in the output. Relative module declaration may cause unexpected issues. Found in ${id}.`);
+			const isDefaultExport = stmt.type === "ExportDefaultDeclaration";
+			const isExportDecl = is.oneOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && !!stmt.declaration;
+			const decl = isExportDecl ? stmt.declaration : stmt;
+			const setDecl = isExportDecl ? (decl) => stmt.declaration = decl : setStmt;
+			if (decl.type !== "TSDeclareFunction" && !is.Declaration(decl)) continue;
+			if (is.oneOf(decl, [
+				"TSEnumDeclaration",
+				"ClassDeclaration",
+				"FunctionDeclaration",
+				"TSDeclareFunction",
+				"TSModuleDeclaration",
+				"VariableDeclaration"
+			])) decl.declare = true;
+			const bindings = [];
+			if (decl.type === "VariableDeclaration") bindings.push(...decl.declarations.map((decl) => decl.id));
+			else if ("id" in decl && decl.id) {
+				let binding = decl.id;
+				if (binding.type === "TSQualifiedName") binding = getIdFromTSEntityName(binding);
+				if (sideEffect) binding = b.Identifier({ name: `_${getIdentifierIndex(identifierMap, "")}` });
+				if (binding.type !== "Identifier") throw new Error(`Unexpected ${binding.type} declaration id`);
+				bindings.push(binding);
+			} else {
+				const binding = b.Identifier({ name: "export_default" });
+				bindings.push(binding);
+				decl.id = binding;
+			}
+			const params = collectParams(decl);
+			const childrenSet = /* @__PURE__ */ new Set();
+			const deps = await collectDependencies(this, decl, id, namespaceStmts, childrenSet, identifierMap);
+			const children = Array.from(childrenSet).filter((child) => bindings.every((b) => child !== b));
+			if (decl !== stmt) decl.comments = stmt.comments;
+			const declarationId = registerDeclaration({
+				decl,
+				deps,
+				bindings,
+				params,
+				children
+			});
+			const declarationIdNode = b.Literal({
+				value: declarationId,
+				raw: String(declarationId)
+			});
+			const depsBody = b.ArrayExpression({ elements: deps });
+			const depsNode = b.ArrowFunctionExpression({
+				id: null,
+				generator: false,
+				async: false,
+				params: params.map(({ name }) => b.Identifier({ name })),
+				body: depsBody,
+				expression: true
+			});
+			const childrenNode = b.ArrayExpression({ elements: children.map((node) => b.Literal({
+				value: "",
+				raw: "\"\"",
+				start: node.start,
+				end: node.end
+			})) });
+			const sideEffectNode = sideEffect && b.CallExpression({
+				callee: b.Identifier({ name: "sideEffect" }),
+				arguments: [bindings[0]],
+				optional: false
+			});
+			const runtimeArrayNode = runtimeBindingArrayExpression([
+				declarationIdNode,
+				depsNode,
+				childrenNode,
+				...sideEffectNode ? [sideEffectNode] : []
+			]);
+			const runtimeAssignment = b.VariableDeclaration({
+				kind: "var",
+				declarations: [b.VariableDeclarator({
+					id: b.ArrayPattern({ elements: bindings.map((binding) => ({
+						...binding,
+						typeAnnotation: null
+					})) }),
+					init: runtimeArrayNode
+				})]
+			});
+			if (isDefaultExport) {
+				appendStmts.push(b.ExportNamedDeclaration({
+					declaration: null,
+					specifiers: [b.ExportSpecifier({
+						local: bindings[0],
+						exported: b.Identifier({ name: "default" })
+					})],
+					source: null,
+					attributes: []
+				}));
+				setStmt(runtimeAssignment);
+			} else setDecl(runtimeAssignment);
+		}
+		if (sideEffects) appendStmts.push(b.ExpressionStatement({ expression: b.CallExpression({
+			callee: b.Identifier({ name: "sideEffect" }),
+			arguments: [],
+			optional: false
+		}) }));
+		program.body = [
+			...Array.from(namespaceStmts.values()).map(({ stmt }) => stmt),
+			...program.body,
+			...appendStmts
+		];
+		const result = print(program, {
+			comments: false,
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: id
+			} }
+		});
+		return {
+			code: result.code,
+			map: result.map ?? null
+		};
 	}
-	let replacement = node;
-	if (node.typeArguments) {
-		overwriteNode(node, b.tsTypeReference(local, node.typeArguments));
-		replacement = local;
-	} else overwriteNode(node, local);
-	return {
-		...TSEntityNameToRuntime(local),
-		replace(newNode) {
-			overwriteNode(replacement, newNode);
+	function renderChunk(code, chunk) {
+		if (!RE_DTS.test(chunk.fileName)) return;
+		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
+		let file;
+		try {
+			file = parse$1(code, {
+				lang: "ts",
+				sourceType: "module",
+				attachComments: true
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse generated code for chunk ${chunk.fileName}. This may be caused by a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
 		}
-	};
-}
-function isChildSymbol(node, parent) {
-	if (node.type === "Identifier") return true;
-	if (is.oneOf(parent, ["TSPropertySignature", "TSMethodSignature"]) && parent.key === node) return true;
-	return false;
-}
-function collectInferredNames(node) {
-	const inferred = [];
-	walk(node, { enter(node) {
-		if (node.type === "TSInferType" && node.typeParameter) inferred.push(node.typeParameter.name.name);
-	} });
-	return inferred;
-}
-const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
-function collectReferenceDirectives(comment, negative = false) {
-	return comment.filter((c) => REFERENCE_RE.test(c.value) !== negative);
-}
-const SOURCE_MAP_PRAGMA_RE = /^#\s*source(?:Mapping)?URL=/;
-function isSourceMapPragma(comment) {
-	return SOURCE_MAP_PRAGMA_RE.test(comment.value);
-}
-function isCjsDtsInputSyntax(node) {
-	return node.type === "TSExportAssignment" || node.type === "TSImportEqualsDeclaration" && node.moduleReference.type === "TSExternalModuleReference";
-}
-/**
-* Check if the given node is a {@link RuntimeBindingVariableDeclration}
-*/
-function isRuntimeBindingVariableDeclaration(node) {
-	return node?.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].type === "VariableDeclarator" && node.declarations[0].id.type === "ArrayPattern" && isRuntimeBindingArrayExpression(node.declarations[0].init);
-}
-/**
-* Check if the given node is a {@link RuntimeBindingArrayExpression}
-*/
-function isRuntimeBindingArrayExpression(node) {
-	return node?.type === "ArrayExpression" && isRuntimeBindingArrayElements(node.elements);
-}
-/**
-* Check if the given array is a {@link RuntimeBindingArrayElements}
-*/
-function isRuntimeBindingArrayElements(elements) {
-	const [declarationId, deps, children, effect] = elements;
-	return is.NumericLiteral(declarationId) && deps?.type === "ArrowFunctionExpression" && children?.type === "ArrayExpression" && (!effect || effect.type === "CallExpression");
-}
-function runtimeBindingArrayExpression(elements) {
-	return b.arrayExpression([...elements]);
-}
-function isThisExpression(node) {
-	return is.Identifier(node, "this") || node.type === "ThisExpression" || node.type === "MemberExpression" && isThisExpression(node.object);
-}
-function isInfer(node) {
-	return is.Identifier(node, "infer");
-}
-function TSEntityNameToRuntime(node) {
-	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
-	const left = TSEntityNameToRuntime(node.left);
-	return Object.assign(node, {
-		type: "MemberExpression",
-		object: left,
-		property: node.right,
-		computed: false
-	});
-}
-function getIdFromTSEntityName(node) {
-	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
-	return getIdFromTSEntityName(node.left);
-}
-function isReferenceId(node) {
-	return is.oneOf(node, ["Identifier", "MemberExpression"]);
-}
-function isHelperImport(node) {
-	return node.type === "ImportDeclaration" && node.specifiers.length && node.specifiers.every((spec) => spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && ["__exportAll", "__reExport"].includes(spec.local.name));
-}
-/**
-* patch `.d.ts` suffix in import source to `.js`
-*/
-function patchImportExport(node, exportInfo, cjsDefault) {
-	if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && !node.specifiers.length && !node.attributes?.length) return false;
-	if (node.type === "ImportDeclaration" && node.specifiers.length) {
-		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
-	}
-	if (is.oneOf(node, [
-		"ImportDeclaration",
-		"ExportAllDeclaration",
-		"ExportNamedDeclaration"
-	])) {
-		if (node.type === "ExportAllDeclaration" && node.source && exportInfo.typeOnlyExportAllSources.has(node.source.value)) node.exportKind = "type";
-		if (node.type === "ExportNamedDeclaration" && exportInfo.typeOnlyNames.size) {
-			for (const spec of node.specifiers) {
-				const name = nameOf(spec.exported);
-				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
-				else node.exportKind = "type";
+		const { program } = file;
+		program.body = patchTsNamespace(program.body);
+		program.body = patchReExport(program.body);
+		program.body = program.body.map((node) => {
+			if (isHelperImport(node)) return null;
+			if (node.type === "ExpressionStatement") return null;
+			const newNode = patchImportExport(node, exportInfo, cjsDefault);
+			if (newNode || newNode === false) return newNode;
+			if (node.type !== "VariableDeclaration") return node;
+			if (!isRuntimeBindingVariableDeclaration(node)) return null;
+			const decl = node.declarations[0];
+			const [declarationIdNode, depsFn, children] = decl.init.elements;
+			const declarationId = declarationIdNode.value;
+			const declaration = getDeclaration(declarationId);
+			if (sourcemap) walk(declaration.decl, { enter(node) {
+				node.start = void 0;
+				node.end = void 0;
+			} });
+			for (const [i, id] of decl.id.elements.entries()) {
+				const transformedBinding = {
+					...id,
+					typeAnnotation: declaration.bindings[i].typeAnnotation
+				};
+				overwriteNode(declaration.bindings[i], transformedBinding);
+			}
+			if (sourcemap) for (const [i, child] of children.elements.entries()) Object.assign(declaration.children[i], {
+				start: child.start,
+				end: child.end
+			});
+			const transformedParams = depsFn.params;
+			for (const [i, transformedParam] of transformedParams.entries()) {
+				const transformedName = transformedParam.name;
+				for (const originalTypeParam of declaration.params[i].typeParams) originalTypeParam.name = transformedName;
+			}
+			const transformedDeps = depsFn.body.elements;
+			for (const [i, originalDep] of declaration.deps.entries()) {
+				let transformedDep = transformedDeps[i];
+				if (transformedDep.type === "UnaryExpression" && transformedDep.operator === "void") {
+					const undefinedDep = b.Identifier({ name: "undefined" });
+					undefinedDep.start = transformedDep.start;
+					undefinedDep.end = transformedDep.end;
+					transformedDep = undefinedDep;
+				} else if (isInfer(transformedDep)) transformedDep.name = "__Infer";
+				if (originalDep.replace) originalDep.replace(transformedDep);
+				else Object.assign(originalDep, transformedDep);
+			}
+			return inheritNodeComments(node, declaration.decl);
+		}).filter((node) => !!node);
+		if (program.body.length === 0) return {
+			code: EMPTY_STUB,
+			map: null
+		};
+		const comments = /* @__PURE__ */ new Set();
+		const commentsValue = /* @__PURE__ */ new Set();
+		for (const id of chunk.moduleIds) {
+			const preserveComments = commentsMap.get(id);
+			if (preserveComments) {
+				preserveComments.forEach((c) => {
+					const id = c.type + c.value;
+					if (commentsValue.has(id)) return;
+					commentsValue.add(id);
+					comments.add(c);
+				});
+				commentsMap.delete(id);
 			}
-			normalizeTypeOnlyExport(node);
-		}
-		if (node.source?.value && RE_DTS.test(node.source.value)) {
-			node.source.value = filename_dts_to(node.source.value, "js");
-			return node;
 		}
-		if (cjsDefault && node.type === "ExportNamedDeclaration" && !node.source && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && nameOf(node.specifiers[0].exported) === "default") {
-			const defaultExport = node.specifiers[0];
-			return b.tsExportAssignment(defaultExport.local);
+		if (comments.size) {
+			program.body[0].comments ||= [];
+			program.body[0].comments.unshift(...Array.from(comments, (c) => ({
+				type: c.type,
+				value: c.value,
+				position: "before",
+				sameLine: false
+			})));
 		}
-	}
-}
-function normalizeTypeOnlyExport(node) {
-	if (node.declaration || !node.specifiers.length) return;
-	for (const specifier of node.specifiers) if (specifier.type !== "ExportSpecifier" || specifier.exportKind !== "type") return;
-	node.exportKind = "type";
-	for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
-}
-/**
-* Handle `__exportAll` call
-*/
-function patchTsNamespace(nodes) {
-	const removed = /* @__PURE__ */ new Set();
-	for (const [i, node] of nodes.entries()) {
-		const result = getExportAllNamespace(node);
-		if (!result) continue;
-		const [binding, exports] = result;
-		if (!exports.properties.length) continue;
-		const namespaceExport = b.exportNamedDeclaration(null, exports.properties.filter((property) => property.type === "Property").map((property) => {
-			const local = property.value.body;
-			const exported = property.key;
-			return b.exportSpecifier(local, exported);
-		}));
-		nodes[i] = b.tsModuleDeclaration(binding, b.tsModuleBlock([namespaceExport]), {
-			kind: "namespace",
-			declare: true
+		const result = print(program, {
+			comments: true,
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: chunk.fileName
+			} }
 		});
+		return {
+			code: result.code,
+			map: result.map ?? null
+		};
+	}
+	function registerDeclaration(info) {
+		const declarationId = declarationIdx++;
+		declarationMap.set(declarationId, info);
+		return declarationId;
+	}
+	function getDeclaration(declarationId) {
+		return declarationMap.get(declarationId);
 	}
-	return nodes.filter((node) => !removed.has(node));
 }
-function getExportAllNamespace(node) {
-	if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
-	return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
+async function collectModuleExports(context, nodes, id) {
+	const info = {
+		typeOnlyLocals: /* @__PURE__ */ new Set(),
+		exports: /* @__PURE__ */ new Map(),
+		reExports: [],
+		exportAlls: []
+	};
+	for (const node of nodes) collectTypeOnlyLocals(node, info.typeOnlyLocals);
+	for (const node of nodes) await collectExportInfo(context, node, id, info);
+	return info;
 }
-/**
-* Handle `__reExport` call
-*/
-function patchReExport(nodes) {
-	const exportsNames = /* @__PURE__ */ new Map();
-	for (const [i, node] of nodes.entries()) if (node.type === "ImportDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ImportSpecifier" && node.specifiers[0].local.type === "Identifier" && node.specifiers[0].local.name.endsWith("_exports")) exportsNames.set(node.specifiers[0].local.name, node.specifiers[0].local.name);
-	else if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && is.Identifier(node.expression.callee, "__reExport")) {
-		const args = node.expression.arguments;
-		exportsNames.set(args[0].name, args[1].name);
-	} else if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].init?.type === "MemberExpression" && node.declarations[0].init.object.type === "Identifier" && exportsNames.has(node.declarations[0].init.object.name)) nodes[i] = b.tsTypeAliasDeclaration(b.identifier(node.declarations[0].id.name), b.tsTypeReference(b.tsQualifiedName(b.identifier(exportsNames.get(node.declarations[0].init.object.name)), b.identifier(node.declarations[0].init.property.name))));
-	else if (node.type === "ExportNamedDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && node.specifiers[0].local.type === "Identifier" && exportsNames.has(node.specifiers[0].local.name)) node.specifiers[0].local.name = exportsNames.get(node.specifiers[0].local.name);
-	return nodes;
+function collectTypeOnlyLocals(node, typeOnlyLocals) {
+	if (node.type !== "ImportDeclaration") return;
+	for (const specifier of node.specifiers) if (node.importKind === "type" || "importKind" in specifier && specifier.importKind === "type") typeOnlyLocals.add(specifier.local.name);
 }
-function rewriteImportExport(node, set) {
-	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
-		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
-		else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
-		if (node.type === "ImportDeclaration") node.importKind = "value";
-		else if (node.type === "ExportNamedDeclaration") node.exportKind = "value";
-		return true;
-	} else if (node.type === "ExportAllDeclaration") {
-		node.exportKind = "value";
-		return true;
-	} else if (node.type === "TSImportEqualsDeclaration") {
-		if (node.moduleReference.type === "TSExternalModuleReference") set(b.importDeclaration([b.importDefaultSpecifier(node.id)], node.moduleReference.expression));
-		return true;
-	} else if (node.type === "TSExportAssignment" && node.expression.type === "Identifier") {
-		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.expression, b.identifier("default"))]));
-		return true;
-	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
-		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.declaration, b.identifier("default"))]));
-		return true;
+function collectDeclarationNames(node) {
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((decl) => collectPatternNames(decl.id));
+	if ("id" in node && node.id) {
+		if (node.id.type !== "Identifier" && node.id.type !== "TSQualifiedName") return [];
+		const id = getIdFromTSEntityName(node.id);
+		return id.type === "Identifier" ? [id.name] : [];
 	}
-	return false;
-}
-function overwriteNode(node, newNode) {
-	for (const key of Object.keys(node)) Reflect.deleteProperty(node, key);
-	Object.assign(node, newNode);
-	return node;
+	return [];
 }
-function inheritNodeComments(oldNode, newNode) {
-	newNode.comments ||= [];
-	const pragmas = oldNode.comments?.filter((comment) => comment.position === "before" && comment.value.startsWith("#") && !isSourceMapPragma(comment));
-	if (pragmas) newNode.comments.unshift(...pragmas);
-	newNode.comments = newNode.comments.filter((comment) => !REFERENCE_RE.test(comment.value) && !isSourceMapPragma(comment));
-	return newNode;
+function collectPatternNames(node) {
+	if (!node) return [];
+	if (node.type === "Identifier") return [node.name];
+	if (node.type === "RestElement") return collectPatternNames(node.argument);
+	if (node.type === "AssignmentPattern") return collectPatternNames(node.left);
+	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => collectPatternNames(element));
+	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => {
+		if (property.type === "RestElement") return collectPatternNames(property.argument);
+		return collectPatternNames(property.value);
+	});
+	return [];
 }
-function getIdentifierIndex(identifierMap, name) {
-	if (name in identifierMap) return ++identifierMap[name];
-	return identifierMap[name] = 0;
+function isTypeOnlyExport(node, specifier) {
+	return node.exportKind === "type" || specifier.exportKind === "type";
 }
-const require$1 = createRequire(import.meta.url);
-const debug$4 = createDebug("rolldown-plugin-dts:tsgo");
-function isTS70Installed() {
-	try {
-		const { versionMajorMinor } = require$1("typescript");
-		return versionMajorMinor === "7.0";
-	} catch {}
-	return false;
+async function collectExportInfo(context, node, id, info) {
+	if (node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			for (const name of collectDeclarationNames(node.declaration)) info.exports.set(name, false);
+			return;
+		}
+		const source = await resolveExportSource(context, node.source, id);
+		for (const specifier of node.specifiers) {
+			const typeOnly = isTypeOnlyExport(node, specifier);
+			const exported = nameOf(specifier.exported);
+			const local = nameOf(specifier.local);
+			if (source) info.reExports.push({
+				source,
+				local,
+				exported,
+				typeOnly
+			});
+			else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
+		}
+		return;
+	}
+	if (node.type === "ExportDefaultDeclaration") {
+		info.exports.set("default", false);
+		return;
+	}
+	if (node.type === "ExportAllDeclaration") {
+		if (node.exported) {
+			info.exports.set(nameOf(node.exported), node.exportKind === "type");
+			return;
+		}
+		info.exportAlls.push({
+			source: await resolveExportSource(context, node.source, id),
+			rawSource: node.source.value,
+			typeOnly: node.exportKind === "type"
+		});
+	}
 }
-const spawnAsync = (...args) => new Promise((resolve, reject) => {
-	const child = spawn(...args);
-	child.on("close", () => resolve());
-	child.on("error", (error) => reject(error));
-});
-let tsgoPathCache;
-async function getTsgoPathFromNodeModules(logger) {
-	if (tsgoPathCache) return tsgoPathCache;
-	const pkgName = isTS70Installed() ? "typescript" : "@typescript/native-preview";
-	const tsgoPkg = import.meta.resolve(`${pkgName}/package.json`);
-	const { default: { version } } = await import(tsgoPkg, { with: { type: "json" } });
-	logger.info(`Emit types with ${styleText("underline", `${pkgName}@${version}`)}`);
-	const { default: getExePath } = await import(new URL("lib/getExePath.js", tsgoPkg).href);
-	return tsgoPathCache = getExePath();
+async function resolveExportSource(context, source, importer) {
+	if (!source) return;
+	const resolved = await context.resolve(source.value, importer);
+	if (!resolved || resolved.external) return;
+	return resolved.id;
 }
-async function runTsgo(logger, rootDir, tsconfig, sourcemap, tsgoPath) {
-	debug$4("[tsgo] rootDir", rootDir);
-	let tsgo;
-	if (tsgoPath) {
-		tsgo = tsgoPath;
-		debug$4("[tsgo] using custom path", tsgo);
-	} else {
-		tsgo = await getTsgoPathFromNodeModules(logger);
-		debug$4("[tsgo] using tsgo from node_modules", tsgo);
+function collectChunkExportInfo(chunk, moduleExportsMap) {
+	const exportsByModule = resolveAllModuleExports(moduleExportsMap);
+	const roots = chunk.facadeModuleId && moduleExportsMap.has(chunk.facadeModuleId) ? [chunk.facadeModuleId] : chunk.moduleIds;
+	const mergedExports = /* @__PURE__ */ new Map();
+	const typeOnlyExportAllSources = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		const exports = exportsByModule.get(root);
+		if (exports) for (const [name, typeOnly] of exports) setExportTypeOnly(mergedExports, name, typeOnly);
+		const moduleExports = moduleExportsMap.get(root);
+		if (!moduleExports) continue;
+		for (const exportAll of moduleExports.exportAlls) {
+			if (!exportAll.typeOnly || exportAll.source) continue;
+			typeOnlyExportAllSources.add(exportAll.rawSource);
+		}
 	}
-	const tsgoDist = await mkdtemp(path.join(tmpdir(), "rolldown-plugin-dts-"));
-	debug$4("[tsgo] tsgoDist", tsgoDist);
-	const args = [
-		"--noEmit",
-		"false",
-		"--declaration",
-		"--emitDeclarationOnly",
-		"-p",
-		tsconfig,
-		"--outDir",
-		tsgoDist,
-		"--rootDir",
-		rootDir,
-		"--noCheck",
-		...sourcemap ? ["--declarationMap"] : []
-	];
-	debug$4("[tsgo] args %o", args);
-	await spawnAsync(tsgo, args, { stdio: "inherit" });
+	const typeOnlyNames = /* @__PURE__ */ new Set();
+	for (const [name, typeOnly] of mergedExports) if (typeOnly) typeOnlyNames.add(name);
 	return {
-		path: tsgoDist,
-		async dispose() {
-			if (debug$4.enabled) debug$4("[tsgo] skip cleanup of tsgoDist", tsgoDist);
-			else {
-				debug$4("[tsgo] disposing tsgoDist", tsgoDist);
-				await rm(tsgoDist, {
-					recursive: true,
-					force: true
-				}).catch(() => {});
-			}
-		}
+		typeOnlyNames,
+		typeOnlyExportAllSources
 	};
 }
-const debug$3 = createDebug("rolldown-plugin-dts:generate");
-const WORKER_URL = "./tsc-worker.mjs";
-function createGeneratePlugin({ generator, entry, tsconfig, tsconfigRaw, build, incremental, cwd, oxc, emitDtsOnly, vue, tsMacro, parallel, eager, tsgo, newContext, emitJs, sourcemap, logger }) {
-	const entryIncludes = entry?.filter((p) => p[0] !== "!");
-	const entryIgnores = entry?.filter((p) => p[0] === "!").map((p) => p.slice(1));
-	const entryMatcher = entry ? (file) => entryIncludes.some((p) => path.matchesGlob(file, p)) && !entryIgnores.some((p) => path.matchesGlob(file, p)) : void 0;
-	const dtsMap = /* @__PURE__ */ new Map();
-	/**
-	* A map of input id to output file name
-	*
-	* @example
-	*
-	* inputAlias = new Map([
-	*   ['/absolute/path/to/src/source_file.ts', 'dist/foo/index'],
-	* ])
-	*/
-	const inputAliasMap = /* @__PURE__ */ new Map();
-	let tscWorker;
-	let tscModule;
-	let tscContext;
-	let tsgoContext;
-	const rootDir = tsconfig ? path.dirname(tsconfig) : cwd;
-	return {
-		name: "rolldown-plugin-dts:generate",
-		async buildStart(options) {
-			if (generator === "tsgo") tsgoContext = await runTsgo(logger, rootDir, tsconfig, sourcemap, tsgo.path);
-			else if (generator === "tsc") if (parallel) tscWorker = createTscWorker();
-			else {
-				tscModule = await import("./tsc-CilQvmj4.js");
-				if (newContext) tscContext = createContext();
-			}
-			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
-				debug$3("resolving input alias %s -> %s", name, id);
-				let resolved = await this.resolve(id);
-				if (!id.startsWith("./")) resolved ||= await this.resolve(`./${id}`);
-				const resolvedId = resolved?.id || id;
-				debug$3("resolved input alias %s -> %s", id, resolvedId);
-				inputAliasMap.set(resolvedId, name);
-			}
-		},
-		outputOptions(options) {
-			return {
-				...options,
-				entryFileNames(chunk) {
-					const { entryFileNames } = options;
-					const nameTemplate = resolveTemplateFn(entryFileNames || "[name].js", chunk);
-					if (chunk.name.endsWith(".d")) {
-						if (RE_DTS.test(nameTemplate)) return replaceTemplateName(nameTemplate, chunk.name.slice(0, -2));
-						if (RE_JS.test(nameTemplate)) return nameTemplate.replace(RE_JS, ".$1ts");
-					}
-					return nameTemplate;
-				}
-			};
-		},
-		resolveId(id) {
-			if (dtsMap.has(id)) {
-				debug$3("resolve dts id %s", id);
-				return { id };
+function resolveAllModuleExports(moduleExportsMap) {
+	const exportsByModule = /* @__PURE__ */ new Map();
+	for (const [id, info] of moduleExportsMap) exportsByModule.set(id, new Map(info.exports));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [id, info] of moduleExportsMap) {
+			const exports = exportsByModule.get(id);
+			for (const reExport of info.reExports) {
+				const sourceTypeOnly = (reExport.source ? exportsByModule.get(reExport.source) : void 0)?.get(reExport.local) ?? false;
+				if (setExportTypeOnly(exports, reExport.exported, reExport.typeOnly || sourceTypeOnly)) changed = true;
 			}
-		},
-		transform: {
-			order: "pre",
-			filter: { id: {
-				include: [
-					RE_JS,
-					RE_TS,
-					RE_VUE,
-					RE_JSON
-				],
-				exclude: [
-					RE_DTS,
-					RE_NODE_MODULES,
-					RE_ROLLDOWN_RUNTIME
-				]
-			} },
-			handler(code, id) {
-				const jsFile = RE_JS.test(id);
-				if (!jsFile || emitJs) {
-					const mod = this.getModuleInfo(id);
-					const isEntry = entryMatcher ? entryMatcher(path.relative(cwd, id)) : !!mod?.isEntry;
-					const dtsId = filename_to_dts(id);
-					dtsMap.set(dtsId, {
-						code,
-						id,
-						isEntry,
-						jsFile
-					});
-					debug$3("register dts source: %s", id);
-					if (isEntry) {
-						const name = inputAliasMap.get(id);
-						this.emitFile({
-							type: "chunk",
-							id: dtsId,
-							name: name ? `${name}.d` : void 0
-						});
-					}
-				}
-				if (emitDtsOnly) {
-					if (RE_JSON.test(id)) return "{}";
-					return "export { }";
+			for (const exportAll of info.exportAlls) {
+				if (!exportAll.source) continue;
+				const sourceExports = exportsByModule.get(exportAll.source);
+				if (!sourceExports) continue;
+				for (const [name, typeOnly] of sourceExports) {
+					if (name === "default") continue;
+					if (setExportTypeOnly(exports, name, exportAll.typeOnly || typeOnly)) changed = true;
 				}
 			}
-		},
-		load: {
-			filter: { id: {
-				include: [RE_DTS],
-				exclude: [RE_NODE_MODULES]
-			} },
-			async handler(dtsId) {
-				const module = dtsMap.get(dtsId);
-				if (!module) return;
-				const { code, id, jsFile } = module;
-				if (jsFile && await access(dtsId).then(() => true).catch(() => false)) {
-					debug$3("dts file already exists for %s, skipping generation", id);
-					return;
-				}
-				let dtsCode;
-				let map;
-				debug$3("generate dts %s from %s", dtsId, id);
-				if (generator === "tsgo") {
-					if (RE_VUE.test(id)) throw new Error("tsgo does not support Vue files.");
-					const dtsPath = path.resolve(tsgoContext.path, path.relative(path.resolve(rootDir), filename_to_dts(id)));
-					if (!existsSync(dtsPath)) {
-						debug$3("[tsgo]", dtsPath, "is missing");
-						throw new Error(`tsgo did not generate dts file for ${id}, please check your tsconfig.`);
-					}
-					dtsCode = await readFile(dtsPath, "utf8");
-					const mapPath = `${dtsPath}.map`;
-					if (existsSync(mapPath)) {
-						const mapRaw = await readFile(mapPath, "utf8");
-						map = {
-							...JSON.parse(mapRaw),
-							sources: [id]
-						};
-					}
-				} else if (generator === "oxc" && !RE_VUE.test(id)) {
-					const result = isolatedDeclarationSync(id, code, oxc);
-					if (result.errors.length) {
-						const [error] = result.errors;
-						return this.error({
-							message: error.message,
-							frame: error.codeframe || void 0
-						});
-					}
-					dtsCode = result.code;
-					if (result.map) {
-						map = result.map;
-						map.sourcesContent = void 0;
-					}
-				} else {
-					const options = {
-						tsconfig,
-						tsconfigRaw,
-						build,
-						incremental,
-						cwd,
-						entries: eager ? void 0 : Array.from(dtsMap.values()).filter((v) => v.isEntry).map((v) => v.id),
-						id,
-						sourcemap,
-						vue,
-						tsMacro,
-						context: tscContext
-					};
-					let result;
-					if (parallel) result = await tscWorker.emit(options);
-					else result = tscModule.tscEmit(options);
-					if (result.error) return this.error(result.error);
-					dtsCode = result.code;
-					map = result.map;
-					if (dtsCode && RE_JSON.test(id)) if (dtsCode.includes("declare const _exports")) {
-						if (dtsCode.includes("declare const _exports: {") && !dtsCode.includes("\n}[];")) {
-							const exports = collectJsonExports(dtsCode);
-							let i = 0;
-							dtsCode += exports.map((e) => {
-								const valid = `_${e.replaceAll(/[^\w$]/g, "_")}${i++}`;
-								const jsonKey = JSON.stringify(e);
-								return `declare let ${valid}: typeof _exports[${jsonKey}]\nexport { ${valid} as ${jsonKey} }`;
-							}).join("\n");
-						}
-					} else {
-						const exportMap = collectJsonExportMap(dtsCode);
-						dtsCode += `
-declare namespace __json_default_export {
-  export { ${Array.from(exportMap.entries()).map(([exported, local]) => exported === local ? exported : `${local} as ${exported}`).join(", ")} }
+		}
+	}
+	return exportsByModule;
 }
-export { __json_default_export as default }`;
+function setExportTypeOnly(exports, name, typeOnly) {
+	const current = exports.get(name);
+	if (current === false || current === typeOnly) return false;
+	if (current === void 0 || !typeOnly) {
+		exports.set(name, typeOnly);
+		return true;
+	}
+	return false;
+}
+/**
+* Collects all TSTypeParameter nodes from the given node and groups them by
+* their name. One name can associate with one or more type parameters. These
+* names will be used as the parameter name in the generated JavaScript
+* dependency function.
+*/
+function collectParams(node) {
+	const typeParams = [];
+	walk(node, { leave(node) {
+		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => name));
+	} });
+	const paramMap = /* @__PURE__ */ new Map();
+	for (const typeParam of typeParams) {
+		const name = typeParam.name;
+		const group = paramMap.get(name);
+		if (group) group.push(typeParam);
+		else paramMap.set(name, [typeParam]);
+	}
+	return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
+		name,
+		typeParams
+	}));
+}
+async function collectDependencies(context, node, importer, namespaceStmts, children, identifierMap) {
+	const deps = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const preserveImportTypeCache = /* @__PURE__ */ new Map();
+	const inferredStack = [];
+	let currentInferred = /* @__PURE__ */ new Set();
+	function isInferred(node) {
+		return node.type === "Identifier" && currentInferred.has(node.name);
+	}
+	await walkAsync(node, {
+		enter(node) {
+			if (node.type === "TSConditionalType") {
+				const inferred = collectInferredNames(node.extendsType);
+				inferredStack.push(inferred);
+			}
+		},
+		async leave(node, path) {
+			const { parent } = path;
+			if (node.type === "TSConditionalType") inferredStack.pop();
+			else if (parent?.type === "TSConditionalType") {
+				const trueBranch = parent.trueType === node;
+				currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
+			} else currentInferred = /* @__PURE__ */ new Set();
+			if (node.type === "ExportNamedDeclaration") {
+				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
+			} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
+			else if (node.type === "ClassDeclaration") {
+				if (node.superClass) addDependency(node.superClass);
+				if (node.implements) for (const implement of node.implements) addDependency(implement.expression);
+			} else if (is.oneOf(node, [
+				"Property",
+				"PropertyDefinition",
+				"TSAbstractPropertyDefinition",
+				"MethodDefinition",
+				"TSAbstractMethodDefinition",
+				"TSPropertySignature",
+				"TSMethodSignature"
+			])) {
+				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
+				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
+			} else switch (node.type) {
+				case "TSTypeReference":
+					addDependency(TSEntityNameToRuntime(node.typeName));
+					break;
+				case "TSTypeQuery":
+					if (seen.has(node.exprName)) return;
+					if (node.exprName.type === "TSImportType") break;
+					addDependency(TSEntityNameToRuntime(node.exprName));
+					break;
+				case "TSImportType": {
+					seen.add(node);
+					const { source, qualifier } = node;
+					const resolved = await context.resolve(source.value, importer);
+					if (!resolved || !!resolved.external) {
+						preserveImportTypeCache.set(source.value, true);
+						break;
 					}
+					const dep = importNamespace(node, qualifier, source, namespaceStmts, identifierMap);
+					if (dep) addDependency(dep);
+					break;
 				}
-				return {
-					code: dtsCode || "",
-					map
-				};
 			}
-		},
-		generateBundle: emitDtsOnly ? (options, bundle) => {
-			for (const fileName of Object.keys(bundle)) if (bundle[fileName].type === "chunk" && !RE_DTS.test(fileName) && !RE_DTS_MAP.test(fileName)) delete bundle[fileName];
-		} : void 0,
-		async buildEnd() {
-			tscWorker?.kill();
-			tscWorker = void 0;
-			await tsgoContext?.dispose();
-			tsgoContext = void 0;
-			if (newContext) tscContext = void 0;
-		},
-		watchChange(id) {
-			if (tscModule) invalidateContextFile(tscContext || globalContext, id);
+			if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
 		}
-	};
-}
-function createTscWorker() {
-	const childProcess = fork(new URL(WORKER_URL, import.meta.url), {
-		stdio: "inherit",
-		serialization: "advanced"
 	});
-	const pending = /* @__PURE__ */ new Map();
-	let nextId = 0;
-	childProcess.on("message", (response) => {
-		const handler = pending.get(response.id);
-		if (!handler) return;
-		pending.delete(response.id);
-		if (response.error) handler.reject(response.error);
-		else handler.resolve(response.result);
-	});
-	childProcess.on("exit", (code) => {
-		for (const handler of pending.values()) handler.reject(/* @__PURE__ */ new Error(`tsc worker exited with code ${code}`));
-		pending.clear();
+	return Array.from(deps);
+	function addDependency(node) {
+		if (isThisExpression(node) || isInferred(node)) return;
+		deps.add(node);
+	}
+}
+function importNamespace(node, imported, source, namespaceStmts, identifierMap) {
+	const sourceText = source.value.replaceAll(/\W/g, "_");
+	const localName = `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`;
+	let local = b.Identifier({ name: localName });
+	if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
+	else namespaceStmts.set(source.value, {
+		stmt: b.ImportDeclaration({
+			specifiers: [b.ImportNamespaceSpecifier({ local })],
+			source,
+			phase: null,
+			attributes: []
+		}),
+		local
 	});
+	if (imported) {
+		const importedLeft = getIdFromTSEntityName(imported);
+		if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
+		overwriteNode(importedLeft, b.TSQualifiedName({
+			left: local,
+			right: { ...importedLeft }
+		}));
+		local = imported;
+	}
+	let replacement = node;
+	if (node.typeArguments) {
+		overwriteNode(node, b.TSTypeReference({
+			typeName: local,
+			typeArguments: node.typeArguments
+		}));
+		replacement = local;
+	} else overwriteNode(node, local);
 	return {
-		emit: (options) => new Promise((resolve, reject) => {
-			const id = nextId++;
-			pending.set(id, {
-				resolve,
-				reject
-			});
-			childProcess.send({
-				id,
-				options
-			});
-		}),
-		kill: () => childProcess.kill()
+		...TSEntityNameToRuntime(local),
+		replace(newNode) {
+			overwriteNode(replacement, newNode);
+		}
 	};
 }
-function collectJsonExportMap(code) {
-	const exportMap = /* @__PURE__ */ new Map();
-	const { program } = parse$1(code, {
-		sourceType: "module",
-		lang: "dts"
+function isChildSymbol(node, parent) {
+	if (node.type === "Identifier") return true;
+	if (is.oneOf(parent, ["TSPropertySignature", "TSMethodSignature"]) && parent.key === node) return true;
+	return false;
+}
+function collectInferredNames(node) {
+	const inferred = [];
+	walk(node, { enter(node) {
+		if (node.type === "TSInferType" && node.typeParameter) inferred.push(node.typeParameter.name.name);
+	} });
+	return inferred;
+}
+const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
+function collectReferenceDirectives(comment, negative = false) {
+	return comment.filter((c) => REFERENCE_RE.test(c.value) !== negative);
+}
+const SOURCE_MAP_PRAGMA_RE = /^#\s*source(?:Mapping)?URL=/;
+function isSourceMapPragma(comment) {
+	return SOURCE_MAP_PRAGMA_RE.test(comment.value);
+}
+function isCjsDtsInputSyntax(node) {
+	return node.type === "TSExportAssignment" || node.type === "TSImportEqualsDeclaration" && node.moduleReference.type === "TSExternalModuleReference";
+}
+/**
+* Check if the given node is a {@link RuntimeBindingVariableDeclration}
+*/
+function isRuntimeBindingVariableDeclaration(node) {
+	return node?.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].type === "VariableDeclarator" && node.declarations[0].id.type === "ArrayPattern" && isRuntimeBindingArrayExpression(node.declarations[0].init);
+}
+/**
+* Check if the given node is a {@link RuntimeBindingArrayExpression}
+*/
+function isRuntimeBindingArrayExpression(node) {
+	return node?.type === "ArrayExpression" && isRuntimeBindingArrayElements(node.elements);
+}
+/**
+* Check if the given array is a {@link RuntimeBindingArrayElements}
+*/
+function isRuntimeBindingArrayElements(elements) {
+	const [declarationId, deps, children, effect] = elements;
+	return is.NumericLiteral(declarationId) && deps?.type === "ArrowFunctionExpression" && children?.type === "ArrayExpression" && (!effect || effect.type === "CallExpression");
+}
+function runtimeBindingArrayExpression(elements) {
+	return b.ArrayExpression({ elements: [...elements] });
+}
+function isThisExpression(node) {
+	return is.Identifier(node, "this") || node.type === "ThisExpression" || node.type === "MemberExpression" && isThisExpression(node.object);
+}
+function isInfer(node) {
+	return is.Identifier(node, "infer");
+}
+function TSEntityNameToRuntime(node) {
+	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
+	const left = TSEntityNameToRuntime(node.left);
+	return Object.assign(node, {
+		type: "MemberExpression",
+		object: left,
+		property: node.right,
+		computed: false
 	});
-	for (const decl of program.body) if (decl.type === "ExportNamedDeclaration") {
-		if (decl.declaration) {
-			if (decl.declaration.type === "VariableDeclaration") {
-				for (const vdecl of decl.declaration.declarations) if (vdecl.id.type === "Identifier") exportMap.set(vdecl.id.name, vdecl.id.name);
-			} else if (decl.declaration.type === "TSModuleDeclaration" && decl.declaration.id.type === "Identifier") exportMap.set(decl.declaration.id.name, decl.declaration.id.name);
-		} else if (decl.specifiers.length) {
-			for (const spec of decl.specifiers) if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") exportMap.set(spec.exported.name, spec.local.type === "Identifier" ? spec.local.name : spec.exported.name);
+}
+function getIdFromTSEntityName(node) {
+	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
+	return getIdFromTSEntityName(node.left);
+}
+function isReferenceId(node) {
+	return is.oneOf(node, ["Identifier", "MemberExpression"]);
+}
+function isHelperImport(node) {
+	return node.type === "ImportDeclaration" && node.specifiers.length && node.specifiers.every((spec) => spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && ["__exportAll", "__reExport"].includes(spec.local.name));
+}
+/**
+* patch `.d.ts` suffix in import source to `.js`
+*/
+function patchImportExport(node, exportInfo, cjsDefault) {
+	if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && !node.specifiers.length && !node.attributes?.length) return false;
+	if (node.type === "ImportDeclaration" && node.specifiers.length) {
+		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
+	}
+	if (is.oneOf(node, [
+		"ImportDeclaration",
+		"ExportAllDeclaration",
+		"ExportNamedDeclaration"
+	])) {
+		if (node.type === "ExportAllDeclaration" && node.source && exportInfo.typeOnlyExportAllSources.has(node.source.value)) node.exportKind = "type";
+		if (node.type === "ExportNamedDeclaration" && exportInfo.typeOnlyNames.size) {
+			for (const spec of node.specifiers) {
+				const name = nameOf(spec.exported);
+				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
+				else node.exportKind = "type";
+			}
+			normalizeTypeOnlyExport(node);
+		}
+		if (node.source?.value && RE_DTS.test(node.source.value)) {
+			node.source.value = filename_dts_to(node.source.value, "js");
+			return node;
+		}
+		if (cjsDefault && node.type === "ExportNamedDeclaration" && !node.source && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && nameOf(node.specifiers[0].exported) === "default") {
+			const defaultExport = node.specifiers[0];
+			return b.TSExportAssignment({ expression: defaultExport.local });
 		}
 	}
-	return exportMap;
 }
-/** `declare const _exports` mode */
-function collectJsonExports(code) {
-	const exports = [];
-	const { program } = parse$1(code, {
-		sourceType: "module",
-		lang: "dts"
+function normalizeTypeOnlyExport(node) {
+	if (node.declaration || !node.specifiers.length) return;
+	for (const specifier of node.specifiers) if (specifier.type !== "ExportSpecifier" || specifier.exportKind !== "type") return;
+	node.exportKind = "type";
+	for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+}
+/**
+* Handle `__exportAll` call
+*/
+function patchTsNamespace(nodes) {
+	const removed = /* @__PURE__ */ new Set();
+	for (const [i, node] of nodes.entries()) {
+		const result = getExportAllNamespace(node);
+		if (!result) continue;
+		const [binding, exports] = result;
+		if (!exports.properties.length) continue;
+		const namespaceExport = b.ExportNamedDeclaration({
+			declaration: null,
+			specifiers: exports.properties.filter((property) => property.type === "Property").map((property) => {
+				const local = property.value.body;
+				const exported = property.key;
+				return b.ExportSpecifier({
+					local,
+					exported
+				});
+			}),
+			source: null,
+			attributes: []
+		});
+		nodes[i] = b.TSModuleDeclaration({
+			id: binding,
+			body: b.TSModuleBlock({ body: [namespaceExport] }),
+			kind: "namespace",
+			declare: true,
+			global: false
+		});
+	}
+	return nodes.filter((node) => !removed.has(node));
+}
+function getExportAllNamespace(node) {
+	if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
+	return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
+}
+/**
+* Handle `__reExport` call
+*/
+function patchReExport(nodes) {
+	const exportsNames = /* @__PURE__ */ new Map();
+	for (const [i, node] of nodes.entries()) if (node.type === "ImportDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ImportSpecifier" && node.specifiers[0].local.type === "Identifier" && node.specifiers[0].local.name.endsWith("_exports")) exportsNames.set(node.specifiers[0].local.name, node.specifiers[0].local.name);
+	else if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && is.Identifier(node.expression.callee, "__reExport")) {
+		const args = node.expression.arguments;
+		exportsNames.set(args[0].name, args[1].name);
+	} else if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].init?.type === "MemberExpression" && node.declarations[0].init.object.type === "Identifier" && exportsNames.has(node.declarations[0].init.object.name)) nodes[i] = b.TSTypeAliasDeclaration({
+		id: b.Identifier({ name: node.declarations[0].id.name }),
+		typeParameters: null,
+		typeAnnotation: b.TSTypeReference({
+			typeName: b.TSQualifiedName({
+				left: b.Identifier({ name: exportsNames.get(node.declarations[0].init.object.name) }),
+				right: b.Identifier({ name: node.declarations[0].init.property.name })
+			}),
+			typeArguments: null
+		}),
+		declare: false
 	});
-	const members = program.body[0].declarations[0].id.typeAnnotation.typeAnnotation.members;
-	for (const member of members) if (member.key.type === "Identifier") exports.push(member.key.name);
-	else if (is.StringLiteral(member.key)) exports.push(member.key.value);
-	return exports;
+	else if (node.type === "ExportNamedDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && node.specifiers[0].local.type === "Identifier" && exportsNames.has(node.specifiers[0].local.name)) node.specifiers[0].local.name = exportsNames.get(node.specifiers[0].local.name);
+	return nodes;
+}
+function rewriteImportExport(node, set) {
+	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
+		else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+		if (node.type === "ImportDeclaration") node.importKind = "value";
+		else if (node.type === "ExportNamedDeclaration") node.exportKind = "value";
+		return true;
+	} else if (node.type === "ExportAllDeclaration") {
+		node.exportKind = "value";
+		return true;
+	} else if (node.type === "TSImportEqualsDeclaration") {
+		if (node.moduleReference.type === "TSExternalModuleReference") set(b.ImportDeclaration({
+			specifiers: [b.ImportDefaultSpecifier({ local: node.id })],
+			source: node.moduleReference.expression,
+			phase: null,
+			attributes: []
+		}));
+		return true;
+	} else if (node.type === "TSExportAssignment" && node.expression.type === "Identifier") {
+		set(b.ExportNamedDeclaration({
+			declaration: null,
+			specifiers: [b.ExportSpecifier({
+				local: node.expression,
+				exported: b.Identifier({ name: "default" })
+			})],
+			source: null,
+			attributes: []
+		}));
+		return true;
+	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
+		set(b.ExportNamedDeclaration({
+			declaration: null,
+			specifiers: [b.ExportSpecifier({
+				local: node.declaration,
+				exported: b.Identifier({ name: "default" })
+			})],
+			source: null,
+			attributes: []
+		}));
+		return true;
+	}
+	return false;
+}
+function overwriteNode(node, newNode) {
+	for (const key of Object.keys(node)) Reflect.deleteProperty(node, key);
+	Object.assign(node, newNode);
+	return node;
+}
+function inheritNodeComments(oldNode, newNode) {
+	newNode.comments ||= [];
+	const pragmas = oldNode.comments?.filter((comment) => comment.position === "before" && comment.value.startsWith("#") && !isSourceMapPragma(comment));
+	if (pragmas) newNode.comments.unshift(...pragmas);
+	newNode.comments = newNode.comments.filter((comment) => !REFERENCE_RE.test(comment.value) && !isSourceMapPragma(comment));
+	return newNode;
+}
+function getIdentifierIndex(identifierMap, name) {
+	if (name in identifierMap) return ++identifierMap[name];
+	return identifierMap[name] = 0;
+}
+const require = createRequire(import.meta.url);
+const debug$3 = createDebug("rolldown-plugin-dts:vue");
+const RE_VUE = /\.vue$/;
+function getVueVolarPlugin() {
+	const ts = requireTS(`Vue support requires TypeScript to be installed. Please install \`typescript\` package.`);
+	const [volarTypeScript, vue] = loadVueLanguageTools();
+	const getLanguagePlugin = (ts, options) => {
+		const $rootDir = options.options.$rootDir;
+		const $configRaw = options.options.$configRaw;
+		const resolver = new vue.CompilerOptionsResolver(ts, ts.sys.readFile);
+		resolver.addConfig($configRaw?.vueCompilerOptions ?? {}, $rootDir);
+		const vueOptions = resolver.build();
+		return vue.createVueLanguagePlugin(ts, options.options, vueOptions, (id) => id);
+	};
+	return {
+		extensionPatterns: [RE_VUE],
+		tsFileExtensionInfos: [{
+			extension: "vue",
+			isMixedContent: true,
+			scriptKind: ts.ScriptKind.Deferred
+		}],
+		volarTypeScript,
+		create(ts, options) {
+			return [getLanguagePlugin(ts, options)];
+		},
+		toTsFilename(id) {
+			return id.replace(RE_VUE, ".vue.ts");
+		}
+	};
+}
+function loadVueLanguageTools() {
+	debug$3("loading vue language tools");
+	try {
+		const vueTscPath = require.resolve("vue-tsc");
+		return [require(require.resolve("@volar/typescript", { paths: [vueTscPath] })), require(require.resolve("@vue/language-core", { paths: [vueTscPath] }))];
+	} catch (cause) {
+		debug$3("vue language tools not found", cause);
+		throw new Error("Failed to load vue language tools. Please manually install vue-tsc.", { cause });
+	}
 }
+var VolarContext = class {
+	plugins;
+	patterns;
+	constructor(plugins) {
+		this.plugins = plugins;
+		this.patterns = plugins.flatMap((plugin) => plugin.extensionPatterns);
+	}
+	isVolarFile(id) {
+		return this.patterns.some((pattern) => pattern.test(id));
+	}
+	getExtraFileExtensions() {
+		if (!this.plugins.length) return;
+		return this.plugins.flatMap((plugin) => plugin.tsFileExtensionInfos);
+	}
+	getCreateProgram(ts) {
+		if (!this.plugins.length) return ts.createProgram;
+		const { proxyCreateProgram } = this.plugins[0].volarTypeScript;
+		return proxyCreateProgram(ts, ts.createProgram, (ts, options) => {
+			const setups = [];
+			const plugins = [];
+			for (const plugin of this.plugins) {
+				const result = plugin.create(ts, options);
+				if (Array.isArray(result)) plugins.push(...result);
+				else {
+					if (result.setup) setups.push(result.setup);
+					plugins.push(...result.languagePlugins);
+				}
+			}
+			return {
+				setup: setups.length ? (language) => {
+					for (const setup of setups) setup(language);
+				} : void 0,
+				languagePlugins: plugins
+			};
+		});
+	}
+	toTsFilename(id) {
+		for (const plugin of this.plugins) if (plugin.toTsFilename && plugin.extensionPatterns.some((pattern) => pattern.test(id))) return plugin.toTsFilename(id);
+		return id;
+	}
+};
 const debug$2 = createDebug("rolldown-plugin-dts:options");
 let warnedTsgo = false;
-function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = false, emitDtsOnly = false, tsconfig, tsconfigRaw: overriddenTsconfigRaw = {}, compilerOptions = {}, sourcemap, resolver = "oxc", cjsDefault = false, sideEffects = false, logger = console, build = false, incremental = false, vue = false, tsMacro = false, parallel = false, eager = false, newContext = false, emitJs, oxc, tsgo }) {
+function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = false, emitDtsOnly = false, tsconfig, tsconfigRaw: overriddenTsconfigRaw = {}, compilerOptions = {}, sourcemap, resolver = "oxc", cjsDefault = false, sideEffects = false, logger = console, volarPlugins, build = false, incremental = false, vue = false, parallel = false, eager = false, newContext = false, emitJs, oxc, tsgo }) {
 	let resolvedTsconfig;
 	if (tsconfig === true || tsconfig == null) {
 		const { config, path } = at(cwd) || {};
@@ -3061,20 +2470,19 @@ function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = fals
 		...overriddenTsconfigRaw,
 		compilerOptions
 	};
-	if (vue || tsMacro) {
-		if (isTS70Installed()) throw new Error("TypeScript 7.0 does not yet have a stable API and is experimental. The `vue` and `tsMacro` options are not yet supported with TypeScript 7.0.");
-		if (generator && generator !== "tsc") logger.warn("The `vue` and `tsMacro` options are enabled, which requires the `tsc` generator. The `generator` option is ignored.");
+	volarPlugins ||= [];
+	if (vue) volarPlugins.push(getVueVolarPlugin());
+	if (volarPlugins.length) {
+		if (isTS70Installed()) throw new Error("TypeScript 7.0 does not yet have a stable API and is experimental. The `vue` and `volarPlugins` options are not yet supported with TypeScript 7.0.");
+		if (generator && generator !== "tsc") logger.warn("The `vue` and `volarPlugins` options are enabled, which requires the `tsc` generator. The `generator` option is ignored.");
 		generator = "tsc";
 	}
+	const volarContext = new VolarContext(volarPlugins);
 	if (!generator) if (tsgo) generator = "tsgo";
 	else if (oxc || compilerOptions?.isolatedDeclarations) generator = "oxc";
 	else if (isTS70Installed()) generator = "tsgo";
 	else generator = "tsc";
-	if (generator === "tsc") try {
-		__require$1.resolve("typescript");
-	} catch {
-		throw new Error("TypeScript is not installed. You can install `typescript` package, or enable `isolatedDeclarations` in your `tsconfig.json` to use Oxc instead.");
-	}
+	if (generator === "tsc") requireTS("Or enable `isolatedDeclarations` in your `tsconfig.json` to use Oxc instead.");
 	else if (generator === "tsgo") {
 		if (!tsconfig) throw new Error("tsgo generator requires a tsconfig file to be specified.");
 		if (!warnedTsgo) {
@@ -3103,12 +2511,11 @@ function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = fals
 		sideEffects,
 		build,
 		incremental,
-		vue,
-		tsMacro,
 		parallel,
 		eager,
 		newContext,
 		emitJs,
+		volarContext,
 		oxc,
 		tsgo,
 		logger
@@ -3117,10 +2524,10 @@ function resolveOptions({ generator, entry, cwd = process.cwd(), dtsInput = fals
 	return resolved;
 }
 const debug$1 = createDebug("rolldown-plugin-dts:resolver");
-function isSourceFile(id) {
-	return RE_TS.test(id) || RE_VUE.test(id) || RE_JSON.test(id);
-}
-function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffects }) {
+function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffects, volarContext }) {
+	function isSourceFile(id) {
+		return RE_TS.test(id) || RE_JSON.test(id) || volarContext.isVolarFile(id);
+	}
 	const baseDtsResolver = createResolver({
 		tsconfig,
 		resolveNodeModules: true,
@@ -3166,7 +2573,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 					debug$1("Resolving dts import to source file:", id);
 					await this.load({ id: dtsResolution });
 					return {
-						id: filename_to_dts(dtsResolution),
+						id: filename_to_dts(dtsResolution, volarContext),
 						moduleSideEffects
 					};
 				}
@@ -3176,7 +2583,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 	async function resolveDtsPath(id, importer, rolldownResolution) {
 		let dtsPath;
 		if (resolver === "tsc") {
-			const { tscResolve } = await import("./resolver-DtsKFXi2-B8Z3WwZh.js");
+			const { tscResolve } = await import("./resolver-cwLsPb2o-oj1hqxK6.js");
 			dtsPath = tscResolve(id, importer, cwd, tsconfig, tsconfigRaw);
 		} else dtsPath = baseDtsResolver(id, importer);
 		debug$1("Using %s for dts import: %O -> %O", resolver, id, dtsPath);