rolldown-plugin-dts 0.26.0 → 0.27.0

package/dist/index.mjs

@@ -2,10 +2,11 @@ import { a as RE_JSON, c as RE_TS, d as filename_js_to_dts, f as filename_to_dts
 import { createContext, globalContext, invalidateContextFile } from "./tsc-context.mjs";
 import { createDebug } from "obug";
 import { importerId, include } from "rolldown/filter";
-import { generate } from "@babel/generator";
-import { isIdentifierName } from "@babel/helper-validator-identifier";
-import { parse } from "@babel/parser";
-import { isDeclarationType, isIdentifierOf, isTypeOf, resolveString, walkAST, walkASTAsync } from "ast-kit";
+import { b, is } from "yuku-ast";
+import { isIdentifierName } from "yuku-ast/identifier";
+import { nameOf } from "yuku-ast/utils";
+import { print } from "yuku-codegen";
+import { parse, walk } from "yuku-parser";
 import { fork, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { access, mkdtemp, readFile, rm } from "node:fs/promises";
@@ -97,39 +98,36 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		let file;
 		try {
 			file = parse(code, {
-				plugins: [["typescript", { dts: true }], "decoratorAutoAccessors"],
+				lang: "dts",
 				sourceType: "module",
-				errorRecovery: true,
-				createParenthesizedExpressions: true
+				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, comments } = file;
+		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(RE_NODE_MODULES.test(id) ? `${id} uses CommonJS dts syntax. CommonJS dts modules cannot be reliably bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `${id} uses CommonJS dts syntax. rolldown-plugin-dts does not support reliably bundling CommonJS dts input.`);
-		}
-		if (comments) {
-			const directives = collectReferenceDirectives(comments);
-			commentsMap.set(id, directives);
+			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.id.type === "StringLiteral" && 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 && 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 = isTypeOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && !!stmt.declaration;
+			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" && !isDeclarationType(decl)) continue;
-			if (isTypeOf(decl, [
+			if (decl.type !== "TSDeclareFunction" && !is.Declaration(decl)) continue;
+			if (is.oneOf(decl, [
 				"TSEnumDeclaration",
 				"ClassDeclaration",
 				"FunctionDeclaration",
@@ -142,17 +140,11 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			else if ("id" in decl && decl.id) {
 				let binding = decl.id;
 				if (binding.type === "TSQualifiedName") binding = getIdFromTSEntityName(binding);
-				binding = sideEffect ? {
-					type: "Identifier",
-					name: `_${getIdentifierIndex(identifierMap, "")}`
-				} : 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 = {
-					type: "Identifier",
-					name: "export_default"
-				};
+				const binding = b.identifier("export_default");
 				bindings.push(binding);
 				decl.id = binding;
 			}
@@ -160,115 +152,58 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			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.leadingComments = stmt.leadingComments;
-			const declarationIdNode = {
-				type: "NumericLiteral",
-				value: registerDeclaration({
-					decl,
-					deps,
-					bindings,
-					params,
-					children
-				})
-			};
-			const depsBody = {
-				type: "ArrayExpression",
-				elements: deps
-			};
-			const depsNode = {
-				type: "ArrowFunctionExpression",
-				params: params.map(({ name }) => ({
-					type: "Identifier",
-					name
-				})),
-				body: depsBody,
-				async: false,
-				expression: true
-			};
-			const childrenNode = {
-				type: "ArrayExpression",
-				elements: children.map((node) => ({
-					type: "StringLiteral",
-					value: "",
-					start: node.start,
-					end: node.end,
-					loc: node.loc
-				}))
-			};
-			const sideEffectNode = sideEffect && {
-				type: "CallExpression",
-				callee: {
-					type: "Identifier",
-					name: "sideEffect"
-				},
-				arguments: [bindings[0]]
-			};
+			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 = {
-				type: "VariableDeclaration",
-				kind: "var",
-				declarations: [{
-					type: "VariableDeclarator",
-					id: {
-						...bindings[0],
-						typeAnnotation: null
-					},
-					init: runtimeArrayNode
-				}, ...bindings.slice(1).map((binding) => ({
-					type: "VariableDeclarator",
-					id: {
-						...binding,
-						typeAnnotation: null
-					}
-				}))]
-			};
+			const runtimeAssignment = b.variableDeclaration("var", [b.variableDeclarator({
+				...bindings[0],
+				typeAnnotation: null
+			}, runtimeArrayNode), ...bindings.slice(1).map((binding) => b.variableDeclarator({
+				...binding,
+				typeAnnotation: null
+			}))]);
 			if (isDefaultExport) {
-				appendStmts.push({
-					type: "ExportNamedDeclaration",
-					declaration: null,
-					specifiers: [{
-						type: "ExportSpecifier",
-						local: bindings[0],
-						exported: {
-							type: "Identifier",
-							name: "default"
-						}
-					}],
-					source: null,
-					attributes: null
-				});
+				appendStmts.push(b.exportNamedDeclaration(null, [b.exportSpecifier(bindings[0], b.identifier("default"))]));
 				setStmt(runtimeAssignment);
 			} else setDecl(runtimeAssignment);
 		}
-		if (sideEffects) appendStmts.push({
-			type: "ExpressionStatement",
-			expression: {
-				type: "CallExpression",
-				callee: {
-					type: "Identifier",
-					name: "sideEffect"
-				},
-				arguments: []
-			}
-		});
+		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 = generate(file, {
+		const result = print(program, {
 			comments: false,
-			sourceMaps: sourcemap,
-			sourceFileName: id
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: id
+			} }
 		});
 		return {
 			code: result.code,
-			map: result.map
+			map: result.map ?? null
 		};
 	}
 	function renderChunk(code, chunk) {
@@ -276,7 +211,11 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
 		let file;
 		try {
-			file = parse(code, { sourceType: "module" });
+			file = parse(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 });
 		}
@@ -293,9 +232,9 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			const [declarationIdNode, depsFn, children] = node.declarations[0].init.elements;
 			const declarationId = declarationIdNode.value;
 			const declaration = getDeclaration(declarationId);
-			walkAST(declaration.decl, { enter(node) {
-				if (node.type === "CommentBlock") return;
-				delete node.loc;
+			if (sourcemap) walk(declaration.decl, { enter(node) {
+				node.start = void 0;
+				node.end = void 0;
 			} });
 			for (const [i, decl] of node.declarations.entries()) {
 				const transformedBinding = {
@@ -304,7 +243,10 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 				};
 				overwriteNode(declaration.bindings[i], transformedBinding);
 			}
-			for (const [i, child] of children.elements.entries()) Object.assign(declaration.children[i], { loc: child.loc });
+			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;
@@ -313,20 +255,21 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			const transformedDeps = depsFn.body.elements;
 			for (const [i, originalDep] of declaration.deps.entries()) {
 				let transformedDep = transformedDeps[i];
-				if (transformedDep.type === "UnaryExpression" && transformedDep.operator === "void") transformedDep = {
-					type: "Identifier",
-					name: "undefined",
-					loc: transformedDep.loc,
-					start: transformedDep.start,
-					end: transformedDep.end
-				};
-				else if (isInfer(transformedDep)) transformedDep.name = "__Infer";
+				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);
 			}
 			return inheritNodeComments(node, declaration.decl);
 		}).filter((node) => !!node);
-		if (program.body.length === 0) return "export { };";
+		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) {
@@ -342,16 +285,24 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			}
 		}
 		if (comments.size) {
-			program.body[0].leadingComments ||= [];
-			program.body[0].leadingComments.unshift(...comments);
+			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 = generate(file, {
-			sourceMaps: sourcemap,
-			sourceFileName: chunk.fileName
+		const result = print(program, {
+			comments: true,
+			...sourcemap && { sourceMaps: {
+				source: code,
+				sourceFileName: chunk.fileName
+			} }
 		});
 		return {
 			code: result.code,
-			map: result.map
+			map: result.map ?? null
 		};
 	}
 	function registerDeclaration(info) {
@@ -400,7 +351,7 @@ function collectPatternNames(node) {
 	return [];
 }
 function isTypeOnlyExport(node, specifier) {
-	return node.exportKind === "type" || "exportKind" in specifier && specifier.exportKind === "type";
+	return node.exportKind === "type" || specifier.exportKind === "type";
 }
 async function collectExportInfo(context, node, id, info) {
 	if (node.type === "ExportNamedDeclaration") {
@@ -411,20 +362,15 @@ async function collectExportInfo(context, node, id, info) {
 		const source = await resolveExportSource(context, node.source, id);
 		for (const specifier of node.specifiers) {
 			const typeOnly = isTypeOnlyExport(node, specifier);
-			if (specifier.type === "ExportSpecifier") {
-				const exported = resolveString(specifier.exported);
-				const local = resolveString(specifier.local);
-				if (source) info.reExports.push({
-					source,
-					local,
-					exported,
-					typeOnly
-				});
-				else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
-			} else {
-				const exported = resolveString(specifier.exported);
-				info.exports.set(exported, typeOnly);
-			}
+			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;
 	}
@@ -432,11 +378,17 @@ async function collectExportInfo(context, node, id, info) {
 		info.exports.set("default", false);
 		return;
 	}
-	if (node.type === "ExportAllDeclaration") info.exportAlls.push({
-		source: await resolveExportSource(context, node.source, id),
-		rawSource: node.source.value,
-		typeOnly: node.exportKind === "type"
-	});
+	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;
@@ -508,11 +460,8 @@ function setExportTypeOnly(exports, name, typeOnly) {
 */
 function collectParams(node) {
 	const typeParams = [];
-	walkAST(node, { leave(node) {
-		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => typeof name === "string" ? {
-			type: "Identifier",
-			name
-		} : name));
+	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) {
@@ -530,20 +479,28 @@ async function collectDependencies(context, node, importer, namespaceStmts, chil
 	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);
 	}
-	await walkASTAsync(node, {
+	walk(node, {
 		enter(node) {
 			if (node.type === "TSConditionalType") {
 				const inferred = collectInferredNames(node.extendsType);
 				inferredStack.push(inferred);
 			}
-			return Promise.resolve();
 		},
-		async leave(node, parent) {
+		leave(node, path) {
+			const { parent } = path;
 			if (node.type === "TSConditionalType") inferredStack.pop();
 			else if (parent?.type === "TSConditionalType") {
 				const trueBranch = parent.trueType === node;
@@ -554,16 +511,14 @@ async function collectDependencies(context, node, importer, namespaceStmts, chil
 			} 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) {
-					if (implement.type === "ClassImplements") throw new Error("Unexpected Flow syntax");
-					addDependency(implement.expression);
-				}
-			} else if (isTypeOf(node, [
-				"ObjectMethod",
-				"ObjectProperty",
-				"ClassProperty",
+				if (node.implements) for (const implement of node.implements) addDependency(implement.expression);
+			} else if (is.oneOf(node, [
+				"Property",
+				"PropertyDefinition",
+				"TSAbstractPropertyDefinition",
+				"MethodDefinition",
+				"TSAbstractMethodDefinition",
 				"TSPropertySignature",
-				"TSDeclareMethod",
 				"TSMethodSignature"
 			])) {
 				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
@@ -580,7 +535,7 @@ async function collectDependencies(context, node, importer, namespaceStmts, chil
 				case "TSImportType": {
 					seen.add(node);
 					const { source, qualifier } = node;
-					const dep = await importNamespace(context, importer, node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
+					const dep = importNamespace(node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
 					if (dep) addDependency(dep);
 					break;
 				}
@@ -594,49 +549,25 @@ async function collectDependencies(context, node, importer, namespaceStmts, chil
 		deps.add(node);
 	}
 }
-async function importNamespace(context, importer, node, imported, source, namespaceStmts, identifierMap, preserveCache) {
-	let preserve = preserveCache.get(source.value);
-	if (preserve === void 0) {
-		const resolved = await context.resolve(source.value, importer);
-		preserve = !resolved || !!resolved.external;
-		preserveCache.set(source.value, preserve);
-	}
-	if (preserve) return;
+function importNamespace(node, imported, source, namespaceStmts, identifierMap, preserveCache) {
+	if (preserveCache.get(source.value) ?? true) return;
 	const sourceText = source.value.replaceAll(/\W/g, "_");
-	let local = {
-		type: "Identifier",
-		name: `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`
-	};
+	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: {
-			type: "ImportDeclaration",
-			specifiers: [{
-				type: "ImportNamespaceSpecifier",
-				local
-			}],
-			source,
-			attributes: null
-		},
+		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, {
-			type: "TSQualifiedName",
-			left: local,
-			right: { ...importedLeft }
-		});
+		overwriteNode(importedLeft, b.tsQualifiedName(local, { ...importedLeft }));
 		local = imported;
 	}
 	let replacement = node;
 	if (node.typeArguments) {
-		overwriteNode(node, {
-			type: "TSTypeReference",
-			typeName: local,
-			typeArguments: node.typeArguments
-		});
+		overwriteNode(node, b.tsTypeReference(local, node.typeArguments));
 		replacement = local;
 	} else overwriteNode(node, local);
 	return {
@@ -648,12 +579,12 @@ async function importNamespace(context, importer, node, imported, source, namesp
 }
 function isChildSymbol(node, parent) {
 	if (node.type === "Identifier") return true;
-	if (isTypeOf(parent, ["TSPropertySignature", "TSMethodSignature"]) && parent.key === node) return true;
+	if (is.oneOf(parent, ["TSPropertySignature", "TSMethodSignature"]) && parent.key === node) return true;
 	return false;
 }
 function collectInferredNames(node) {
 	const inferred = [];
-	walkAST(node, { enter(node) {
+	walk(node, { enter(node) {
 		if (node.type === "TSInferType" && node.typeParameter) inferred.push(node.typeParameter.name.name);
 	} });
 	return inferred;
@@ -662,6 +593,10 @@ 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";
 }
@@ -682,19 +617,16 @@ function isRuntimeBindingArrayExpression(node) {
 */
 function isRuntimeBindingArrayElements(elements) {
 	const [declarationId, deps, children, effect] = elements;
-	return declarationId?.type === "NumericLiteral" && deps?.type === "ArrowFunctionExpression" && children?.type === "ArrayExpression" && (!effect || effect.type === "CallExpression");
+	return is.NumericLiteral(declarationId) && deps?.type === "ArrowFunctionExpression" && children?.type === "ArrayExpression" && (!effect || effect.type === "CallExpression");
 }
 function runtimeBindingArrayExpression(elements) {
-	return {
-		type: "ArrayExpression",
-		elements
-	};
+	return b.arrayExpression([...elements]);
 }
 function isThisExpression(node) {
-	return isIdentifierOf(node, "this") || node.type === "ThisExpression" || node.type === "MemberExpression" && isThisExpression(node.object);
+	return is.Identifier(node, "this") || node.type === "ThisExpression" || node.type === "MemberExpression" && isThisExpression(node.object);
 }
 function isInfer(node) {
-	return isIdentifierOf(node, "infer");
+	return is.Identifier(node, "infer");
 }
 function TSEntityNameToRuntime(node) {
 	if (node.type === "Identifier" || node.type === "ThisExpression") return node;
@@ -711,7 +643,7 @@ function getIdFromTSEntityName(node) {
 	return getIdFromTSEntityName(node.left);
 }
 function isReferenceId(node) {
-	return isTypeOf(node, ["Identifier", "MemberExpression"]);
+	return is.oneOf(node, ["Identifier", "MemberExpression"]);
 }
 function isHelperImport(node) {
 	return node.type === "ImportDeclaration" && node.specifiers.every((spec) => spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && ["__exportAll", "__reExport"].includes(spec.local.name));
@@ -724,7 +656,7 @@ function patchImportExport(node, exportInfo, cjsDefault) {
 	if (node.type === "ImportDeclaration" && node.specifiers.length) {
 		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
 	}
-	if (isTypeOf(node, [
+	if (is.oneOf(node, [
 		"ImportDeclaration",
 		"ExportAllDeclaration",
 		"ExportNamedDeclaration"
@@ -732,7 +664,7 @@ function patchImportExport(node, exportInfo, cjsDefault) {
 		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 = resolveString(spec.exported);
+				const name = nameOf(spec.exported);
 				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
 				else node.exportKind = "type";
 			}
@@ -742,10 +674,10 @@ function patchImportExport(node, exportInfo, cjsDefault) {
 			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" && resolveString(node.specifiers[0].exported) === "default") return {
-			type: "TSExportAssignment",
-			expression: node.specifiers[0].local
-		};
+		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);
+		}
 	}
 }
 function normalizeTypeOnlyExport(node) {
@@ -764,27 +696,15 @@ function patchTsNamespace(nodes) {
 		if (!result) continue;
 		const [binding, exports] = result;
 		if (!exports.properties.length) continue;
-		nodes[i] = {
-			type: "TSModuleDeclaration",
-			id: binding,
+		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,
-			body: {
-				type: "TSModuleBlock",
-				body: [{
-					type: "ExportNamedDeclaration",
-					specifiers: exports.properties.filter((property) => property.type === "ObjectProperty").map((property) => {
-						return {
-							type: "ExportSpecifier",
-							local: property.value.body,
-							exported: property.key
-						};
-					}),
-					source: null,
-					declaration: null
-				}]
-			}
-		};
+			declare: true
+		});
 	}
 	return nodes.filter((node) => !removed.has(node));
 }
@@ -798,30 +718,10 @@ function getExportAllNamespace(node) {
 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" && isIdentifierOf(node.expression.callee, "__reExport")) {
+	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] = {
-		type: "TSTypeAliasDeclaration",
-		id: {
-			type: "Identifier",
-			name: node.declarations[0].id.name
-		},
-		typeAnnotation: {
-			type: "TSTypeReference",
-			typeName: {
-				type: "TSQualifiedName",
-				left: {
-					type: "Identifier",
-					name: exportsNames.get(node.declarations[0].init.object.name)
-				},
-				right: {
-					type: "Identifier",
-					name: node.declarations[0].init.property.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;
 }
@@ -836,54 +736,27 @@ function rewriteImportExport(node, set) {
 		node.exportKind = "value";
 		return true;
 	} else if (node.type === "TSImportEqualsDeclaration") {
-		if (node.moduleReference.type === "TSExternalModuleReference") set({
-			type: "ImportDeclaration",
-			specifiers: [{
-				type: "ImportDefaultSpecifier",
-				local: node.id
-			}],
-			source: node.moduleReference.expression
-		});
+		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({
-			type: "ExportNamedDeclaration",
-			specifiers: [{
-				type: "ExportSpecifier",
-				local: node.expression,
-				exported: {
-					type: "Identifier",
-					name: "default"
-				}
-			}]
-		});
+		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.expression, b.identifier("default"))]));
 		return true;
 	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
-		set({
-			type: "ExportNamedDeclaration",
-			specifiers: [{
-				type: "ExportSpecifier",
-				local: node.declaration,
-				exported: {
-					type: "Identifier",
-					name: "default"
-				}
-			}]
-		});
+		set(b.exportNamedDeclaration(null, [b.exportSpecifier(node.declaration, b.identifier("default"))]));
 		return true;
 	}
 	return false;
 }
 function overwriteNode(node, newNode) {
-	for (const key of Object.keys(node)) delete node[key];
+	for (const key of Object.keys(node)) Reflect.deleteProperty(node, key);
 	Object.assign(node, newNode);
 	return node;
 }
 function inheritNodeComments(oldNode, newNode) {
-	newNode.leadingComments ||= [];
-	const leadingComments = oldNode.leadingComments?.filter((comment) => comment.value.startsWith("#"));
-	if (leadingComments) newNode.leadingComments.unshift(...leadingComments);
-	newNode.leadingComments = collectReferenceDirectives(newNode.leadingComments, true);
+	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) {
@@ -963,8 +836,7 @@ function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental
 	* ])
 	*/
 	const inputAliasMap = /* @__PURE__ */ new Map();
-	let childProcess;
-	let rpc;
+	let tscWorker;
 	let tscModule;
 	let tscContext;
 	let tsgoContext;
@@ -973,13 +845,8 @@ function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental
 		name: "rolldown-plugin-dts:generate",
 		async buildStart(options) {
 			if (tsgo) tsgoContext = await runTsgo(rootDir, tsconfig, sourcemap, tsgo.path);
-			else if (!oxc) if (parallel) {
-				childProcess = fork(new URL(WORKER_URL, import.meta.url), { stdio: "inherit" });
-				rpc = (await import("birpc")).createBirpc({}, {
-					post: (data) => childProcess.send(data),
-					on: (fn) => childProcess.on("message", fn)
-				});
-			} else {
+			else if (!oxc) if (parallel) tscWorker = createTscWorker();
+			else {
 				tscModule = await import("./tsc.mjs");
 				if (newContext) tscContext = createContext();
 			}
@@ -1116,7 +983,7 @@ function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental
 						context: tscContext
 					};
 					let result;
-					if (parallel) result = await rpc.tscEmit(options);
+					if (parallel) result = await tscWorker.emit(options);
 					else result = tscModule.tscEmit(options);
 					if (result.error) return this.error(result.error);
 					dtsCode = result.code;
@@ -1150,7 +1017,8 @@ export { __json_default_export as default }`;
 			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() {
-			childProcess?.kill();
+			tscWorker?.kill();
+			tscWorker = void 0;
 			await tsgoContext?.dispose();
 			tsgoContext = void 0;
 			if (newContext) tscContext = void 0;
@@ -1160,12 +1028,44 @@ export { __json_default_export as default }`;
 		}
 	};
 }
+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 {
+		emit: (options) => new Promise((resolve, reject) => {
+			const id = nextId++;
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			childProcess.send({
+				id,
+				options
+			});
+		}),
+		kill: () => childProcess.kill()
+	};
+}
 function collectJsonExportMap(code) {
 	const exportMap = /* @__PURE__ */ new Map();
 	const { program } = parse(code, {
 		sourceType: "module",
-		plugins: [["typescript", { dts: true }]],
-		errorRecovery: true
+		lang: "dts"
 	});
 	for (const decl of program.body) if (decl.type === "ExportNamedDeclaration") {
 		if (decl.declaration) {
@@ -1183,11 +1083,11 @@ function collectJsonExports(code) {
 	const exports = [];
 	const { program } = parse(code, {
 		sourceType: "module",
-		plugins: [["typescript", { dts: true }]]
+		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 (member.key.type === "StringLiteral") exports.push(member.key.value);
+	else if (is.StringLiteral(member.key)) exports.push(member.key.value);
 	return exports;
 }
 //#endregion