@nasti-toolchain/nasti 1.6.3 → 1.6.4

package/dist/index.js

@@ -353,8 +353,61 @@ var init_resolve = __esm({
   }
 });
 
-// src/plugins/css.ts
+// src/plugins/tailwind.ts
 import path3 from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+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 = createRequire2(path3.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(pathToFileURL2(nodePath).href);
+  const oxide = await import(pathToFileURL2(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: path3.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 TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    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
+import path4 from "path";
 function cssPlugin(config) {
   return {
     name: "nasti:css",
@@ -362,9 +415,14 @@ 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);
       if (config.command === "serve") {
         const escaped = JSON.stringify(rewritten);
         return {
@@ -399,19 +457,20 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = path3.resolve(path3.dirname(from), url);
-    const relative = "/" + path3.relative(root, resolved);
+    const resolved = path4.resolve(path4.dirname(from), url);
+    const relative = "/" + path4.relative(root, resolved);
     return `url(${relative})`;
   });
 }
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
+    init_tailwind();
   }
 });
 
 // src/plugins/assets.ts
-import path4 from "path";
+import path5 from "path";
 import fs3 from "fs";
 import crypto from "crypto";
 function assetsPlugin(config) {
@@ -424,7 +483,7 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = path4.extname(id.replace(/\?.*$/, ""));
+      const ext = path5.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
         if (fs3.existsSync(file)) {
@@ -436,12 +495,12 @@ function assetsPlugin(config) {
         const file = id.replace(/\?.*$/, "");
         if (!fs3.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + path4.relative(config.root, file);
+          const url = "/" + path5.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
         const content = fs3.readFileSync(file);
         const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = path4.basename(file, ext);
+        const basename = path5.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -481,7 +540,7 @@ var init_assets = __esm({
 });
 
 // src/plugins/html.ts
-import path5 from "path";
+import path6 from "path";
 import fs4 from "fs";
 function htmlPlugin(config) {
   return {
@@ -545,7 +604,7 @@ function serializeTag(tag) {
   return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
 }
 async function readHtmlFile(root) {
-  const htmlPath = path5.resolve(root, "index.html");
+  const htmlPath = path6.resolve(root, "index.html");
   if (!fs4.existsSync(htmlPath)) return null;
   return fs4.readFileSync(htmlPath, "utf-8");
 }
@@ -601,7 +660,7 @@ var init_transformer = __esm({
 });
 
 // src/core/env.ts
-import path6 from "path";
+import path7 from "path";
 import fs5 from "fs";
 function loadEnv(mode, root, prefixes) {
   const envFiles = [
@@ -612,7 +671,7 @@ function loadEnv(mode, root, prefixes) {
   ];
   const raw = {};
   for (const file of envFiles) {
-    const filePath = path6.resolve(root, file);
+    const filePath = path7.resolve(root, file);
     if (!fs5.existsSync(filePath)) continue;
     const content = fs5.readFileSync(filePath, "utf-8");
     for (const line of content.split("\n")) {
@@ -786,17 +845,17 @@ var build_exports = {};
 __export(build_exports, {
   build: () => build
 });
-import path7 from "path";
+import path8 from "path";
 import fs6 from "fs";
 import { rolldown } from "rolldown";
 import pc from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.6.3"}`));
+  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.6.4"}`));
   console.log(pc.dim(`  root: ${config.root}`));
   console.log(pc.dim(`  mode: ${config.mode}`));
-  const outDir = path7.resolve(config.root, config.build.outDir);
+  const outDir = path8.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && fs6.existsSync(outDir)) {
     fs6.rmSync(outDir, { recursive: true, force: true });
   }
@@ -808,14 +867,14 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(path7.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(path8.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 = path7.resolve(config.root, entry);
+      const fullPath = path8.resolve(config.root, entry);
       if (fs6.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
@@ -880,8 +939,8 @@ async function build(inlineConfig = {}) {
   await bundle.close();
   await pluginContainer.buildEnd();
   for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = path7.resolve(outDir, ef.fileName);
-    fs6.mkdirSync(path7.dirname(dest), { recursive: true });
+    const dest = path8.resolve(outDir, ef.fileName);
+    fs6.mkdirSync(path8.dirname(dest), { recursive: true });
     fs6.writeFileSync(dest, ef.source);
   }
   if (html) {
@@ -899,14 +958,14 @@ async function build(inlineConfig = {}) {
     }
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = path7.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = path8.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    fs6.writeFileSync(path7.resolve(outDir, "index.html"), processedHtml);
+    fs6.writeFileSync(path8.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -1118,18 +1177,18 @@ __export(middleware_exports, {
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
-import path9 from "path";
+import path10 from "path";
 import fs8 from "fs";
-import { createRequire as createRequire2 } from "module";
-import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
+import { createRequire as createRequire3 } from "module";
+import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
 function getReactRefreshRuntimeEsm() {
   if (__refreshRuntimeCache) return __refreshRuntimeCache;
   let cjsPath;
   try {
     const pkgPath = __require.resolve("react-refresh/package.json");
-    cjsPath = path9.join(path9.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    cjsPath = path10.join(path10.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = path9.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    cjsPath = path10.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
     if (!fs8.existsSync(cjsPath)) {
       const origMsg = err instanceof Error ? err.message : String(err);
       throw new Error(
@@ -1269,9 +1328,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() };
@@ -1350,7 +1409,7 @@ async function loadVirtualModule(spec, ctx) {
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
   ));
-  const anchor = path9.join(config.root, "__nasti_virtual__.ts");
+  const anchor = path10.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -1393,13 +1452,13 @@ async function doBundlePackage(entryFile) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile) {
-  const NM = `${path9.sep}node_modules${path9.sep}`;
+  const NM = `${path10.sep}node_modules${path10.sep}`;
   if (!entryFile.includes(NM)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = path9.dirname(entryFile);
+  let dir = path10.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = path9.join(dir, "package.json");
+    const pkgJsonPath = path10.join(dir, "package.json");
     if (fs8.existsSync(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
@@ -1411,21 +1470,21 @@ async function tryGenerateSubpathShim(entryFile) {
       } catch {
       }
     }
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
     if (!dir.includes(NM)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = path9.extname(entryFile);
+  const entryExt = path10.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (path9.resolve(mainEntry) === path9.resolve(entryFile)) return null;
+  if (path10.resolve(mainEntry) === path10.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
-    mainNs = await import(pathToFileURL2(mainEntry).href);
-    subNs = await import(pathToFileURL2(entryFile).href);
+    mainNs = await import(pathToFileURL3(mainEntry).href);
+    subNs = await import(pathToFileURL3(entryFile).href);
   } catch {
     return null;
   }
@@ -1456,7 +1515,7 @@ async function tryGenerateSubpathShim(entryFile) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = path9.join(pkgDir, "package.json");
+  const pkgJsonPath = path10.join(pkgDir, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
@@ -1478,13 +1537,13 @@ function pickMainEntryByExtension(pkgDir, preferredExt) {
   if (typeof pkg.module === "string") candidates.push(pkg.module);
   if (typeof pkg.main === "string") candidates.push(pkg.main);
   for (const cand of candidates) {
-    if (path9.extname(cand) === preferredExt) {
-      const full = path9.resolve(pkgDir, cand);
+    if (path10.extname(cand) === preferredExt) {
+      const full = path10.resolve(pkgDir, cand);
       if (fs8.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = path9.resolve(pkgDir, cand);
+    const full = path10.resolve(pkgDir, cand);
     if (fs8.existsSync(full)) return full;
   }
   return null;
@@ -1510,19 +1569,20 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire5 } = await import("module");
-    const req = createRequire5(entryFile);
+    const { createRequire: createRequire6 } = await import("module");
+    const req = createRequire6(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")
     );
@@ -1532,11 +1592,11 @@ async function injectCjsNamedExports(code, entryFile) {
 }
 function rewriteImports(code, config, filePath) {
   const root = config.root;
-  const fileDir = path9.dirname(filePath);
+  const fileDir = path10.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + path9.relative(root, abs).replace(/\\/g, "/");
+  const toRootUrl = (abs) => "/" + path10.relative(root, abs).replace(/\\/g, "/");
   const transformSpec = (spec) => {
     const suffixMatch = spec.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
@@ -1545,18 +1605,18 @@ function rewriteImports(code, config, filePath) {
       if (baseSpec === key || baseSpec.startsWith(key + "/")) {
         const aliasBase = resolveAliasTarget(value, root);
         const sub = baseSpec.slice(key.length).replace(/^\//, "");
-        const target = sub ? path9.join(aliasBase, sub) : aliasBase;
+        const target = sub ? path10.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
         return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const target = path9.resolve(fileDir, baseSpec);
+      const target = path10.resolve(fileDir, baseSpec);
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const target = path9.join(root, baseSpec.replace(/^\//, ""));
+      const target = path10.join(root, baseSpec.replace(/^\//, ""));
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
@@ -1575,9 +1635,9 @@ function rewriteImports(code, config, filePath) {
   );
 }
 function resolveAliasTarget(value, root) {
-  if (path9.isAbsolute(value) && fs8.existsSync(value)) return value;
-  if (value.startsWith("/")) return path9.join(root, value.slice(1));
-  return path9.resolve(root, value);
+  if (path10.isAbsolute(value) && fs8.existsSync(value)) return value;
+  if (value.startsWith("/")) return path10.join(root, value.slice(1));
+  return path10.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
   if (fs8.existsSync(target) && fs8.statSync(target).isFile()) return target;
@@ -1587,15 +1647,15 @@ function tryResolveDiskPath(target) {
   }
   if (fs8.existsSync(target) && fs8.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = path9.join(target, "index" + ext);
+      const idx = path10.join(target, "index" + ext);
       if (fs8.existsSync(idx) && fs8.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
 function isUnderRoot(abs, root) {
-  const rel = path9.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !path9.isAbsolute(rel);
+  const rel = path10.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !path10.isAbsolute(rel);
 }
 function resolveNodeModule(root, moduleName) {
   let pkgName;
@@ -1612,17 +1672,17 @@ function resolveNodeModule(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = path9.join(dir, "node_modules", pkgName);
+    const candidate = path10.join(dir, "node_modules", pkgName);
     if (fs8.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = path9.join(pkgDir, "package.json");
+  const pkgJsonPath = path10.join(pkgDir, "package.json");
   if (!fs8.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
@@ -1639,12 +1699,12 @@ function resolveNodeModule(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = path9.dirname(pkg[field]);
+        const dir2 = path10.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = path9.join(pkgDir, dir2, subpath);
+      const direct = path10.join(pkgDir, dir2, subpath);
       if (fs8.existsSync(direct) && fs8.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
         if (fs8.existsSync(direct + ext)) return direct + ext;
@@ -1654,24 +1714,24 @@ function resolveNodeModule(root, moduleName) {
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = path9.join(pkgDir, pkg[field]);
+      const entry = path10.join(pkgDir, pkg[field]);
       if (fs8.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = path9.join(pkgDir, "index.js");
+  const indexFallback = path10.join(pkgDir, "index.js");
   if (fs8.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports, key, pkgDir) {
   if (typeof exports === "string") {
-    return key === "." ? path9.join(pkgDir, exports) : null;
+    return key === "." ? path10.join(pkgDir, exports) : null;
   }
   const entry = exports[key];
   if (entry === void 0) return null;
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return path9.join(pkgDir, value);
+  if (typeof value === "string") return path10.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -1695,7 +1755,7 @@ function resolveUrlToFile(url, root) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = path9.resolve(root, cleanUrl.replace(/^\//, ""));
+  const filePath = path10.resolve(root, cleanUrl.replace(/^\//, ""));
   if (fs8.existsSync(filePath) && fs8.statSync(filePath).isFile()) {
     return filePath;
   }
@@ -1704,7 +1764,7 @@ function resolveUrlToFile(url, root) {
     if (fs8.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = path9.join(filePath, "index" + ext);
+    const indexFile = path10.join(filePath, "index" + ext);
     if (fs8.existsSync(indexFile)) return indexFile;
   }
   return null;
@@ -1713,7 +1773,7 @@ function isModuleRequest(url) {
   const cleanUrl = url.split("?")[0];
   if (/\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl)) return true;
   if (cleanUrl.startsWith("/@modules/")) return true;
-  if (!path9.extname(cleanUrl)) return true;
+  if (!path10.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
@@ -1851,8 +1911,8 @@ var init_middleware = __esm({
     init_transformer();
     init_html();
     init_env();
-    __dirname_esm = path9.dirname(fileURLToPath(import.meta.url));
-    __require = createRequire2(import.meta.url);
+    __dirname_esm = path10.dirname(fileURLToPath(import.meta.url));
+    __require = createRequire3(import.meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_GLOBAL_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
@@ -1869,11 +1929,11 @@ window.__vite_plugin_react_preamble_installed__ = true;
 });
 
 // src/server/hmr.ts
-import path10 from "path";
+import path11 from "path";
 import fs9 from "fs";
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
-  const relativePath = "/" + path10.relative(config.root, file);
+  const relativePath = "/" + path11.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
@@ -1930,7 +1990,7 @@ __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path11 from "path";
+import path12 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
@@ -1954,20 +2014,20 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = path11.resolve(config.root, "public");
+  const publicDir = path12.resolve(config.root, "public");
   app.use(sirv(publicDir, { dev: true, etag: true }));
   app.use(sirv(config.root, { dev: true, etag: true }));
   const httpServer = http.createServer(app);
   const ws = createWebSocketServer(httpServer);
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = path11.resolve(config.root, config.build.outDir);
+  const outDirAbs = path12.resolve(config.root, config.build.outDir);
   const watcher = watch(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path11.sep)) return true;
-      const rel = path11.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || path11.isAbsolute(rel)) return false;
-      for (const seg of rel.split(path11.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path12.sep)) return true;
+      const rel = path12.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || path12.isAbsolute(rel)) return false;
+      for (const seg of rel.split(path12.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -1999,7 +2059,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(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.6.3"}`));
+          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.6.4"}`));
           console.log();
           console.log(`  ${pc3.green(">")} Local:   ${pc3.cyan(localUrl)}`);
           if (networkUrl) {
@@ -2078,7 +2138,7 @@ init_build();
 // src/build/electron.ts
 init_config();
 init_resolve();
-import path8 from "path";
+import path9 from "path";
 import fs7 from "fs";
 import { rolldown as rolldown2 } from "rolldown";
 import pc2 from "picocolors";
@@ -2123,16 +2183,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.6.3"}`));
+  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.6.4"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
   console.log(pc2.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = path8.resolve(config.root, config.build.outDir);
+  const outDir = path9.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && fs7.existsSync(outDir)) {
     fs7.rmSync(outDir, { recursive: true, force: true });
   }
   fs7.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = path8.join(outDir, "renderer");
+  const rendererOutDir = path9.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2143,7 +2203,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = path8.resolve(config.root, config.electron.main);
+  const mainEntry = path9.resolve(config.root, config.electron.main);
   if (!fs7.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2162,7 +2222,7 @@ async function buildElectron(inlineConfig = {}) {
       console.warn(pc2.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = path8.basename(entry).replace(/\.[^.]+$/, "");
+    const base = path9.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2174,10 +2234,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(pc2.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(pc2.dim(`  renderer: ${path8.relative(config.root, rendererOutDir)}/`));
-  console.log(pc2.dim(`  main:     ${path8.relative(config.root, mainFile)}`));
+  console.log(pc2.dim(`  renderer: ${path9.relative(config.root, rendererOutDir)}/`));
+  console.log(pc2.dim(`  main:     ${path9.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(pc2.dim(`  preload:  ${path8.relative(config.root, pf)}`));
+    console.log(pc2.dim(`  preload:  ${path9.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2208,7 +2268,7 @@ async function bundleNode(config, entry, opts) {
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
     ...config.build.rolldownOptions
   });
-  fs7.mkdirSync(path8.dirname(opts.outFile), { recursive: true });
+  fs7.mkdirSync(path9.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2217,16 +2277,16 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle.close();
-  console.log(pc2.dim(`  \u2713 ${opts.label} \u2192 ${path8.relative(config.root, opts.outFile)}`));
+  console.log(pc2.dim(`  \u2713 ${opts.label} \u2192 ${path9.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return path8.join(outDir, base + ext);
+  return path9.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => path8.resolve(root, p));
+  return list.map((p) => path9.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -2241,7 +2301,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = path8.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = path9.resolve(root, "node_modules/electron/package.json");
     if (!fs7.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2256,9 +2316,9 @@ init_server();
 
 // src/server/electron-dev.ts
 init_config();
-import path12 from "path";
+import path13 from "path";
 import fs10 from "fs";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc4 from "picocolors";
@@ -2270,17 +2330,17 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.6.3"}`));
+  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.6.4"}`));
   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(pc4.dim(`  renderer: ${devUrl}`));
-  const stageDir = path12.resolve(config.root, ".nasti");
+  const stageDir = path13.resolve(config.root, ".nasti");
   fs10.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = path12.resolve(config.root, config.electron.main);
+  const mainEntry = path13.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = path12.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = path13.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -2291,8 +2351,8 @@ async function startElectronDev(inlineConfig = {}) {
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
       if (!fs10.existsSync(entry)) continue;
-      const base = path12.basename(entry).replace(/\.[^.]+$/, "");
-      const out = path12.join(stageDir, base + extFor(config.electron.preloadFormat));
+      const base = path13.basename(entry).replace(/\.[^.]+$/, "");
+      const out = path13.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -2407,7 +2467,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs10.mkdirSync(path12.dirname(opts.outFile), { recursive: true });
+  fs10.mkdirSync(path13.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2424,7 +2484,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire3(path12.resolve(config.root, "package.json"));
+    const require2 = createRequire4(path13.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
@@ -2454,10 +2514,10 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-import path13 from "path";
+import path14 from "path";
 import fs11 from "fs";
 import crypto2 from "crypto";
-import { createRequire as createRequire4 } from "module";
+import { createRequire as createRequire5 } from "module";
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -2476,7 +2536,7 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = createRequire4(path13.resolve(root, "package.json"));
+    const require2 = createRequire5(path14.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
     const pkg = JSON.parse(fs11.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
@@ -2498,13 +2558,13 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = path13.join(cacheDir, `${worker.label}.worker.js`);
+    const cacheFile = path14.join(cacheDir, `${worker.label}.worker.js`);
     if (fs11.existsSync(cacheFile)) return cacheFile;
     const existing = building.get(worker.label);
     if (existing) return existing;
     const task = (async () => {
       const { rolldown: rolldown4 } = await import("rolldown");
-      const require2 = createRequire4(path13.resolve(resolvedConfig.root, "package.json"));
+      const require2 = createRequire5(path14.resolve(resolvedConfig.root, "package.json"));
       let entry;
       try {
         entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });
@@ -2571,12 +2631,12 @@ function monacoEditorPlugin(options = {}) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
       const key = crypto2.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = path13.resolve(config.root, "node_modules/.nasti/monaco", key);
+      cacheDir = path14.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoDir = path13.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoDir = path14.resolve(resolvedConfig.root, "node_modules/monaco-editor");
       try {
         watcher?.unwatch?.(monacoDir);
       } catch {
@@ -2641,7 +2701,7 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? path13.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path13.resolve(
+      ) : isCDN(publicPath) ? path14.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path14.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
@@ -2650,7 +2710,7 @@ self.monaco = monaco;`,
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          fs11.copyFileSync(cacheFile, path13.join(outDir, `${worker.label}.worker.js`));
+          fs11.copyFileSync(cacheFile, path14.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}