rolldown-plugin-dts 0.8.6 → 0.9.0

package/dist/index.d.ts

@@ -3,53 +3,82 @@ import { IsolatedDeclarationsOptions } from "oxc-transform";
 import { Plugin } from "rolldown";
 
 //#region src/fake-js.d.ts
-declare function createFakeJsPlugin({ dtsInput }: Pick<Options, "dtsInput">): Plugin;
+declare function createFakeJsPlugin({
+  dtsInput,
+  sourcemap
+}: OptionsResolved): Plugin;
 
 //#endregion
 //#region src/generate.d.ts
-declare function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations, resolve, emitDtsOnly }: Pick<Options, "isolatedDeclarations" | "resolve" | "emitDtsOnly" | "tsconfig" | "compilerOptions">): Plugin;
+declare function createGeneratePlugin({
+  tsconfig,
+  compilerOptions,
+  isolatedDeclarations,
+  resolve,
+  emitDtsOnly
+}: OptionsResolved): Plugin;
 
 //#endregion
 //#region src/index.d.ts
 interface Options {
-	/**
-	* When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
-	*
-	* If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
-	*/
-	dtsInput?: boolean;
-	/**
-	* When `true`, the plugin will only emit `.d.ts` files and remove all other chunks.
-	*
-	* This feature is particularly beneficial when you need to generate `d.ts` files for the CommonJS format as part of a separate build process.
-	*/
-	emitDtsOnly?: boolean;
-	/**
-	* The path to the `tsconfig.json` file.
-	*
-	* When set to `false`, the plugin will ignore any `tsconfig.json` file.
-	* However, `compilerOptions` can still be specified directly in the options.
-	*
-	* @default `tsconfig.json`
-	*/
-	tsconfig?: string | boolean;
-	/**
-	* The `compilerOptions` for the TypeScript compiler.
-	*
-	* @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
-	*/
-	compilerOptions?: TsConfigJson.CompilerOptions;
-	/**
-	* When `true`, the plugin will generate `.d.ts` files using `oxc-transform`,
-	* which is blazingly faster than `typescript` compiler.
-	*
-	* This option is enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
-	*/
-	isolatedDeclarations?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
-	/** Resolve external types used in dts files from `node_modules` */
-	resolve?: boolean | (string | RegExp)[];
+  cwd?: string;
+  /**
+  * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
+  *
+  * If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
+  */
+  dtsInput?: boolean;
+  /**
+  * When `true`, the plugin will only emit `.d.ts` files and remove all other chunks.
+  *
+  * This feature is particularly beneficial when you need to generate `d.ts` files for the CommonJS format as part of a separate build process.
+  */
+  emitDtsOnly?: boolean;
+  /**
+  * The path to the `tsconfig.json` file.
+  *
+  * When set to `false`, the plugin will ignore any `tsconfig.json` file.
+  * However, `compilerOptions` can still be specified directly in the options.
+  *
+  * @default `tsconfig.json`
+  */
+  tsconfig?: string | boolean;
+  /**
+  * The `compilerOptions` for the TypeScript compiler.
+  *
+  * @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
+  */
+  compilerOptions?: TsConfigJson.CompilerOptions;
+  /**
+  * When `true`, the plugin will generate `.d.ts` files using `oxc-transform`,
+  * which is blazingly faster than `typescript` compiler.
+  *
+  * This option is enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
+  */
+  isolatedDeclarations?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
+  /**
+  * When `true`, the plugin will generate declaration maps for `.d.ts` files.
+  */
+  sourcemap?: boolean;
+  /** Resolve external types used in dts files from `node_modules` */
+  resolve?: boolean | (string | RegExp)[];
 }
+type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type OptionsResolved = Overwrite<Required<Options>, {
+  tsconfig: string | undefined;
+  isolatedDeclarations: IsolatedDeclarationsOptions | false;
+}>;
 declare function dts(options?: Options): Plugin[];
+declare function resolveOptions({
+  cwd,
+  tsconfig,
+  compilerOptions,
+  isolatedDeclarations,
+  sourcemap,
+  dtsInput,
+  emitDtsOnly,
+  resolve
+}: Options): OptionsResolved;
 
 //#endregion
-export { Options, createFakeJsPlugin, createGeneratePlugin, dts };
+export { Options, OptionsResolved, createFakeJsPlugin, createGeneratePlugin, dts, resolveOptions };

package/dist/index.js

@@ -1,9 +1,11 @@
 import path from "node:path";
-import { MagicStringAST } from "magic-string-ast";
-import { parseSync } from "oxc-parser";
 import process from "node:process";
-import { createResolver } from "dts-resolver";
 import { getTsconfig, parseTsconfig } from "get-tsconfig";
+import _generate from "@babel/generator";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import { isDeclarationType, isTypeOf } from "ast-kit";
+import { createResolver } from "dts-resolver";
 import { isolatedDeclaration } from "oxc-transform";
 import { createRequire } from "node:module";
 import Debug from "debug";
@@ -12,6 +14,7 @@ import Debug from "debug";
 const RE_JS = /\.([cm]?)jsx?$/;
 const RE_TS = /\.([cm]?)tsx?$/;
 const RE_DTS = /\.d\.([cm]?)ts$/;
+const RE_DTS_MAP = /\.d\.([cm]?)ts\.map$/;
 const RE_NODE_MODULES = /[\\/]node_modules[\\/]/;
 function filename_js_to_dts(id) {
 	return id.replace(RE_JS, ".d.$1ts");
@@ -43,7 +46,10 @@ function createDtsInputPlugin() {
 		outputOptions(options) {
 			return {
 				...options,
-				entryFileNames: "[name].ts"
+				entryFileNames(chunk) {
+					if (chunk.name.endsWith(".d")) return "[name].ts";
+					return "[name].d.ts";
+				}
 			};
 		},
 		resolveId: {
@@ -246,41 +252,23 @@ function walk(ast, { enter, leave }) {
 	return instance.visit(ast, null);
 }
 
-//#endregion
-//#region src/utils/ast.ts
-function getIdentifierRange(node, offset = 0) {
-	if ("typeAnnotation" in node && node.typeAnnotation) return [node.start + offset, node.typeAnnotation.start + offset];
-	return [node.start + offset, node.end + offset];
-}
-
-//#endregion
-//#region src/utils/magic-string.ts
-function overwriteOrAppend(s, range, replacement, suffix) {
-	if (range[0] === range[1]) {
-		s.appendLeft(range[0], ` ${replacement}`);
-		return;
-	}
-	const original = s.slice(range[0], range[1]);
-	if (original !== replacement) s.overwrite(range[0], range[1], replacement + (suffix || ""));
-}
-
 //#endregion
 //#region src/fake-js.ts
-const RE_TYPE = /\btype\b/;
-function createFakeJsPlugin({ dtsInput }) {
+const generate = _generate.default || _generate;
+function createFakeJsPlugin({ dtsInput, sourcemap }) {
 	let symbolIdx = 0;
 	let identifierIdx = 0;
 	const symbolMap = new Map();
-	const preserveMap = new Map();
+	const commentsMap = new Map();
 	function getIdentifierIndex() {
 		return identifierIdx++;
 	}
-	function register(info) {
+	function registerSymbol(info) {
 		const symbolId = symbolIdx++;
 		symbolMap.set(symbolId, info);
 		return symbolId;
 	}
-	function retrieve(symbolId) {
+	function getSymbol(symbolId) {
 		return symbolMap.get(symbolId);
 	}
 	return {
@@ -307,6 +295,7 @@ function createFakeJsPlugin({ dtsInput }) {
 			if (options.format === "cjs" || options.format === "commonjs") throw new Error("[rolldown-plugin-dts] Cannot bundle dts files with `cjs` format.");
 			return {
 				...options,
+				sourcemap: sourcemap ? true : options.sourcemap,
 				entryFileNames: options.entryFileNames ?? (dtsInput ? "[name].ts" : void 0),
 				chunkFileNames(chunk) {
 					const original = (typeof options.chunkFileNames === "function" ? options.chunkFileNames(chunk) : options.chunkFileNames) || "[name]-[hash].js";
@@ -318,137 +307,183 @@ function createFakeJsPlugin({ dtsInput }) {
 		transform: {
 			filter: { id: RE_DTS },
 			handler(code, id) {
-				const { program, comments } = parseSync(id, code);
-				const preserved = collectReferenceDirectives(comments);
-				preserveMap.set(id, preserved);
-				const s = new MagicStringAST(code);
-				for (let node of program.body) {
-					if (rewriteImportExport(s, node)) continue;
-					const sideEffect = node.type === "TSModuleDeclaration" && node.kind !== "namespace";
-					const stmt = node;
-					const isDefaultExport = node.type === "ExportDefaultDeclaration";
-					if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && node.declaration) node = node.declaration;
-					if (node.type === "VariableDeclaration" && node.declarations.length !== 1) throw new Error("Only one declaration is supported");
-					if (node.type === "TSDeclareFunction" || node.type.endsWith("Declaration")) {
-						const binding = node.type === "VariableDeclaration" ? node.declarations[0].id : node.id;
-						const code$1 = s.sliceNode(node);
-						const offset = node.start;
-						let bindingRange;
-						if (sideEffect) bindingRange = [0, 0];
-						else if (binding) bindingRange = getIdentifierRange(binding, -offset);
-						else if (isDefaultExport) {
-							const idx = s.sliceNode(node).indexOf("function") + 8;
-							bindingRange = [idx, idx];
-						} else continue;
-						const depsNodes = collectDependencies(s, node, getIdentifierIndex);
-						const depsString = stringifyDependencies(s, depsNodes);
-						const depsSymbols = depsNodes.map((dep) => [
-							dep.start - offset,
-							dep.end - offset,
-							dep._suffix
-						]);
-						const needDeclare = (node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction" || node.type === "TSModuleDeclaration" || node.type === "VariableDeclaration") && !node.declare;
-						const symbolId = register({
-							code: code$1,
-							binding: bindingRange,
-							deps: depsSymbols,
-							needDeclare,
-							preserveName: sideEffect
-						});
-						const runtime = `[${symbolId}, ${depsString}${depsString && sideEffect ? ", " : ""}${sideEffect ? "sideEffect()" : ""}]`;
-						const bindingName = sideEffect ? `_${identifierIdx++}` : binding ? s.sliceNode(binding) : "export_default";
-						if (isDefaultExport) s.overwriteNode(stmt, `var ${bindingName} = ${runtime};export { ${bindingName} as default }`);
-						else s.overwriteNode(node, `var ${bindingName} = ${runtime};`);
+				const file = parse(code, {
+					plugins: [["typescript", { dts: true }]],
+					sourceType: "module"
+				});
+				const { program, comments } = file;
+				if (comments) {
+					const directives = collectReferenceDirectives(comments);
+					commentsMap.set(id, directives);
+				}
+				const prependStmts = [];
+				const appendStmts = [];
+				const prepend = (stmt) => prependStmts.push(stmt);
+				for (const [i, stmt] of program.body.entries()) {
+					const setStmt = (node) => program.body[i] = inheritNode(stmt, node);
+					if (rewriteImportExport(stmt, setStmt)) continue;
+					const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
+					const isDefaultExport = stmt.type === "ExportDefaultDeclaration";
+					const isDecl = isTypeOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && stmt.declaration;
+					const decl = isDecl ? stmt.declaration : stmt;
+					const setDecl = isDecl ? (node) => stmt.declaration = inheritNode(stmt.declaration, node) : setStmt;
+					if (decl.type === "VariableDeclaration" && decl.declarations.length !== 1) throw new Error("Only one declaration is supported");
+					if (decl.type !== "TSDeclareFunction" && !isDeclarationType(decl)) continue;
+					if (isTypeOf(decl, [
+						"TSEnumDeclaration",
+						"ClassDeclaration",
+						"FunctionDeclaration",
+						"TSDeclareFunction",
+						"TSModuleDeclaration",
+						"VariableDeclaration"
+					])) decl.declare = true;
+					let binding = decl.type === "VariableDeclaration" ? decl.declarations[0].id : "id" in decl ? decl.id : null;
+					if (!binding) {
+						binding = t.identifier("export_default");
+						decl.id = binding;
 					}
+					binding = sideEffect ? t.identifier(`_${identifierIdx++}`) : binding;
+					const deps = collectDependencies(decl, getIdentifierIndex, prepend);
+					const elements = [
+						t.numericLiteral(0),
+						...deps.map((dep) => t.arrowFunctionExpression([], dep)),
+						...sideEffect ? [t.callExpression(t.identifier("sideEffect"), [])] : []
+					];
+					const runtime = t.arrayExpression(elements);
+					const symbolId = registerSymbol({
+						decl,
+						deps,
+						binding
+					});
+					elements[0] = t.numericLiteral(symbolId);
+					const runtimeAssignment = {
+						type: "VariableDeclaration",
+						kind: "var",
+						declarations: [{
+							type: "VariableDeclarator",
+							id: {
+								...binding,
+								typeAnnotation: null
+							},
+							init: runtime
+						}]
+					};
+					if (isDefaultExport) {
+						appendStmts.push(t.exportNamedDeclaration(null, [t.exportSpecifier(binding, t.identifier("default"))]));
+						setStmt(runtimeAssignment);
+					} else setDecl(runtimeAssignment);
 				}
-				if (!s.hasChanged()) return;
-				const str = s.toString();
-				return str;
+				program.body = [
+					...prependStmts,
+					...program.body,
+					...appendStmts
+				];
+				const result = generate(file, {
+					comments: true,
+					sourceMaps: sourcemap,
+					sourceFileName: id
+				});
+				return result;
 			}
 		},
 		renderChunk(code, chunk) {
 			if (!RE_DTS.test(chunk.fileName)) return;
-			const { program } = parseSync(chunk.fileName, code);
-			const s = new MagicStringAST(code);
-			const comments = new Set();
-			for (const id of chunk.moduleIds) {
-				const preserveComments = preserveMap.get(id);
-				if (preserveComments) {
-					preserveComments.forEach((c) => comments.add(c));
-					preserveMap.delete(id);
+			const file = parse(code, { sourceType: "module" });
+			const { program } = file;
+			if (program.body.length) {
+				const comments = new Set();
+				const commentsValue = new Set();
+				for (const id of chunk.moduleIds) {
+					const preserveComments = commentsMap.get(id);
+					if (preserveComments) {
+						preserveComments.forEach((c) => {
+							const id$1 = c.type + c.value;
+							if (commentsValue.has(id$1)) return;
+							commentsValue.add(id$1);
+							comments.add(c);
+						});
+						commentsMap.delete(id);
+					}
+				}
+				if (comments.size) {
+					program.body[0].leadingComments ||= [];
+					program.body[0].leadingComments.push(...comments);
 				}
 			}
-			if (comments.size) s.prepend(`${[...comments].join("\n")}\n`);
-			const removedNodes = patchTsNamespace(s, program.body);
-			for (const node of program.body) {
-				if (removedNodes.has(node)) continue;
-				if (patchImportSource(s, node)) continue;
-				if (node.type !== "VariableDeclaration" || node.declarations.length !== 1) continue;
+			program.body = patchTsNamespace(program.body);
+			program.body = program.body.map((node) => {
+				if (patchImportSource(node)) return node;
+				if (node.type !== "VariableDeclaration" || node.declarations.length !== 1) return node;
 				const [decl] = node.declarations;
-				if (decl.init?.type !== "ArrayExpression" || !decl.init.elements[0]) {
-					s.removeNode(node);
-					continue;
-				}
-				const [symbolIdNode, ...depsNodes] = decl.init.elements;
-				if (symbolIdNode?.type !== "Literal" || typeof symbolIdNode.value !== "number") {
-					s.removeNode(node);
-					continue;
-				}
+				if (decl.init?.type !== "ArrayExpression" || !decl.init.elements[0]) return null;
+				const [symbolIdNode, ...depsFns] = decl.init.elements;
+				if (symbolIdNode?.type !== "NumericLiteral") return null;
 				const symbolId = symbolIdNode.value;
-				const { code: code$1, binding, deps, needDeclare, preserveName } = retrieve(symbolId);
-				const depsRaw = depsNodes.filter((node$1) => node$1?.type === "ArrowFunctionExpression").map((dep) => s.sliceNode(dep.body));
-				const ss = new MagicStringAST(code$1);
-				if (!preserveName) overwriteOrAppend(ss, binding, s.sliceNode(decl.id));
-				for (const dep of deps) {
-					const [start, end, suffix] = dep;
-					overwriteOrAppend(ss, [start, end], depsRaw.shift(), suffix);
+				const original = getSymbol(symbolId);
+				const transformedBinding = {
+					...decl.id,
+					typeAnnotation: original.binding.typeAnnotation
+				};
+				overwriteNode(original.binding, transformedBinding);
+				const transformedDeps = depsFns.filter((node$1) => node$1?.type === "ArrowFunctionExpression").map((node$1) => node$1.body);
+				if (original.deps.length) for (let i = 0; i < original.deps.length; i++) {
+					const originalDep = original.deps[i];
+					if (originalDep.replace) originalDep.replace(transformedDeps[i]);
+					else Object.assign(originalDep, transformedDeps[i]);
 				}
-				if (needDeclare) ss.prepend("declare ");
-				s.overwriteNode(node, ss.toString());
+				return inheritNode(node, original.decl);
+			}).filter((node) => !!node);
+			if (program.body.length === 0) return "export { };";
+			const result = generate(file, {
+				comments: true,
+				sourceMaps: sourcemap,
+				sourceFileName: chunk.fileName
+			});
+			return result;
+		},
+		generateBundle(options, bundle) {
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "asset" || !RE_DTS_MAP.test(chunk.fileName) || typeof chunk.source !== "string") continue;
+				const maps = JSON.parse(chunk.source);
+				maps.sourcesContent = null;
+				chunk.source = JSON.stringify(maps);
 			}
-			const str = s.toString();
-			if (str.trim().length === 0) return "export { };";
-			return str;
 		}
 	};
 }
 const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
 function collectReferenceDirectives(comment) {
-	return comment.filter((c) => REFERENCE_RE.test(c.value)).map((c) => `//${c.value}`);
+	return comment.filter((c) => REFERENCE_RE.test(c.value));
 }
-function collectDependencies(s, node, getIdentifierIndex) {
+function collectDependencies(node, getIdentifierIndex, prepend) {
 	const deps = new Set();
+	const seen = new Set();
 	walk(node, { leave(node$1) {
 		if (node$1.type === "ExportNamedDeclaration") {
-			for (const specifier of node$1.specifiers) if (specifier.type === "ExportSpecifier") {
-				let _suffix;
-				if (specifier.local.start === specifier.exported.start && specifier.local.end === specifier.exported.end) _suffix = ` as ${s.sliceNode(specifier.local)}`;
-				addDependency({
-					...specifier.local,
-					_suffix
-				});
-			}
-		} else if (node$1.type === "TSInterfaceDeclaration" && node$1.extends) for (const heritage of node$1.extends || []) addDependency(heritage.expression);
+			for (const specifier of node$1.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
+		} else if (node$1.type === "TSInterfaceDeclaration" && node$1.extends) for (const heritage of node$1.extends || []) addDependency(TSEntityNameToRuntime(heritage.expression));
 		else if (node$1.type === "ClassDeclaration") {
 			if (node$1.superClass) addDependency(node$1.superClass);
-			if (node$1.implements) for (const implement of node$1.implements) addDependency(implement.expression);
-		} else if (node$1.type === "MethodDefinition" || node$1.type === "PropertyDefinition" || node$1.type === "TSPropertySignature") {
+			if (node$1.implements) for (const implement of node$1.implements) addDependency(TSEntityNameToRuntime(implement.expression));
+		} else if (isTypeOf(node$1, [
+			"ObjectMethod",
+			"ObjectProperty",
+			"ClassProperty",
+			"TSPropertySignature",
+			"TSDeclareMethod"
+		])) {
 			if (node$1.computed && isReferenceId(node$1.key)) addDependency(node$1.key);
 			if ("value" in node$1 && isReferenceId(node$1.value)) addDependency(node$1.value);
-		} else if (node$1.type === "TSTypeReference") addDependency(node$1.typeName);
+		} else if (node$1.type === "TSTypeReference") addDependency(TSEntityNameToRuntime(node$1.typeName));
 		else if (node$1.type === "TSTypeQuery") {
-			if (node$1.exprName.type !== "TSImportType") addDependency(node$1.exprName);
+			if (seen.has(node$1.exprName)) return;
+			if (node$1.exprName.type !== "TSImportType") addDependency(TSEntityNameToRuntime(node$1.exprName));
 		} else if (node$1.type === "TSImportType") {
-			if (node$1.argument.type !== "TSLiteralType" || node$1.argument.literal.type !== "Literal" || typeof node$1.argument.literal.value !== "string") return;
-			const source = node$1.argument.literal.value;
-			const imported = node$1.qualifier && resolveTSTypeName(node$1.qualifier);
-			const local = importNamespace(s, source, imported && s.sliceNode(imported), getIdentifierIndex);
-			addDependency({
-				type: "Identifier",
-				name: local,
-				start: node$1.start,
-				end: imported ? imported.end : node$1.end
-			});
+			seen.add(node$1);
+			const source = node$1.argument;
+			const imported = node$1.qualifier;
+			const dep = importNamespace(node$1, imported, source, getIdentifierIndex, prepend);
+			addDependency(dep);
 		}
 	} });
 	return Array.from(deps);
@@ -457,76 +492,151 @@ function collectDependencies(s, node, getIdentifierIndex) {
 		deps.add(node$1);
 	}
 }
-function resolveTSTypeName(node) {
+function TSEntityNameToRuntime(node) {
+	if (node.type === "Identifier") return node;
+	const left = TSEntityNameToRuntime(node.left);
+	return Object.assign(node, t.memberExpression(left, node.right));
+}
+function getIdFromTSEntityName(node) {
 	if (node.type === "Identifier") return node;
-	return resolveTSTypeName(node.left);
+	return getIdFromTSEntityName(node.left);
 }
 function isReferenceId(node) {
 	return !!node && (node.type === "Identifier" || node.type === "MemberExpression");
 }
-function stringifyDependencies(s, deps) {
-	return deps.map((node) => `() => ${node.type === "Identifier" ? node.name : s.sliceNode(node)}`).join(", ");
-}
-function patchImportSource(s, node) {
-	if ((node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value && RE_DTS.test(node.source.value)) {
-		s.overwriteNode(node.source, JSON.stringify(filename_dts_to(node.source.value, "js")));
+function patchImportSource(node) {
+	if (isTypeOf(node, [
+		"ImportDeclaration",
+		"ExportAllDeclaration",
+		"ExportNamedDeclaration"
+	]) && node.source?.value && RE_DTS.test(node.source.value)) {
+		node.source.value = filename_dts_to(node.source.value, "js");
 		return true;
 	}
 }
-function patchTsNamespace(s, nodes) {
+function patchTsNamespace(nodes) {
 	const emptyObjectAssignments = new Map();
 	const removed = new Set();
-	for (const node of nodes) {
-		if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].init?.type === "ObjectExpression" && node.declarations[0].init.properties.length === 0) emptyObjectAssignments.set(s.sliceNode(node.declarations[0].id), node);
+	for (const [i, node] of nodes.entries()) {
+		if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].id.type === "Identifier" && node.declarations[0].init?.type === "ObjectExpression" && node.declarations[0].init.properties.length === 0) emptyObjectAssignments.set(node.declarations[0].id.name, node);
 		if (node.type !== "ExpressionStatement" || node.expression.type !== "CallExpression" || node.expression.callee.type !== "Identifier" || !node.expression.callee.name.startsWith("__export")) continue;
 		const [binding, exports] = node.expression.arguments;
-		const bindingText = s.sliceNode(binding);
+		if (binding.type !== "Identifier") continue;
+		const bindingText = binding.name;
 		if (emptyObjectAssignments.has(bindingText)) {
 			const emptyNode = emptyObjectAssignments.get(bindingText);
-			s.removeNode(emptyNode);
 			emptyObjectAssignments.delete(bindingText);
 			removed.add(emptyNode);
 		}
-		let code = `declare namespace ${bindingText} {
-  export { `;
-		for (const properties of exports.properties) {
-			if (properties.type !== "Property") continue;
-			const exported = s.sliceNode(properties.key);
-			const local = s.sliceNode(properties.value.body);
-			const suffix = exported !== local ? ` as ${exported}` : "";
-			code += `${local}${suffix}, `;
-		}
-		code += `}\n}`;
-		s.overwriteNode(node, code);
+		nodes[i] = {
+			type: "TSModuleDeclaration",
+			id: binding,
+			kind: "namespace",
+			declare: true,
+			body: {
+				type: "TSModuleBlock",
+				body: [{
+					type: "ExportNamedDeclaration",
+					specifiers: exports.properties.filter((property) => property.type === "ObjectProperty").map((property) => {
+						const local = property.value.body;
+						const exported = property.key;
+						return t.exportSpecifier(local, exported);
+					}),
+					source: null,
+					declaration: null
+				}]
+			}
+		};
 	}
-	return removed;
+	return nodes.filter((node) => !removed.has(node));
 }
-function rewriteImportExport(s, node) {
+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 === "type" || specifier.type === "ExportSpecifier" && specifier.exportKind === "type") s.overwriteNode(specifier, s.sliceNode(specifier).replace(RE_TYPE, ""));
-		const firstSpecifier = node.specifiers[0];
-		const kind = node.type === "ImportDeclaration" ? node.importKind : node.exportKind;
-		if (kind === "type" && firstSpecifier) s.overwrite(node.start, firstSpecifier.start, s.slice(node.start, firstSpecifier.start).replace(RE_TYPE, ""));
+		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") {
-		if (node.exportKind === "type") s.overwrite(node.start, node.source.start, s.slice(node.start, node.source.start).replace(RE_TYPE, ""));
+		node.exportKind = "value";
 		return true;
 	} else if (node.type === "TSImportEqualsDeclaration") {
-		if (node.moduleReference.type === "TSExternalModuleReference") s.overwriteNode(node, `import ${s.sliceNode(node.id)} from ${s.sliceNode(node.moduleReference.expression)}`);
+		if (node.moduleReference.type === "TSExternalModuleReference") set({
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportDefaultSpecifier",
+				local: node.id
+			}],
+			source: node.moduleReference.expression
+		});
 		return true;
-	} else if (node.type === "TSExportAssignment") {
-		s.overwriteNode(node, `export { ${s.sliceNode(node.expression)} as default }`);
+	} else if (node.type === "TSExportAssignment" && node.expression.type === "Identifier") {
+		set({
+			type: "ExportNamedDeclaration",
+			specifiers: [{
+				type: "ExportSpecifier",
+				local: node.expression,
+				exported: {
+					type: "Identifier",
+					name: "default"
+				}
+			}]
+		});
 		return true;
 	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
-		s.overwriteNode(node, `export { ${s.sliceNode(node.declaration)} as default }`);
+		set({
+			type: "ExportNamedDeclaration",
+			specifiers: [{
+				type: "ExportSpecifier",
+				local: node.declaration,
+				exported: t.identifier("default")
+			}]
+		});
 		return true;
 	}
+	return false;
 }
-function importNamespace(s, source, imported, getIdentifierIndex) {
-	const local = `_${getIdentifierIndex()}`;
-	const specifiers = imported ? `{ ${imported} as ${local} }` : `* as ${local}`;
-	s.prepend(`import ${specifiers} from ${JSON.stringify(source)};\n`);
-	return local;
+function importNamespace(node, imported, source, getIdentifierIndex, prepend) {
+	let local = t.identifier(`_${getIdentifierIndex()}`);
+	prepend(t.importDeclaration([t.importNamespaceSpecifier(local)], source));
+	if (imported) {
+		const importedLeft = getIdFromTSEntityName(imported);
+		overwriteNode(importedLeft, t.tsQualifiedName(local, { ...importedLeft }));
+		local = imported;
+	}
+	let replacement = node;
+	if (node.typeParameters) {
+		overwriteNode(node, t.tsTypeReference(local, node.typeParameters));
+		replacement = local;
+	} else overwriteNode(node, local);
+	const dep = {
+		...TSEntityNameToRuntime(local),
+		replace(newNode) {
+			overwriteNode(replacement, newNode);
+		}
+	};
+	return dep;
+}
+function inheritNode(oldValue, newValue) {
+	return {
+		...newValue,
+		leadingComments: oldValue.leadingComments,
+		innerComments: oldValue.innerComments,
+		trailingComments: oldValue.trailingComments
+	};
+}
+function overwriteNode(node, newNode) {
+	const preserve = [
+		"leadingComments",
+		"innerComments",
+		"trailingComments"
+	];
+	for (const key of Object.keys(node)) {
+		if (preserve.includes(key)) continue;
+		delete node[key];
+	}
+	Object.assign(node, newNode, { ...node });
+	return node;
 }
 
 //#endregion
@@ -631,28 +741,8 @@ function getTsModule(dtsMap, tsId) {
 //#endregion
 //#region src/generate.ts
 const meta = { dtsFile: true };
-function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations, resolve = false, emitDtsOnly = false }) {
+function createGeneratePlugin({ tsconfig, compilerOptions = {}, isolatedDeclarations, resolve = false, emitDtsOnly = false }) {
 	const dtsMap = new Map();
-	function resolveOptions(cwd) {
-		if (tsconfig === true || tsconfig == null) {
-			const { config, path: path$1 } = getTsconfig(cwd) || {};
-			tsconfig = path$1;
-			compilerOptions = {
-				...config?.compilerOptions,
-				...compilerOptions
-			};
-		} else if (typeof tsconfig === "string") {
-			tsconfig = path.resolve(cwd || process.cwd(), tsconfig);
-			const config = parseTsconfig(tsconfig);
-			compilerOptions = {
-				...config.compilerOptions,
-				...compilerOptions
-			};
-		}
-		if (isolatedDeclarations == null) isolatedDeclarations = !!compilerOptions?.isolatedDeclarations;
-		if (isolatedDeclarations === true) isolatedDeclarations = {};
-		if (isolatedDeclarations && isolatedDeclarations.stripInternal == null) isolatedDeclarations.stripInternal = !!compilerOptions?.stripInternal;
-	}
 	/**
 	* A map of input id to output file name
 	*
@@ -663,14 +753,12 @@ function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations,
 	* ])
 	*/
 	const inputAliasMap = new Map();
-	let resolver;
 	let programs = [];
+	const resolver = createResolver({ tsconfig: tsconfig ? tsconfig : void 0 });
+	if (!isolatedDeclarations) initTs();
 	return {
 		name: "rolldown-plugin-dts:generate",
 		async buildStart(options) {
-			resolveOptions(options.cwd);
-			resolver = createResolver({ tsconfig: tsconfig ? tsconfig : void 0 });
-			if (!isolatedDeclarations) initTs();
 			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
 				let resolved = await this.resolve(id, void 0, { skipSelf: true });
 				resolved ||= await this.resolve(`./${id}`, void 0, { skipSelf: true });
@@ -784,8 +872,9 @@ function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations,
 				if (!dtsMap.has(dtsId)) return;
 				const { code, id, isEntry } = dtsMap.get(dtsId);
 				let dtsCode;
+				let map;
 				if (isolatedDeclarations) {
-					const result = isolatedDeclaration(id, code, isolatedDeclarations === true ? {} : isolatedDeclarations);
+					const result = isolatedDeclaration(id, code, isolatedDeclarations);
 					if (result.errors.length) {
 						const [error] = result.errors;
 						return this.error({
@@ -794,6 +883,7 @@ function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations,
 						});
 					}
 					dtsCode = result.code;
+					if (result.map) map = result.map;
 				} else {
 					const module = createOrGetTsModule(programs, compilerOptions, id, isEntry, dtsMap);
 					const result = tscEmit(module);
@@ -803,12 +893,13 @@ function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations,
 				if (!dtsCode) return this.error(new Error(`Failed to generate dts for ${id}`));
 				return {
 					code: dtsCode,
-					moduleSideEffects: false
+					moduleSideEffects: false,
+					map
 				};
 			}
 		},
 		generateBundle: emitDtsOnly ? (options, bundle) => {
-			for (const fileName of Object.keys(bundle)) if (!RE_DTS.test(fileName)) delete bundle[fileName];
+			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,
 		buildEnd() {
 			programs = [];
@@ -819,12 +910,48 @@ function createGeneratePlugin({ tsconfig, compilerOptions, isolatedDeclarations,
 //#endregion
 //#region src/index.ts
 function dts(options = {}) {
+	const resolved = resolveOptions(options);
 	const plugins = [];
 	if (options.dtsInput) plugins.push(createDtsInputPlugin());
-	else plugins.push(createGeneratePlugin(options));
-	plugins.push(createFakeJsPlugin(options));
+	else plugins.push(createGeneratePlugin(resolved));
+	plugins.push(createFakeJsPlugin(resolved));
 	return plugins;
 }
+function resolveOptions({ cwd = process.cwd(), tsconfig, compilerOptions = {}, isolatedDeclarations, sourcemap, dtsInput = false, emitDtsOnly = false, resolve = false }) {
+	if (tsconfig === true || tsconfig == null) {
+		const { config, path: path$1 } = getTsconfig(cwd) || {};
+		tsconfig = path$1;
+		compilerOptions = {
+			...config?.compilerOptions,
+			...compilerOptions
+		};
+	} else if (typeof tsconfig === "string") {
+		tsconfig = path.resolve(cwd || process.cwd(), tsconfig);
+		const config = parseTsconfig(tsconfig);
+		compilerOptions = {
+			...config.compilerOptions,
+			...compilerOptions
+		};
+	} else tsconfig = void 0;
+	sourcemap ??= !!compilerOptions.declarationMap;
+	compilerOptions.declarationMap = sourcemap;
+	if (isolatedDeclarations == null) isolatedDeclarations = !!compilerOptions?.isolatedDeclarations;
+	if (isolatedDeclarations === true) isolatedDeclarations = {};
+	if (isolatedDeclarations) {
+		isolatedDeclarations.stripInternal ??= !!compilerOptions?.stripInternal;
+		isolatedDeclarations.sourcemap = !!compilerOptions.declarationMap;
+	}
+	return {
+		cwd,
+		tsconfig,
+		compilerOptions,
+		isolatedDeclarations,
+		sourcemap,
+		dtsInput,
+		emitDtsOnly,
+		resolve
+	};
+}
 
 //#endregion
-export { createFakeJsPlugin, createGeneratePlugin, dts };
+export { createFakeJsPlugin, createGeneratePlugin, dts, resolveOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "description": "A Rolldown plugin to bundle dts files",
   "type": "module",
   "license": "MIT",
@@ -37,20 +37,23 @@
     }
   },
   "dependencies": {
+    "@babel/generator": "^7.27.0",
+    "@babel/parser": "^7.27.0",
+    "@babel/types": "^7.27.0",
+    "ast-kit": "^1.4.3",
     "debug": "^4.4.0",
     "dts-resolver": "^1.0.1",
     "get-tsconfig": "^4.10.0",
-    "magic-string-ast": "^0.9.1",
-    "oxc-parser": "^0.66.0",
     "oxc-transform": "^0.66.0"
   },
   "devDependencies": {
     "@sxzz/eslint-config": "^6.1.2",
     "@sxzz/prettier-config": "^2.2.1",
     "@sxzz/test-utils": "^0.5.5",
+    "@types/babel__generator": "^7.27.0",
     "@types/debug": "^4.1.12",
     "@types/diff": "^7.0.2",
-    "@types/node": "^22.14.1",
+    "@types/node": "^22.15.2",
     "bumpp": "^10.1.0",
     "diff": "^7.0.0",
     "eslint": "^9.25.1",
@@ -58,7 +61,8 @@
     "prettier": "^3.5.3",
     "rolldown": "1.0.0-beta.8-commit.6aca0ce",
     "rollup-plugin-dts": "^6.2.1",
-    "tsdown": "^0.9.6",
+    "tinyglobby": "^0.2.13",
+    "tsdown": "^0.9.8",
     "tsx": "^4.19.3",
     "typescript": "^5.8.3",
     "vitest": "^3.1.2"