@nasti-toolchain/nasti 1.6.3 → 1.6.5

package/dist/cli.cjs

@@ -56,7 +56,8 @@ var init_defaults = __esm({
       sourcemap: false,
       target: "es2022",
       rolldownOptions: {},
-      emptyOutDir: true
+      emptyOutDir: true,
+      css: {}
     };
     defaultElectron = {
       main: "src/electron/main.ts",
@@ -919,9 +920,9 @@ function transformMiddleware(ctx) {
 async function transformRequest(url, ctx) {
   const { config, pluginContainer, moduleGraph } = ctx;
   const cleanReqUrl = url.split("?")[0];
-  const cached = moduleGraph.getModuleByUrl(url);
-  if (cached?.transformResult) {
-    return cached.transformResult;
+  const cached2 = moduleGraph.getModuleByUrl(url);
+  if (cached2?.transformResult) {
+    return cached2.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
     return { code: getReactRefreshRuntimeEsm() };
@@ -1160,19 +1161,20 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire4 } = await import("module");
-    const req = createRequire4(entryFile);
+    const { createRequire: createRequire5 } = await import("module");
+    const req = createRequire5(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
       (k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k)
     );
-    if (namedKeys.length === 0) return code;
+    const hasEsmInterop = cjsExports.__esModule === true && "default" in cjsExports;
+    if (!hasEsmInterop && namedKeys.length === 0) return code;
     return code.replace(
       /^export default (\w+\(\));?\s*$/m,
       (_, call) => [
         `const __cjsMod = ${call};`,
-        `export default __cjsMod;`,
+        hasEsmInterop ? `export default __cjsMod.default;` : `export default __cjsMod;`,
         ...namedKeys.map((k) => `export const ${k} = __cjsMod[${JSON.stringify(k)}];`)
       ].join("\n")
     );
@@ -1584,20 +1586,29 @@ var init_hmr = __esm({
 function resolvePlugin(config) {
   const { alias, extensions } = config.resolve;
   const require2 = (0, import_node_module2.createRequire)(import_node_path6.default.resolve(config.root, "package.json"));
+  const aliasEntries = Object.entries(alias).sort(
+    ([a], [b]) => b.length - a.length
+  );
   return {
     name: "nasti:resolve",
     enforce: "pre",
     resolveId(source, importer) {
-      for (const [key, value] of Object.entries(alias)) {
+      for (const [key, value] of aliasEntries) {
         if (source === key || source.startsWith(key + "/")) {
-          source = source.replace(key, value);
-          if (!import_node_path6.default.isAbsolute(source)) {
-            source = import_node_path6.default.resolve(config.root, source);
-          }
+          const aliasBase = resolveAliasTarget2(value, config.root);
+          const sub = source.slice(key.length).replace(/^\//, "");
+          const target = sub ? import_node_path6.default.join(aliasBase, sub) : aliasBase;
+          const resolved = tryResolveFile(target, extensions);
+          if (resolved) return resolved;
           break;
         }
       }
-      if (import_node_path6.default.isAbsolute(source)) {
+      if (source.startsWith("/") && !source.startsWith("//")) {
+        const rootRelative = import_node_path6.default.join(config.root, source.slice(1));
+        const resolved = tryResolveFile(rootRelative, extensions);
+        if (resolved) return resolved;
+      }
+      if (import_node_path6.default.isAbsolute(source) && import_node_fs6.default.existsSync(source)) {
         const resolved = tryResolveFile(source, extensions);
         if (resolved) return resolved;
       }
@@ -1620,6 +1631,7 @@ function resolvePlugin(config) {
       return null;
     },
     load(id) {
+      if (id.startsWith("\0")) return null;
       if (!import_node_fs6.default.existsSync(id)) return null;
       if (id.endsWith(".json")) {
         const content = import_node_fs6.default.readFileSync(id, "utf-8");
@@ -1629,6 +1641,11 @@ function resolvePlugin(config) {
     }
   };
 }
+function resolveAliasTarget2(value, root) {
+  if (import_node_path6.default.isAbsolute(value) && import_node_fs6.default.existsSync(value)) return value;
+  if (value.startsWith("/")) return import_node_path6.default.join(root, value.slice(1));
+  return import_node_path6.default.resolve(root, value);
+}
 function tryResolveFile(file, extensions) {
   if (import_node_fs6.default.existsSync(file) && import_node_fs6.default.statSync(file).isFile()) {
     return file;
@@ -1659,6 +1676,59 @@ var init_resolve = __esm({
   }
 });
 
+// src/plugins/tailwind.ts
+function hasTailwindDirectives(css) {
+  const withoutBlockComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const withoutLineComments = withoutBlockComments.replace(/\/\/.*$/gm, "");
+  return TAILWIND_DIRECTIVE_RE.test(withoutLineComments);
+}
+async function loadTailwind(projectRoot) {
+  if (cached && cachedRoot === projectRoot) return cached;
+  const req = (0, import_node_module3.createRequire)(import_node_path7.default.join(projectRoot, "package.json"));
+  let nodePath;
+  let oxidePath;
+  try {
+    nodePath = req.resolve("@tailwindcss/node");
+    oxidePath = req.resolve("@tailwindcss/oxide");
+  } catch {
+    throw new Error(
+      "[nasti] CSS contains Tailwind v4 directives but `@tailwindcss/node` and/or `@tailwindcss/oxide` are not installed in this project. Install them with:  npm i -D tailwindcss @tailwindcss/node @tailwindcss/oxide"
+    );
+  }
+  const node = await import((0, import_node_url3.pathToFileURL)(nodePath).href);
+  const oxide = await import((0, import_node_url3.pathToFileURL)(oxidePath).href);
+  cached = { node, oxide };
+  cachedRoot = projectRoot;
+  return cached;
+}
+async function compileTailwind(css, fromFile, projectRoot) {
+  const { node, oxide } = await loadTailwind(projectRoot);
+  const dependencies = [];
+  const compiler = await node.compile(css, {
+    base: import_node_path7.default.dirname(fromFile),
+    from: fromFile,
+    onDependency: (p) => dependencies.push(p)
+  });
+  const scanner = new oxide.Scanner({ sources: compiler.sources });
+  const candidates = scanner.scan();
+  return {
+    css: compiler.build(candidates),
+    dependencies: [...dependencies, ...scanner.files]
+  };
+}
+var import_node_path7, import_node_module3, import_node_url3, TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    import_node_path7 = __toESM(require("path"), 1);
+    import_node_module3 = require("module");
+    import_node_url3 = require("url");
+    TAILWIND_DIRECTIVE_RE = /@(?:import\s+["']tailwindcss(?:\b|\/)|tailwind\b|theme\b|apply\b|plugin\b|source\b|utility\b|variant\b|custom-variant\b|reference\b)/;
+    cached = null;
+    cachedRoot = null;
+  }
+});
+
 // src/plugins/css.ts
 function cssPlugin(config) {
   return {
@@ -1667,11 +1737,16 @@ function cssPlugin(config) {
       if (source.endsWith(".css")) return null;
       return null;
     },
-    transform(code, id) {
+    async transform(code, id) {
       if (!id.endsWith(".css")) return null;
-      const rewritten = rewriteCssUrls(code, id, config.root);
+      let cssSource = code;
+      if (hasTailwindDirectives(code)) {
+        const compiled = await compileTailwind(code, id, config.root);
+        cssSource = compiled.css;
+      }
+      const rewritten = rewriteCssUrls(cssSource, id, config.root);
+      const escaped = JSON.stringify(rewritten);
       if (config.command === "serve") {
-        const escaped = JSON.stringify(rewritten);
         return {
           code: `
 const css = ${escaped};
@@ -1695,7 +1770,42 @@ export default css;
 `
         };
       }
-      return rewritten !== code ? { code: rewritten } : null;
+      const cssConfig = config.build.css || {};
+      const nonce = cssConfig.nonce;
+      const emitCssFile = cssConfig.emitCssFile;
+      if (emitCssFile) {
+        const fileName = `assets/${import_node_path8.default.basename(id, ".css")}.css`;
+        this.emitFile({
+          type: "asset",
+          fileName,
+          source: rewritten
+        });
+        return {
+          code: `
+const link = document.createElement('link');
+link.rel = 'stylesheet';
+link.href = ${JSON.stringify("/" + fileName)};
+document.head.appendChild(link);
+
+export default ${escaped};
+`,
+          moduleType: "js"
+        };
+      }
+      const nonceAttr = nonce ? `style.setAttribute('nonce', ${JSON.stringify(nonce)});` : "";
+      return {
+        code: `
+const css = ${escaped};
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+${nonceAttr}
+style.textContent = css;
+document.head.appendChild(style);
+
+export default css;
+`,
+        moduleType: "js"
+      };
     }
   };
 }
@@ -1704,16 +1814,17 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = import_node_path7.default.resolve(import_node_path7.default.dirname(from), url);
-    const relative = "/" + import_node_path7.default.relative(root, resolved);
+    const resolved = import_node_path8.default.resolve(import_node_path8.default.dirname(from), url);
+    const relative = "/" + import_node_path8.default.relative(root, resolved);
     return `url(${relative})`;
   });
 }
-var import_node_path7;
+var import_node_path8;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    init_tailwind();
   }
 });
 
@@ -1728,7 +1839,7 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = import_node_path8.default.extname(id.replace(/\?.*$/, ""));
+      const ext = import_node_path9.default.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
         if (import_node_fs7.default.existsSync(file)) {
@@ -1740,12 +1851,12 @@ function assetsPlugin(config) {
         const file = id.replace(/\?.*$/, "");
         if (!import_node_fs7.default.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + import_node_path8.default.relative(config.root, file);
+          const url = "/" + import_node_path9.default.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
         const content = import_node_fs7.default.readFileSync(file);
         const hash = import_node_crypto.default.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = import_node_path8.default.basename(file, ext);
+        const basename = import_node_path9.default.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -1753,11 +1864,11 @@ function assetsPlugin(config) {
     }
   };
 }
-var import_node_path8, import_node_fs7, import_node_crypto, ASSET_EXTENSIONS;
+var import_node_path9, import_node_fs7, import_node_crypto, ASSET_EXTENSIONS;
 var init_assets = __esm({
   "src/plugins/assets.ts"() {
     "use strict";
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
     import_node_fs7 = __toESM(require("fs"), 1);
     import_node_crypto = __toESM(require("crypto"), 1);
     ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -1810,20 +1921,20 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = import_node_path9.default.resolve(config.root, "public");
+  const publicDir = import_node_path10.default.resolve(config.root, "public");
   app.use((0, import_sirv.default)(publicDir, { dev: true, etag: true }));
   app.use((0, import_sirv.default)(config.root, { dev: true, etag: true }));
   const httpServer = import_node_http.default.createServer(app);
   const ws = createWebSocketServer(httpServer);
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = import_node_path9.default.resolve(config.root, config.build.outDir);
+  const outDirAbs = import_node_path10.default.resolve(config.root, config.build.outDir);
   const watcher = (0, import_chokidar.watch)(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path9.default.sep)) return true;
-      const rel = import_node_path9.default.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || import_node_path9.default.isAbsolute(rel)) return false;
-      for (const seg of rel.split(import_node_path9.default.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path10.default.sep)) return true;
+      const rel = import_node_path10.default.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || import_node_path10.default.isAbsolute(rel)) return false;
+      for (const seg of rel.split(import_node_path10.default.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -1855,7 +1966,7 @@ async function createServer(inlineConfig = {}) {
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(import_picocolors.default.cyan("  nasti dev server") + import_picocolors.default.dim(` v${"1.6.3"}`));
+          console.log(import_picocolors.default.cyan("  nasti dev server") + import_picocolors.default.dim(` v${"1.6.5"}`));
           console.log();
           console.log(`  ${import_picocolors.default.green(">")} Local:   ${import_picocolors.default.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1911,12 +2022,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path9, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors;
+var import_node_http, import_node_path10, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -1956,14 +2067,14 @@ function electronPlugin(config) {
     }
   };
 }
-var import_node_module3, NODE_BUILTINS, ELECTRON_MODULES;
+var import_node_module4, NODE_BUILTINS, ELECTRON_MODULES;
 var init_electron = __esm({
   "src/plugins/electron.ts"() {
     "use strict";
-    import_node_module3 = require("module");
+    import_node_module4 = require("module");
     NODE_BUILTINS = /* @__PURE__ */ new Set([
-      ...import_node_module3.builtinModules,
-      ...import_node_module3.builtinModules.map((m) => `node:${m}`)
+      ...import_node_module4.builtinModules,
+      ...import_node_module4.builtinModules.map((m) => `node:${m}`)
     ]);
     ELECTRON_MODULES = /* @__PURE__ */ new Set([
       "electron",
@@ -1982,10 +2093,10 @@ __export(build_exports, {
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${"1.6.3"}`));
+  console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${"1.6.5"}`));
   console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
-  const outDir = import_node_path10.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path11.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs8.default.existsSync(outDir)) {
     import_node_fs8.default.rmSync(outDir, { recursive: true, force: true });
   }
@@ -1997,14 +2108,14 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(import_node_path10.default.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(import_node_path11.default.resolve(config.root, src.replace(/^\//, "")));
       }
     }
   }
   if (entryPoints.length === 0) {
     const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
     for (const entry of fallbackEntries) {
-      const fullPath = import_node_path10.default.resolve(config.root, entry);
+      const fullPath = import_node_path11.default.resolve(config.root, entry);
       if (import_node_fs8.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
@@ -2036,9 +2147,11 @@ async function build(inlineConfig = {}) {
   };
   const env = loadEnv(config.mode, config.root, config.envPrefix);
   const envDefine = buildEnvDefine(env, config.mode);
+  const existingTransform = config.build.rolldownOptions?.transform;
+  const mergedDefine = { ...existingTransform?.define ?? {}, ...envDefine };
   const bundle = await (0, import_rolldown.rolldown)({
     input: entryPoints,
-    define: envDefine,
+    transform: { ...existingTransform, define: mergedDefine },
     plugins: [
       oxcTransformPlugin,
       // 转换 Nasti 插件为 Rolldown 插件格式
@@ -2069,8 +2182,8 @@ async function build(inlineConfig = {}) {
   await bundle.close();
   await pluginContainer.buildEnd();
   for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = import_node_path10.default.resolve(outDir, ef.fileName);
-    import_node_fs8.default.mkdirSync(import_node_path10.default.dirname(dest), { recursive: true });
+    const dest = import_node_path11.default.resolve(outDir, ef.fileName);
+    import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(dest), { recursive: true });
     import_node_fs8.default.writeFileSync(dest, ef.source);
   }
   if (html) {
@@ -2088,14 +2201,14 @@ async function build(inlineConfig = {}) {
     }
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = import_node_path10.default.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = import_node_path11.default.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    import_node_fs8.default.writeFileSync(import_node_path10.default.resolve(outDir, "index.html"), processedHtml);
+    import_node_fs8.default.writeFileSync(import_node_path11.default.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -2117,11 +2230,11 @@ function formatSize(bytes) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_path10, import_node_fs8, import_rolldown, import_picocolors2;
+var import_node_path11, import_node_fs8, import_rolldown, import_picocolors2;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("path"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
     import_node_fs8 = __toESM(require("fs"), 1);
     import_rolldown = require("rolldown");
     init_config();
@@ -2147,16 +2260,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors3.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors3.default.dim(` v${"1.6.3"}`));
+  console.log(import_picocolors3.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors3.default.dim(` v${"1.6.5"}`));
   console.log(import_picocolors3.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors3.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors3.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path11.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path12.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs9.default.existsSync(outDir)) {
     import_node_fs9.default.rmSync(outDir, { recursive: true, force: true });
   }
   import_node_fs9.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path11.default.join(outDir, "renderer");
+  const rendererOutDir = import_node_path12.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2167,7 +2280,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = import_node_path11.default.resolve(config.root, config.electron.main);
+  const mainEntry = import_node_path12.default.resolve(config.root, config.electron.main);
   if (!import_node_fs9.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2186,7 +2299,7 @@ async function buildElectron(inlineConfig = {}) {
       console.warn(import_picocolors3.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path11.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path12.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2198,10 +2311,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors3.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors3.default.dim(`  renderer: ${import_node_path11.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors3.default.dim(`  main:     ${import_node_path11.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors3.default.dim(`  renderer: ${import_node_path12.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors3.default.dim(`  main:     ${import_node_path12.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors3.default.dim(`  preload:  ${import_node_path11.default.relative(config.root, pf)}`));
+    console.log(import_picocolors3.default.dim(`  preload:  ${import_node_path12.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2225,14 +2338,16 @@ async function bundleNode(config, entry, opts) {
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
+  const existingTransform = config.build.rolldownOptions?.transform;
+  const mergedDefine = { ...existingTransform?.define ?? {}, ...envDefine };
   const bundle = await (0, import_rolldown2.rolldown)({
     input: entry,
-    define: envDefine,
+    transform: { ...existingTransform, define: mergedDefine },
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
     ...config.build.rolldownOptions
   });
-  import_node_fs9.default.mkdirSync(import_node_path11.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path12.default.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2241,16 +2356,16 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle.close();
-  console.log(import_picocolors3.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path11.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors3.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path12.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path11.default.join(outDir, base + ext);
+  return import_node_path12.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path11.default.resolve(root, p));
+  return list.map((p) => import_node_path12.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -2265,7 +2380,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = import_node_path11.default.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = import_node_path12.default.resolve(root, "node_modules/electron/package.json");
     if (!import_node_fs9.default.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(import_node_fs9.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2274,11 +2389,11 @@ function detectInstalledElectron(root) {
     return null;
   }
 }
-var import_node_path11, import_node_fs9, import_rolldown2, import_picocolors3;
+var import_node_path12, import_node_fs9, import_rolldown2, import_picocolors3;
 var init_electron2 = __esm({
   "src/build/electron.ts"() {
     "use strict";
-    import_node_path11 = __toESM(require("path"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
     import_node_fs9 = __toESM(require("fs"), 1);
     import_rolldown2 = require("rolldown");
     import_picocolors3 = __toESM(require("picocolors"), 1);
@@ -2299,17 +2414,17 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.6.3"}`));
+  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.6.5"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}/`;
   console.log(import_picocolors4.default.dim(`  renderer: ${devUrl}`));
-  const stageDir = import_node_path12.default.resolve(config.root, ".nasti");
+  const stageDir = import_node_path13.default.resolve(config.root, ".nasti");
   import_node_fs10.default.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = import_node_path12.default.resolve(config.root, config.electron.main);
+  const mainEntry = import_node_path13.default.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = import_node_path12.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = import_node_path13.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -2320,8 +2435,8 @@ async function startElectronDev(inlineConfig = {}) {
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
       if (!import_node_fs10.default.existsSync(entry)) continue;
-      const base = import_node_path12.default.basename(entry).replace(/\.[^.]+$/, "");
-      const out = import_node_path12.default.join(stageDir, base + extFor(config.electron.preloadFormat));
+      const base = import_node_path13.default.basename(entry).replace(/\.[^.]+$/, "");
+      const out = import_node_path13.default.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -2436,7 +2551,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs10.default.mkdirSync(import_node_path12.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs10.default.mkdirSync(import_node_path13.default.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2453,7 +2568,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = (0, import_node_module4.createRequire)(import_node_path12.default.resolve(config.root, "package.json"));
+    const require2 = (0, import_node_module5.createRequire)(import_node_path13.default.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && import_node_fs10.default.existsSync(electronModule)) {
@@ -2481,13 +2596,13 @@ function warnElectronVersion(config) {
     );
   }
 }
-var import_node_path12, import_node_fs10, import_node_module4, import_node_child_process, import_chokidar2, import_picocolors4, import_rolldown3;
+var import_node_path13, import_node_fs10, import_node_module5, import_node_child_process, import_chokidar2, import_picocolors4, import_rolldown3;
 var init_electron_dev = __esm({
   "src/server/electron-dev.ts"() {
     "use strict";
-    import_node_path12 = __toESM(require("path"), 1);
+    import_node_path13 = __toESM(require("path"), 1);
     import_node_fs10 = __toESM(require("fs"), 1);
-    import_node_module4 = require("module");
+    import_node_module5 = require("module");
     import_node_child_process = require("child_process");
     import_chokidar2 = __toESM(require("chokidar"), 1);
     import_picocolors4 = __toESM(require("picocolors"), 1);
@@ -2609,11 +2724,11 @@ cli.command("electron-build [root]", "Build Electron app for production").option
 cli.command("preview [root]", "Preview production build").option("--port <port>", "Port number", { default: 4173 }).option("--host [host]", "Hostname").option("--outDir <dir>", "Output directory to serve", { default: "dist" }).action(async (root, options) => {
   try {
     const http2 = await import("http");
-    const path13 = await import("path");
+    const path14 = await import("path");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path13.resolve(root ?? ".");
-    const outDir = path13.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path14.resolve(root ?? ".");
+    const outDir = path14.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
@@ -2634,6 +2749,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("1.6.3");
+cli.version("1.6.5");
 cli.parse();
 //# sourceMappingURL=cli.cjs.map