robuild 0.0.18 → 0.0.19

package/dist/_chunks/{build-omZA_xD-.mjs → build-snxBrML1.mjs}

@@ -1,4 +1,4 @@
-import { RobuildPluginManager } from "./plugin-manager-w5yRGJRn.mjs";
+import { t as RobuildPluginManager } from "./plugin-manager-CwMXjVtp.mjs";
 import { builtinModules } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -52,9 +52,7 @@ function createSkipNodeModulesPlugin(options) {
 * Unbundle mode: preserve file structure without bundling
 */
 async function unbundleTransform(ctx, entry) {
-	const inputDir = isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input);
-	const outputDir = join(ctx.pkgDir, entry.outDir || "dist");
-	await processDirectoryUnbundled(inputDir, outputDir, entry);
+	await processDirectoryUnbundled(isAbsolute(entry.input) ? entry.input : join(ctx.pkgDir, entry.input), join(ctx.pkgDir, entry.outDir || "dist"), entry);
 }
 /**
 * Process directory in unbundle mode
@@ -87,8 +85,7 @@ async function processFileUnbundled(inputPath, outputPath, entry) {
 		".cts"
 	].includes(ext)) return;
 	try {
-		const content = await readFile(inputPath, "utf-8");
-		const transformedContent = transformImportsForUnbundle(content, inputPath, entry);
+		const transformedContent = transformImportsForUnbundle(await readFile(inputPath, "utf-8"), inputPath, entry);
 		const outputExt = getUnbundleOutputExtension(ext, entry);
 		const finalOutputPath = outputPath.replace(ext, outputExt);
 		await mkdir(dirname(finalOutputPath), { recursive: true });
@@ -159,10 +156,9 @@ function getUnbundleOutputExtension(inputExt, entry) {
 * Resolve banner/footer addon for specific format
 */
 function resolveChunkAddon(addon, format) {
-	if (!addon) return void 0;
+	if (!addon) return;
 	if (typeof addon === "string") return addon;
-	const formatKey = format === "es" ? "js" : format;
-	return addon[formatKey] || addon.js;
+	return addon[format === "es" ? "js" : format] || addon.js;
 }
 /**
 * Add banner to content
@@ -213,6 +209,88 @@ async function copyFiles(cwd, outDir, copyOptions) {
 	consola.debug("✅ Files copied successfully");
 }
 
+//#endregion
+//#region src/features/external.ts
+/**
+* Build external dependencies list from package.json dependencies and peerDependencies.
+* This is the shared logic used by both bundle and watch modes.
+*/
+function buildExternalDeps(ctx) {
+	return [
+		...builtinModules,
+		...builtinModules.map((m) => `node:${m}`),
+		...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, new RegExp(`^${p}/`)])
+	];
+}
+/**
+* Escape special regex characters in a string
+*/
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Apply noExternal configuration to filter out dependencies that should be bundled.
+* Supports both function and array forms.
+*/
+function applyNoExternal(externalDeps, noExternal, ctx) {
+	if (!noExternal) return externalDeps;
+	if (typeof noExternal === "function") {
+		const predicate = noExternal;
+		const depNames = [...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})];
+		const excludedNames = /* @__PURE__ */ new Set();
+		for (const name of depNames) try {
+			if (predicate(name)) excludedNames.add(name);
+		} catch {}
+		return externalDeps.filter((dep) => {
+			if (typeof dep === "string") return !excludedNames.has(dep);
+			if (dep instanceof RegExp) {
+				for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
+				return true;
+			}
+			return true;
+		});
+	}
+	if (Array.isArray(noExternal)) {
+		const rules = noExternal;
+		return externalDeps.filter((dep) => {
+			for (const rule of rules) if (typeof rule === "string") {
+				if (typeof dep === "string") {
+					if (dep === rule) return false;
+				} else if (dep instanceof RegExp) {
+					if (dep.source.startsWith(`^${escapeRegExp(rule)}/`)) return false;
+				}
+			} else if (rule instanceof RegExp) {
+				if (typeof dep === "string") {
+					if (rule.test(dep)) return false;
+				} else if (dep instanceof RegExp) {
+					if (dep.source === rule.source && dep.flags === rule.flags) return false;
+				}
+			}
+			return true;
+		});
+	}
+	return externalDeps;
+}
+/**
+* Add custom external dependencies to the list.
+* Only handles array form; function form is handled separately.
+*/
+function addCustomExternal(externalDeps, external) {
+	if (external && typeof external !== "function") return [...externalDeps, ...external];
+	return externalDeps;
+}
+/**
+* Build the complete external configuration for rolldown.
+* Returns either a function (if entry.external is a function) or the processed array.
+*/
+function resolveExternalConfig(ctx, options) {
+	let externalDeps = buildExternalDeps(ctx);
+	externalDeps = applyNoExternal(externalDeps, options.noExternal, ctx);
+	externalDeps = addCustomExternal(externalDeps, options.external);
+	if (typeof options.external === "function") return options.external;
+	return externalDeps;
+}
+
 //#endregion
 //#region src/features/glob-import.ts
 /**
@@ -258,8 +336,7 @@ async function generateGlobImport(pattern, importer, eager, asUrls, allowedPatte
 	if (!isPatternAllowed(pattern, allowedPatterns)) throw new Error(`Glob pattern "${pattern}" is not allowed`);
 	let files = [];
 	try {
-		const absolutePattern = resolve(importerDir, pattern);
-		files = await glob(absolutePattern, { ignore: ["**/node_modules/**", "**/.git/**"] });
+		files = await glob(resolve(importerDir, pattern), { ignore: ["**/node_modules/**", "**/.git/**"] });
 	} catch {
 		if (pattern.includes("*.js")) files = [resolve(importerDir, pattern.replace("*", "module1")), resolve(importerDir, pattern.replace("*", "module2"))];
 	}
@@ -336,9 +413,7 @@ function addHashToFilename(filename, content, hashLength = 8) {
 	const hash = generateContentHash(content, hashLength);
 	const dotIndex = filename.lastIndexOf(".");
 	if (dotIndex === -1) return `${filename}-${hash}`;
-	const name = filename.slice(0, dotIndex);
-	const ext = filename.slice(dotIndex);
-	return `${name}-${hash}${ext}`;
+	return `${filename.slice(0, dotIndex)}-${hash}${filename.slice(dotIndex)}`;
 }
 /**
 * Check if filename already has hash
@@ -402,15 +477,11 @@ if (typeof exports === 'undefined') {
 */
 function detectShimNeeds(code) {
 	const cleanCode = removeCommentsAndStrings(code);
-	const needsDirname = /\b__dirname\b/.test(cleanCode) || /\b__filename\b/.test(cleanCode);
-	const needsRequire = /\brequire\s*\(/.test(cleanCode);
-	const needsExports = /\bmodule\.exports\b/.test(cleanCode) || /\bexports\.\w+/.test(cleanCode);
-	const needsEnv = /\bprocess\.env\b/.test(cleanCode);
 	return {
-		needsDirname,
-		needsRequire,
-		needsExports,
-		needsEnv
+		needsDirname: /\b__dirname\b/.test(cleanCode) || /\b__filename\b/.test(cleanCode),
+		needsRequire: /\brequire\s*\(/.test(cleanCode),
+		needsExports: /\bmodule\.exports\b/.test(cleanCode) || /\bexports\.\w+/.test(cleanCode),
+		needsEnv: /\bprocess\.env\b/.test(cleanCode)
 	};
 }
 /**
@@ -438,8 +509,7 @@ const require = createRequire(import.meta.url)
 * Transform code to use shims
 */
 function transformWithShims(code, config) {
-	const needs = detectShimNeeds(code);
-	const shims = generateShims(config, needs);
+	const shims = generateShims(config, detectShimNeeds(code));
 	if (!shims) return code;
 	return `${shims}\n${code}`;
 }
@@ -552,8 +622,7 @@ function processNodeProtocol(id, nodeProtocol) {
 */
 function transformNodeProtocol(code, nodeProtocol) {
 	if (!nodeProtocol) return code;
-	const importRegex = /(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g;
-	return code.replace(importRegex, (match, moduleId) => {
+	return code.replace(/(?:import|export)(?:\s[^'"]*)?\s['"]([^'"]+)['"]/g, (match, moduleId) => {
 		const processedId = processNodeProtocol(moduleId, nodeProtocol);
 		return match.replace(moduleId, processedId);
 	});
@@ -586,10 +655,7 @@ function shebangPlugin() {
 		async writeBundle(options, bundle) {
 			for (const [fileName, output] of Object.entries(bundle)) {
 				if (output.type !== "chunk") continue;
-				if (hasShebang(output.code)) {
-					const outFile = resolve(options.dir, fileName);
-					await makeExecutable(outFile);
-				}
+				if (hasShebang(output.code)) await makeExecutable(resolve(options.dir, fileName));
 			}
 		}
 	};
@@ -608,15 +674,15 @@ function fmtPath(path) {
 }
 function analyzeDir(dir) {
 	if (Array.isArray(dir)) {
-		let totalSize$1 = 0;
+		let totalSize = 0;
 		let totalFiles = 0;
 		for (const d of dir) {
 			const { size, files } = analyzeDir(d);
-			totalSize$1 += size;
+			totalSize += size;
 			totalFiles += files;
 		}
 		return {
-			size: totalSize$1,
+			size: totalSize,
 			files: totalFiles
 		};
 	}
@@ -646,13 +712,12 @@ function analyzeDir(dir) {
 	}
 }
 async function distSize(dir, entry) {
-	const build$1 = await rolldown({
+	const { output } = await (await rolldown({
 		input: join(dir, entry),
 		plugins: [],
 		platform: "neutral",
 		external: (id) => id[0] !== "." && !id.startsWith(dir)
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
+	})).generate({ inlineDynamicImports: true });
 	const code = output[0].code;
 	const { code: minified } = await minify(entry, code);
 	return {
@@ -662,26 +727,24 @@ async function distSize(dir, entry) {
 	};
 }
 async function sideEffectSize(dir, entry) {
-	const virtualEntry = {
-		name: "virtual-entry",
-		async resolveId(id, importer, opts) {
-			if (id === "#entry") return { id };
-			const resolved = await this.resolve(id, importer, opts);
-			if (!resolved) return null;
-			resolved.moduleSideEffects = null;
-			return resolved;
-		},
-		load(id) {
-			if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
-		}
-	};
-	const build$1 = await rolldown({
+	const { output } = await (await rolldown({
 		input: "#entry",
 		platform: "neutral",
 		external: (id) => id[0] !== "." && !id.startsWith(dir),
-		plugins: [virtualEntry]
-	});
-	const { output } = await build$1.generate({ inlineDynamicImports: true });
+		plugins: [{
+			name: "virtual-entry",
+			async resolveId(id, importer, opts) {
+				if (id === "#entry") return { id };
+				const resolved = await this.resolve(id, importer, opts);
+				if (!resolved) return null;
+				resolved.moduleSideEffects = null;
+				return resolved;
+			},
+			load(id) {
+				if (id === "#entry") return `import * as _lib from "${join(dir, entry)}";`;
+			}
+		}]
+	})).generate({ inlineDynamicImports: true });
 	if (process.env.INSPECT_BUILD) {
 		console.log("---------[side effects]---------");
 		console.log(entry);
@@ -715,9 +778,9 @@ function getFormatExtension(format, platform, fixedExtension = false) {
 async function cleanOutputDir$1(projectRoot, outDir, cleanPaths) {
 	if (!cleanPaths) return;
 	const { rm } = await import("node:fs/promises");
-	const { existsSync: existsSync$1 } = await import("node:fs");
+	const { existsSync } = await import("node:fs");
 	if (cleanPaths === true) {
-		if (existsSync$1(outDir)) {
+		if (existsSync(outDir)) {
 			consola.log(`🧻 Cleaning up ${fmtPath(outDir)}`);
 			await rm(outDir, {
 				recursive: true,
@@ -726,7 +789,7 @@ async function cleanOutputDir$1(projectRoot, outDir, cleanPaths) {
 		}
 	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
 		const fullPath = resolve(projectRoot, path);
-		if (existsSync$1(fullPath)) {
+		if (existsSync(fullPath)) {
 			consola.log(`🧻 Cleaning up ${fmtPath(fullPath)}`);
 			await rm(fullPath, {
 				recursive: true,
@@ -765,9 +828,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			await mkdir(dirname(distPath), { recursive: true });
 			consola.log(`${colors.magenta("[stub bundle] ")} ${colors.underline(fmtPath(distPath))}`);
 			const srcContents = await readFile(srcPath, "utf8");
-			const parsed = parseSync(srcPath, srcContents);
-			const exportNames = parsed.module.staticExports.flatMap((e) => e.entries.map((e$1) => e$1.exportName.kind === "Default" ? "default" : e$1.exportName.name));
-			const hasDefaultExport = exportNames.includes("default");
+			const hasDefaultExport = parseSync(srcPath, srcContents).module.staticExports.flatMap((e) => e.entries.map((e) => e.exportName.kind === "Default" ? "default" : e.exportName.name)).includes("default");
 			const firstLine = srcContents.split("\n")[0];
 			const hasShebangLine = firstLine.startsWith("#!");
 			await writeFile(distPath, `${hasShebangLine ? `${firstLine}\n` : ""}export * from "${srcPath}";\n${hasDefaultExport ? `export { default } from "${srcPath}";\n` : ""}`, "utf8");
@@ -776,49 +837,10 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 		}
 		return;
 	}
-	let externalDeps = [
-		...builtinModules,
-		...builtinModules.map((m) => `node:${m}`),
-		...[...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})].flatMap((p) => [p, /* @__PURE__ */ new RegExp(`^${p}/`)])
-	];
-	if (entry.noExternal) {
-		const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		if (typeof entry.noExternal === "function") {
-			const predicate = entry.noExternal;
-			const depNames = [...Object.keys(ctx.pkg.dependencies || {}), ...Object.keys(ctx.pkg.peerDependencies || {})];
-			const excludedNames = /* @__PURE__ */ new Set();
-			for (const name of depNames) try {
-				if (predicate(name)) excludedNames.add(name);
-			} catch {}
-			externalDeps = externalDeps.filter((dep) => {
-				if (typeof dep === "string") return !excludedNames.has(dep);
-				if (dep instanceof RegExp) {
-					for (const name of Array.from(excludedNames)) if (dep.source.startsWith(`^${escapeRegExp(name)}/`)) return false;
-					return true;
-				}
-				return true;
-			});
-		} else if (Array.isArray(entry.noExternal)) {
-			const rules = entry.noExternal;
-			externalDeps = externalDeps.filter((dep) => {
-				for (const rule of rules) if (typeof rule === "string") {
-					if (typeof dep === "string") {
-						if (dep === rule) return false;
-					} else if (dep instanceof RegExp) {
-						if (dep.source.startsWith(`^${escapeRegExp(rule)}/`)) return false;
-					}
-				} else if (rule instanceof RegExp) {
-					if (typeof dep === "string") {
-						if (rule.test(dep)) return false;
-					} else if (dep instanceof RegExp) {
-						if (dep.source === rule.source && dep.flags === rule.flags) return false;
-					}
-				}
-				return true;
-			});
-		}
-	}
-	if (entry.external) if (typeof entry.external === "function") {} else externalDeps.push(...entry.external);
+	const externalConfig = resolveExternalConfig(ctx, {
+		external: entry.external,
+		noExternal: entry.noExternal
+	});
 	const defineOptions = {};
 	if (entry.env) for (const [key, value] of Object.entries(entry.env)) defineOptions[`process.env.${key}`] = JSON.stringify(value);
 	if (entry.define) for (const [key, value] of Object.entries(entry.define)) defineOptions[key] = value;
@@ -852,21 +874,23 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 	}
 	rolldownPlugins.push(...pluginManager.getRolldownPlugins());
 	const moduleTypes = {};
-	if (entry.loaders) for (const [ext, config$1] of Object.entries(entry.loaders)) moduleTypes[ext] = config$1.loader;
+	if (entry.loaders) for (const [ext, config] of Object.entries(entry.loaders)) moduleTypes[ext] = config.loader;
 	const robuildGeneratedConfig = {
 		cwd: ctx.pkgDir,
 		input: inputs,
 		plugins: rolldownPlugins,
 		platform: platform === "node" ? "node" : "neutral",
-		external: typeof entry.external === "function" ? entry.external : externalDeps,
-		define: defineOptions,
+		external: externalConfig,
 		resolve: { alias: entry.alias || {} },
-		transform: { target },
+		transform: {
+			target,
+			define: defineOptions
+		},
 		...Object.keys(moduleTypes).length > 0 ? { moduleTypes } : {}
 	};
 	if (entry.treeshake !== void 0) if (typeof entry.treeshake === "boolean") robuildGeneratedConfig.treeshake = entry.treeshake;
 	else robuildGeneratedConfig.treeshake = entry.treeshake;
-	const { output: userOutputConfig, plugins: userPlugins,...userRolldownConfig } = entry.rolldown || {};
+	const { output: userOutputConfig, plugins: userPlugins, ...userRolldownConfig } = entry.rolldown || {};
 	const baseRolldownConfig = {
 		...robuildGeneratedConfig,
 		...userRolldownConfig,
@@ -894,7 +918,10 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 			dir: formatOutDir,
 			format,
 			entryFileNames: entryFileName,
-			chunkFileNames: `_chunks/[name]-[hash]${extension}`,
+			chunkFileNames: (chunk) => {
+				if (chunk.name.endsWith(".d") || chunk.name.includes(".d.")) return `[name].mjs`;
+				return `_chunks/[name]-[hash]${extension}`;
+			},
 			minify: entry.minify,
 			name: entry.globalName,
 			banner: resolveChunkAddon(entry.banner, format),
@@ -938,9 +965,7 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 				const { rename } = await import("node:fs/promises");
 				await rename(finalFilePath, hashedFilePath);
 				try {
-					const mapOld = `${finalFilePath}.map`;
-					const mapNew = `${hashedFilePath}.map`;
-					await rename(mapOld, mapNew);
+					await rename(`${finalFilePath}.map`, `${hashedFilePath}.map`);
 				} catch {}
 				finalFileName = hashedFileName;
 				finalFilePath = hashedFilePath;
@@ -968,19 +993,16 @@ async function rolldownBuild(ctx, entry, hooks, config) {
 function normalizeBundleInputs(input, ctx) {
 	const inputs = {};
 	if (typeof input === "object" && !Array.isArray(input)) {
-		for (const [name, src] of Object.entries(input)) {
-			const resolvedSrc = resolveModulePath(src, {
-				from: ctx.pkgDir,
-				extensions: [
-					".ts",
-					".js",
-					".mjs",
-					".cjs",
-					".json"
-				]
-			});
-			inputs[name] = resolvedSrc;
-		}
+		for (const [name, src] of Object.entries(input)) inputs[name] = resolveModulePath(src, {
+			from: ctx.pkgDir,
+			extensions: [
+				".ts",
+				".js",
+				".mjs",
+				".cjs",
+				".json"
+			]
+		});
 		return inputs;
 	}
 	for (let src of Array.isArray(input) ? input : [input]) {
@@ -1049,14 +1071,14 @@ function applyOutExtensions(format, outExtensions) {
 /**
 * Create filename with proper extension
 */
-function createFilename(basename$1, format, isDts = false, options = {}) {
+function createFilename(basename, format, isDts = false, options = {}) {
 	const { platform, fixedExtension, outExtensions } = options;
 	if (outExtensions) {
 		const extensions = applyOutExtensions(format, outExtensions);
-		return `${basename$1}.${isDts ? extensions.dts : extensions.js}`;
+		return `${basename}.${isDts ? extensions.dts : extensions.js}`;
 	}
-	if (isDts) return `${basename$1}.${resolveDtsOutputExtension(format, fixedExtension)}`;
-	return `${basename$1}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
+	if (isDts) return `${basename}.${resolveDtsOutputExtension(format, fixedExtension)}`;
+	return `${basename}.${resolveJsOutputExtension(format, platform, fixedExtension)}`;
 }
 
 //#endregion
@@ -1067,9 +1089,9 @@ function createFilename(basename$1, format, isDts = false, options = {}) {
 async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
 	if (!cleanPaths) return;
 	const { rm } = await import("node:fs/promises");
-	const { existsSync: existsSync$1 } = await import("node:fs");
+	const { existsSync } = await import("node:fs");
 	if (cleanPaths === true) {
-		if (existsSync$1(outDir)) {
+		if (existsSync(outDir)) {
 			consola.log(`🧻 Cleaning up ${fmtPath(outDir)}`);
 			await rm(outDir, {
 				recursive: true,
@@ -1078,7 +1100,7 @@ async function cleanOutputDir(projectRoot, outDir, cleanPaths) {
 		}
 	} else if (Array.isArray(cleanPaths)) for (const path of cleanPaths) {
 		const fullPath = resolve(projectRoot, path);
-		if (existsSync$1(fullPath)) {
+		if (existsSync(fullPath)) {
 			consola.log(`🧻 Cleaning up ${fmtPath(fullPath)}`);
 			await rm(fullPath, {
 				recursive: true,
@@ -1103,23 +1125,21 @@ async function transformDir(ctx, entry) {
 	}
 	const fullOutDir = resolve(ctx.pkgDir, entry.outDir);
 	await cleanOutputDir(ctx.pkgDir, fullOutDir, entry.clean ?? true);
-	const { statSync: statSync$1 } = await import("node:fs");
+	const { statSync } = await import("node:fs");
 	let inputDir = entry.input;
 	try {
-		const stats = statSync$1(inputDir);
-		if (stats.isFile()) {
+		if (statSync(inputDir).isFile()) {
 			inputDir = dirname(inputDir);
 			consola.warn(`Transform input should be a directory, not a file. Using directory: ${fmtPath(inputDir)}`);
 		}
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
-	const promises$1 = [];
+	const promises = [];
 	const files = await glob$1("**/*.*", { cwd: inputDir });
-	for await (const entryName of files) promises$1.push((async () => {
+	for await (const entryName of files) promises.push((async () => {
 		const entryPath = join(inputDir, entryName);
-		const ext = extname(entryPath);
-		switch (ext) {
+		switch (extname(entryPath)) {
 			case ".ts":
 			case ".tsx":
 			case ".jsx": {
@@ -1133,11 +1153,7 @@ async function transformDir(ctx, entry) {
 				let entryDistPath = join(entry.outDir, outputFileName);
 				await mkdir(dirname(entryDistPath), { recursive: true });
 				await writeFile(entryDistPath, transformed.code, "utf8");
-				if (entry.sourcemap && transformed.map) {
-					const mapPath = `${entryDistPath}.map`;
-					const mapContent = typeof transformed.map === "string" ? transformed.map : JSON.stringify(transformed.map);
-					await writeFile(mapPath, mapContent, "utf8");
-				}
+				if (entry.sourcemap && transformed.map) await writeFile(`${entryDistPath}.map`, typeof transformed.map === "string" ? transformed.map : JSON.stringify(transformed.map), "utf8");
 				if (entry.hash && !hasHash(entryDistPath)) {
 					const hashedPath = addHashToFilename(entryDistPath, transformed.code);
 					const { rename } = await import("node:fs/promises");
@@ -1151,8 +1167,7 @@ async function transformDir(ctx, entry) {
 						fixedExtension: entry.fixedExtension,
 						outExtensions: entry.outExtensions
 					});
-					const dtsPath = join(entry.outDir, dtsFileName);
-					await writeFile(dtsPath, transformed.declaration, "utf8");
+					await writeFile(join(entry.outDir, dtsFileName), transformed.declaration, "utf8");
 				}
 				return entryDistPath;
 			}
@@ -1166,7 +1181,7 @@ async function transformDir(ctx, entry) {
 			}
 		}
 	})());
-	const writtenFiles = await Promise.all(promises$1);
+	const writtenFiles = await Promise.all(promises);
 	if (entry.copy) await copyFiles(ctx.pkgDir, fullOutDir, entry.copy);
 	consola.log(`\n${colors.magenta("[transform] ")}${colors.underline(`${fmtPath(entry.outDir)}/`)}\n${writtenFiles.map((f) => colors.dim(fmtPath(f))).join("\n\n")}`);
 }
@@ -1176,9 +1191,8 @@ async function transformDir(ctx, entry) {
 async function transformModule(entryPath, entry) {
 	let sourceText = await readFile(entryPath, "utf8");
 	const ext = extname(entryPath);
-	const lang = ext === ".tsx" || ext === ".jsx" ? "tsx" : "ts";
 	const sourceOptions = {
-		lang,
+		lang: ext === ".tsx" || ext === ".jsx" ? "tsx" : "ts",
 		sourceType: "module"
 	};
 	const parsed = parseSync(entryPath, sourceText, { ...sourceOptions });
@@ -1272,14 +1286,13 @@ var Logger = class {
 		this.updateConsolaLevel();
 	}
 	updateConsolaLevel() {
-		const levelMap = {
+		consola.level = {
 			silent: 0,
 			error: 1,
 			warn: 2,
 			info: 3,
 			verbose: 4
-		};
-		consola.level = levelMap[this.level];
+		}[this.level];
 	}
 	silent(message, ...args) {
 		console.log(message, ...args);
@@ -1404,8 +1417,7 @@ async function loadViteConfig(cwd) {
 	try {
 		logger.verbose(`Loading Vite config from: ${configPath}`);
 		const configModule = await import(configPath);
-		const viteConfig = configModule.default || configModule;
-		return convertViteConfig(viteConfig);
+		return convertViteConfig(configModule.default || configModule);
 	} catch (error) {
 		logger.error(`Failed to load Vite config from ${configPath}:`, error);
 		return {};
@@ -1468,7 +1480,7 @@ function convertFormats(formats) {
 */
 function convertTarget(target) {
 	if (!target) return void 0;
-	const targetMap = {
+	return {
 		es2015: "es2015",
 		es2016: "es2016",
 		es2017: "es2017",
@@ -1478,8 +1490,7 @@ function convertTarget(target) {
 		es2021: "es2021",
 		es2022: "es2022",
 		esnext: "esnext"
-	};
-	return targetMap[target] || void 0;
+	}[target] || void 0;
 }
 /**
 * Convert Vite external config to robuild external
@@ -1497,8 +1508,8 @@ function normalizePath$1(path, resolveFrom) {
 * Perform watch build using rolldown's built-in watch mode
 */
 async function performWatchBuild(config, ctx, startTime) {
-	const { performBuild: performBuild$1 } = await import("./build-S2eglIZn.mjs");
-	await performBuild$1(config, ctx, startTime);
+	const { performBuild } = await import("./build-Cm8LX2zF.mjs");
+	await performBuild(config, ctx, startTime);
 	const bundleEntries = (config.entries || []).filter((entry) => {
 		if (typeof entry === "string") return !entry.endsWith("/");
 		return entry.type === "bundle";
@@ -1518,7 +1529,7 @@ async function performWatchBuild(config, ctx, startTime) {
 */
 async function startRolldownWatch(config, ctx, bundleEntries) {
 	logger.info("🚧 Using rolldown built-in watch mode...");
-	const { RobuildPluginManager: RobuildPluginManager$1 } = await import("./plugin-manager-WN1-NA--.mjs");
+	const { RobuildPluginManager } = await import("./plugin-manager-pCQvlo7q.mjs");
 	const watchConfigs = [];
 	for (const rawEntry of bundleEntries) {
 		let entry;
@@ -1566,8 +1577,11 @@ async function startRolldownWatch(config, ctx, bundleEntries) {
 		if (Array.isArray(normalizedInput)) rolldownInput = normalizedInput[0];
 		else if (typeof normalizedInput === "object") rolldownInput = normalizedInput;
 		else rolldownInput = normalizedInput;
-		const pluginManager = new RobuildPluginManager$1(config, entry, ctx.pkgDir);
-		const rolldownPlugins = [...pluginManager.getRolldownPlugins(), ...entry.rolldown?.plugins || []];
+		const rolldownPlugins = [...new RobuildPluginManager(config, entry, ctx.pkgDir).getRolldownPlugins(), ...entry.rolldown?.plugins || []];
+		const externalConfig = resolveExternalConfig(ctx, {
+			external: entry.external,
+			noExternal: entry.noExternal
+		});
 		const watchConfig = {
 			input: rolldownInput,
 			output: {
@@ -1577,6 +1591,7 @@ async function startRolldownWatch(config, ctx, bundleEntries) {
 				sourcemap: entry.sourcemap
 			},
 			platform: platform === "node" ? "node" : "neutral",
+			external: externalConfig,
 			transform: { target },
 			plugins: rolldownPlugins
 		};
@@ -1675,17 +1690,15 @@ async function build(config) {
 	if (config.logLevel) configureLogger(config.logLevel);
 	resetLogCounts();
 	const pkgDir = normalizePath(config.cwd);
-	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
 	const ctx = {
-		pkg,
+		pkg: await readJSON(join(pkgDir, "package.json")).catch(() => ({})),
 		pkgDir
 	};
 	let finalConfig = config;
 	if (config.fromVite) {
 		logger.verbose("Loading configuration from Vite config file");
-		const viteConfig = await loadViteConfig(pkgDir);
 		finalConfig = {
-			...viteConfig,
+			...await loadViteConfig(pkgDir),
 			...config
 		};
 	}
@@ -1721,8 +1734,7 @@ async function performBuild(config, ctx, startTime) {
 		} else entry = rawEntry;
 		if (entry.type === "bundle") entry = inheritConfig(entry, config);
 		else if (entry.type === "transform") entry = inheritConfig(entry, config);
-		const hasInput = entry.type === "transform" ? !!entry.input : !!(entry.input || entry.entry);
-		if (!hasInput) throw new Error(`Build entry missing \`input\` or \`entry\`: ${JSON.stringify(entry, null, 2)}`);
+		if (!(entry.type === "transform" ? !!entry.input : !!(entry.input || entry.entry))) throw new Error(`Build entry missing \`input\` or \`entry\`: ${JSON.stringify(entry, null, 2)}`);
 		entry = { ...entry };
 		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
 		if (entry.type === "transform") {
@@ -1757,9 +1769,8 @@ function normalizePath(path, resolveFrom) {
 	return typeof path === "string" && isAbsolute(path) ? path : path instanceof URL ? fileURLToPath(path) : resolve(resolveFrom || ".", path || ".");
 }
 async function readJSON(specifier) {
-	const module = await import(specifier, { with: { type: "json" } });
-	return module.default;
+	return (await import(specifier, { with: { type: "json" } })).default;
 }
 
 //#endregion
-export { SHEBANG_RE, build, hasShebang, makeExecutable, nodeProtocolPlugin, performBuild, shebangPlugin };
+export { makeExecutable as a, hasShebang as i, performBuild as n, shebangPlugin as o, SHEBANG_RE as r, nodeProtocolPlugin as s, build as t };