@nasti-toolchain/nasti 1.6.3 → 1.6.4

package/dist/index.cjs

@@ -376,6 +376,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_module2.createRequire)(import_node_path3.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_url2.pathToFileURL)(nodePath).href);
+  const oxide = await import((0, import_node_url2.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_path3.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_path3, import_node_module2, import_node_url2, TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_module2 = require("module");
+    import_node_url2 = 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 {
@@ -384,9 +437,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 {
@@ -421,16 +479,17 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = import_node_path3.default.resolve(import_node_path3.default.dirname(from), url);
-    const relative = "/" + import_node_path3.default.relative(root, resolved);
+    const resolved = import_node_path4.default.resolve(import_node_path4.default.dirname(from), url);
+    const relative = "/" + import_node_path4.default.relative(root, resolved);
     return `url(${relative})`;
   });
 }
-var import_node_path3;
+var import_node_path4;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    init_tailwind();
   }
 });
 
@@ -445,7 +504,7 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = import_node_path4.default.extname(id.replace(/\?.*$/, ""));
+      const ext = import_node_path5.default.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
         if (import_node_fs3.default.existsSync(file)) {
@@ -457,12 +516,12 @@ function assetsPlugin(config) {
         const file = id.replace(/\?.*$/, "");
         if (!import_node_fs3.default.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + import_node_path4.default.relative(config.root, file);
+          const url = "/" + import_node_path5.default.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
         const content = import_node_fs3.default.readFileSync(file);
         const hash = import_node_crypto.default.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = import_node_path4.default.basename(file, ext);
+        const basename = import_node_path5.default.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -470,11 +529,11 @@ function assetsPlugin(config) {
     }
   };
 }
-var import_node_path4, import_node_fs3, import_node_crypto, ASSET_EXTENSIONS;
+var import_node_path5, import_node_fs3, import_node_crypto, ASSET_EXTENSIONS;
 var init_assets = __esm({
   "src/plugins/assets.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
     import_node_fs3 = __toESM(require("fs"), 1);
     import_node_crypto = __toESM(require("crypto"), 1);
     ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -567,15 +626,15 @@ function serializeTag(tag) {
   return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
 }
 async function readHtmlFile(root) {
-  const htmlPath = import_node_path5.default.resolve(root, "index.html");
+  const htmlPath = import_node_path6.default.resolve(root, "index.html");
   if (!import_node_fs4.default.existsSync(htmlPath)) return null;
   return import_node_fs4.default.readFileSync(htmlPath, "utf-8");
 }
-var import_node_path5, import_node_fs4, REACT_REFRESH_HTML_PREAMBLE;
+var import_node_path6, import_node_fs4, REACT_REFRESH_HTML_PREAMBLE;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
-    import_node_path5 = __toESM(require("path"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
     import_node_fs4 = __toESM(require("fs"), 1);
     REACT_REFRESH_HTML_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
@@ -634,7 +693,7 @@ function loadEnv(mode, root, prefixes) {
   ];
   const raw = {};
   for (const file of envFiles) {
-    const filePath = import_node_path6.default.resolve(root, file);
+    const filePath = import_node_path7.default.resolve(root, file);
     if (!import_node_fs5.default.existsSync(filePath)) continue;
     const content = import_node_fs5.default.readFileSync(filePath, "utf-8");
     for (const line of content.split("\n")) {
@@ -677,11 +736,11 @@ function replaceEnvInCode(code, define) {
   }
   return result;
 }
-var import_node_path6, import_node_fs5;
+var import_node_path7, import_node_fs5;
 var init_env = __esm({
   "src/core/env.ts"() {
     "use strict";
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
     import_node_fs5 = __toESM(require("fs"), 1);
   }
 });
@@ -814,10 +873,10 @@ __export(build_exports, {
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(import_picocolors.default.cyan("\n\u{1F528} nasti build") + import_picocolors.default.dim(` v${"1.6.3"}`));
+  console.log(import_picocolors.default.cyan("\n\u{1F528} nasti build") + import_picocolors.default.dim(` v${"1.6.4"}`));
   console.log(import_picocolors.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors.default.dim(`  mode: ${config.mode}`));
-  const outDir = import_node_path7.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path8.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs6.default.existsSync(outDir)) {
     import_node_fs6.default.rmSync(outDir, { recursive: true, force: true });
   }
@@ -829,14 +888,14 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(import_node_path7.default.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(import_node_path8.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_path7.default.resolve(config.root, entry);
+      const fullPath = import_node_path8.default.resolve(config.root, entry);
       if (import_node_fs6.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
@@ -901,8 +960,8 @@ async function build(inlineConfig = {}) {
   await bundle.close();
   await pluginContainer.buildEnd();
   for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = import_node_path7.default.resolve(outDir, ef.fileName);
-    import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(dest), { recursive: true });
+    const dest = import_node_path8.default.resolve(outDir, ef.fileName);
+    import_node_fs6.default.mkdirSync(import_node_path8.default.dirname(dest), { recursive: true });
     import_node_fs6.default.writeFileSync(dest, ef.source);
   }
   if (html) {
@@ -920,14 +979,14 @@ async function build(inlineConfig = {}) {
     }
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = import_node_path7.default.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = import_node_path8.default.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    import_node_fs6.default.writeFileSync(import_node_path7.default.resolve(outDir, "index.html"), processedHtml);
+    import_node_fs6.default.writeFileSync(import_node_path8.default.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -949,11 +1008,11 @@ function formatSize(bytes) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_path7, import_node_fs6, import_rolldown, import_picocolors;
+var import_node_path8, import_node_fs6, import_rolldown, import_picocolors;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
     import_node_fs6 = __toESM(require("fs"), 1);
     import_rolldown = require("rolldown");
     init_config();
@@ -1150,9 +1209,9 @@ function getReactRefreshRuntimeEsm() {
   let cjsPath;
   try {
     const pkgPath = __require.resolve("react-refresh/package.json");
-    cjsPath = import_node_path9.default.join(import_node_path9.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    cjsPath = import_node_path10.default.join(import_node_path10.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = import_node_path9.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    cjsPath = import_node_path10.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
     if (!import_node_fs8.default.existsSync(cjsPath)) {
       const origMsg = err instanceof Error ? err.message : String(err);
       throw new Error(
@@ -1292,9 +1351,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() };
@@ -1373,7 +1432,7 @@ async function loadVirtualModule(spec, ctx) {
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
   ));
-  const anchor = import_node_path9.default.join(config.root, "__nasti_virtual__.ts");
+  const anchor = import_node_path10.default.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -1416,13 +1475,13 @@ async function doBundlePackage(entryFile) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile) {
-  const NM = `${import_node_path9.default.sep}node_modules${import_node_path9.default.sep}`;
+  const NM = `${import_node_path10.default.sep}node_modules${import_node_path10.default.sep}`;
   if (!entryFile.includes(NM)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = import_node_path9.default.dirname(entryFile);
+  let dir = import_node_path10.default.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = import_node_path9.default.join(dir, "package.json");
+    const pkgJsonPath = import_node_path10.default.join(dir, "package.json");
     if (import_node_fs8.default.existsSync(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgJsonPath, "utf-8"));
@@ -1434,21 +1493,21 @@ async function tryGenerateSubpathShim(entryFile) {
       } catch {
       }
     }
-    const parent = import_node_path9.default.dirname(dir);
+    const parent = import_node_path10.default.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
     if (!dir.includes(NM)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = import_node_path9.default.extname(entryFile);
+  const entryExt = import_node_path10.default.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (import_node_path9.default.resolve(mainEntry) === import_node_path9.default.resolve(entryFile)) return null;
+  if (import_node_path10.default.resolve(mainEntry) === import_node_path10.default.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
-    mainNs = await import((0, import_node_url2.pathToFileURL)(mainEntry).href);
-    subNs = await import((0, import_node_url2.pathToFileURL)(entryFile).href);
+    mainNs = await import((0, import_node_url3.pathToFileURL)(mainEntry).href);
+    subNs = await import((0, import_node_url3.pathToFileURL)(entryFile).href);
   } catch {
     return null;
   }
@@ -1479,7 +1538,7 @@ async function tryGenerateSubpathShim(entryFile) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = import_node_path9.default.join(pkgDir, "package.json");
+  const pkgJsonPath = import_node_path10.default.join(pkgDir, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgJsonPath, "utf-8"));
@@ -1501,13 +1560,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 (import_node_path9.default.extname(cand) === preferredExt) {
-      const full = import_node_path9.default.resolve(pkgDir, cand);
+    if (import_node_path10.default.extname(cand) === preferredExt) {
+      const full = import_node_path10.default.resolve(pkgDir, cand);
       if (import_node_fs8.default.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = import_node_path9.default.resolve(pkgDir, cand);
+    const full = import_node_path10.default.resolve(pkgDir, cand);
     if (import_node_fs8.default.existsSync(full)) return full;
   }
   return null;
@@ -1533,19 +1592,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")
     );
@@ -1555,11 +1615,11 @@ async function injectCjsNamedExports(code, entryFile) {
 }
 function rewriteImports(code, config, filePath) {
   const root = config.root;
-  const fileDir = import_node_path9.default.dirname(filePath);
+  const fileDir = import_node_path10.default.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + import_node_path9.default.relative(root, abs).replace(/\\/g, "/");
+  const toRootUrl = (abs) => "/" + import_node_path10.default.relative(root, abs).replace(/\\/g, "/");
   const transformSpec = (spec) => {
     const suffixMatch = spec.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
@@ -1568,18 +1628,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 ? import_node_path9.default.join(aliasBase, sub) : aliasBase;
+        const target = sub ? import_node_path10.default.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
         return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const target = import_node_path9.default.resolve(fileDir, baseSpec);
+      const target = import_node_path10.default.resolve(fileDir, baseSpec);
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const target = import_node_path9.default.join(root, baseSpec.replace(/^\//, ""));
+      const target = import_node_path10.default.join(root, baseSpec.replace(/^\//, ""));
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
@@ -1598,9 +1658,9 @@ function rewriteImports(code, config, filePath) {
   );
 }
 function resolveAliasTarget(value, root) {
-  if (import_node_path9.default.isAbsolute(value) && import_node_fs8.default.existsSync(value)) return value;
-  if (value.startsWith("/")) return import_node_path9.default.join(root, value.slice(1));
-  return import_node_path9.default.resolve(root, value);
+  if (import_node_path10.default.isAbsolute(value) && import_node_fs8.default.existsSync(value)) return value;
+  if (value.startsWith("/")) return import_node_path10.default.join(root, value.slice(1));
+  return import_node_path10.default.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
   if (import_node_fs8.default.existsSync(target) && import_node_fs8.default.statSync(target).isFile()) return target;
@@ -1610,15 +1670,15 @@ function tryResolveDiskPath(target) {
   }
   if (import_node_fs8.default.existsSync(target) && import_node_fs8.default.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = import_node_path9.default.join(target, "index" + ext);
+      const idx = import_node_path10.default.join(target, "index" + ext);
       if (import_node_fs8.default.existsSync(idx) && import_node_fs8.default.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
 function isUnderRoot(abs, root) {
-  const rel = import_node_path9.default.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !import_node_path9.default.isAbsolute(rel);
+  const rel = import_node_path10.default.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !import_node_path10.default.isAbsolute(rel);
 }
 function resolveNodeModule(root, moduleName) {
   let pkgName;
@@ -1635,17 +1695,17 @@ function resolveNodeModule(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = import_node_path9.default.join(dir, "node_modules", pkgName);
+    const candidate = import_node_path10.default.join(dir, "node_modules", pkgName);
     if (import_node_fs8.default.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = import_node_path9.default.dirname(dir);
+    const parent = import_node_path10.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = import_node_path9.default.join(pkgDir, "package.json");
+  const pkgJsonPath = import_node_path10.default.join(pkgDir, "package.json");
   if (!import_node_fs8.default.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
@@ -1662,12 +1722,12 @@ function resolveNodeModule(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = import_node_path9.default.dirname(pkg[field]);
+        const dir2 = import_node_path10.default.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = import_node_path9.default.join(pkgDir, dir2, subpath);
+      const direct = import_node_path10.default.join(pkgDir, dir2, subpath);
       if (import_node_fs8.default.existsSync(direct) && import_node_fs8.default.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
         if (import_node_fs8.default.existsSync(direct + ext)) return direct + ext;
@@ -1677,24 +1737,24 @@ function resolveNodeModule(root, moduleName) {
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = import_node_path9.default.join(pkgDir, pkg[field]);
+      const entry = import_node_path10.default.join(pkgDir, pkg[field]);
       if (import_node_fs8.default.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = import_node_path9.default.join(pkgDir, "index.js");
+  const indexFallback = import_node_path10.default.join(pkgDir, "index.js");
   if (import_node_fs8.default.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports2, key, pkgDir) {
   if (typeof exports2 === "string") {
-    return key === "." ? import_node_path9.default.join(pkgDir, exports2) : null;
+    return key === "." ? import_node_path10.default.join(pkgDir, exports2) : null;
   }
   const entry = exports2[key];
   if (entry === void 0) return null;
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return import_node_path9.default.join(pkgDir, value);
+  if (typeof value === "string") return import_node_path10.default.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -1718,7 +1778,7 @@ function resolveUrlToFile(url, root) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = import_node_path9.default.resolve(root, cleanUrl.replace(/^\//, ""));
+  const filePath = import_node_path10.default.resolve(root, cleanUrl.replace(/^\//, ""));
   if (import_node_fs8.default.existsSync(filePath) && import_node_fs8.default.statSync(filePath).isFile()) {
     return filePath;
   }
@@ -1727,7 +1787,7 @@ function resolveUrlToFile(url, root) {
     if (import_node_fs8.default.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = import_node_path9.default.join(filePath, "index" + ext);
+    const indexFile = import_node_path10.default.join(filePath, "index" + ext);
     if (import_node_fs8.default.existsSync(indexFile)) return indexFile;
   }
   return null;
@@ -1736,7 +1796,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 (!import_node_path9.default.extname(cleanUrl)) return true;
+  if (!import_node_path10.default.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
@@ -1867,20 +1927,20 @@ export function createHotContext(ownerPath) {
 }
 `;
 }
-var import_node_path9, import_node_fs8, import_node_module3, import_node_url2, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var import_node_path10, import_node_fs8, import_node_module4, import_node_url3, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     import_node_fs8 = __toESM(require("fs"), 1);
-    import_node_module3 = require("module");
-    import_node_url2 = require("url");
+    import_node_module4 = require("module");
+    import_node_url3 = require("url");
     init_transformer();
     init_html();
     init_env();
     import_meta = {};
-    __dirname_esm = import_node_path9.default.dirname((0, import_node_url2.fileURLToPath)(import_meta.url));
-    __require = (0, import_node_module3.createRequire)(import_meta.url);
+    __dirname_esm = import_node_path10.default.dirname((0, import_node_url3.fileURLToPath)(import_meta.url));
+    __require = (0, import_node_module4.createRequire)(import_meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_GLOBAL_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
@@ -1899,7 +1959,7 @@ window.__vite_plugin_react_preamble_installed__ = true;
 // src/server/hmr.ts
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
-  const relativePath = "/" + import_node_path10.default.relative(config.root, file);
+  const relativePath = "/" + import_node_path11.default.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
@@ -1944,11 +2004,11 @@ async function handleFileChange(file, server) {
     ws.send({ type: "update", updates });
   }
 }
-var import_node_path10, import_node_fs9;
+var import_node_path11, import_node_fs9;
 var init_hmr = __esm({
   "src/server/hmr.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("path"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
     import_node_fs9 = __toESM(require("fs"), 1);
   }
 });
@@ -1976,20 +2036,20 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = import_node_path11.default.resolve(config.root, "public");
+  const publicDir = import_node_path12.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_path11.default.resolve(config.root, config.build.outDir);
+  const outDirAbs = import_node_path12.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_path11.default.sep)) return true;
-      const rel = import_node_path11.default.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || import_node_path11.default.isAbsolute(rel)) return false;
-      for (const seg of rel.split(import_node_path11.default.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path12.default.sep)) return true;
+      const rel = import_node_path12.default.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || import_node_path12.default.isAbsolute(rel)) return false;
+      for (const seg of rel.split(import_node_path12.default.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -2021,7 +2081,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_picocolors3.default.cyan("  nasti dev server") + import_picocolors3.default.dim(` v${"1.6.3"}`));
+          console.log(import_picocolors3.default.cyan("  nasti dev server") + import_picocolors3.default.dim(` v${"1.6.4"}`));
           console.log();
           console.log(`  ${import_picocolors3.default.green(">")} Local:   ${import_picocolors3.default.cyan(localUrl)}`);
           if (networkUrl) {
@@ -2077,12 +2137,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path11, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors3;
+var import_node_http, import_node_path12, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors3;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path11 = __toESM(require("path"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -2118,7 +2178,7 @@ init_config();
 init_build();
 
 // src/build/electron.ts
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_fs7 = __toESM(require("fs"), 1);
 var import_rolldown2 = require("rolldown");
 var import_picocolors2 = __toESM(require("picocolors"), 1);
@@ -2126,10 +2186,10 @@ init_config();
 init_resolve();
 
 // src/plugins/electron.ts
-var import_node_module2 = require("module");
+var import_node_module3 = require("module");
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
-  ...import_node_module2.builtinModules,
-  ...import_node_module2.builtinModules.map((m) => `node:${m}`)
+  ...import_node_module3.builtinModules,
+  ...import_node_module3.builtinModules.map((m) => `node:${m}`)
 ]);
 var ELECTRON_MODULES = /* @__PURE__ */ new Set([
   "electron",
@@ -2165,16 +2225,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors2.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors2.default.dim(` v${"1.6.3"}`));
+  console.log(import_picocolors2.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors2.default.dim(` v${"1.6.4"}`));
   console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors2.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path8.default.resolve(config.root, config.build.outDir);
+  const outDir = import_node_path9.default.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && import_node_fs7.default.existsSync(outDir)) {
     import_node_fs7.default.rmSync(outDir, { recursive: true, force: true });
   }
   import_node_fs7.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path8.default.join(outDir, "renderer");
+  const rendererOutDir = import_node_path9.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2185,7 +2245,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = import_node_path8.default.resolve(config.root, config.electron.main);
+  const mainEntry = import_node_path9.default.resolve(config.root, config.electron.main);
   if (!import_node_fs7.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2204,7 +2264,7 @@ async function buildElectron(inlineConfig = {}) {
       console.warn(import_picocolors2.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path8.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path9.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2216,10 +2276,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors2.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors2.default.dim(`  renderer: ${import_node_path8.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors2.default.dim(`  main:     ${import_node_path8.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors2.default.dim(`  renderer: ${import_node_path9.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors2.default.dim(`  main:     ${import_node_path9.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors2.default.dim(`  preload:  ${import_node_path8.default.relative(config.root, pf)}`));
+    console.log(import_picocolors2.default.dim(`  preload:  ${import_node_path9.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2250,7 +2310,7 @@ async function bundleNode(config, entry, opts) {
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
     ...config.build.rolldownOptions
   });
-  import_node_fs7.default.mkdirSync(import_node_path8.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path9.default.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2259,16 +2319,16 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle.close();
-  console.log(import_picocolors2.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path8.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors2.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path9.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path8.default.join(outDir, base + ext);
+  return import_node_path9.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path8.default.resolve(root, p));
+  return list.map((p) => import_node_path9.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -2283,7 +2343,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = import_node_path8.default.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = import_node_path9.default.resolve(root, "node_modules/electron/package.json");
     if (!import_node_fs7.default.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(import_node_fs7.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2297,9 +2357,9 @@ function detectInstalledElectron(root) {
 init_server();
 
 // src/server/electron-dev.ts
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_module4 = require("module");
+var import_node_module5 = require("module");
 var import_node_child_process = require("child_process");
 var import_chokidar2 = __toESM(require("chokidar"), 1);
 var import_picocolors4 = __toESM(require("picocolors"), 1);
@@ -2312,17 +2372,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.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(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, {
@@ -2333,8 +2393,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,
@@ -2449,7 +2509,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",
@@ -2466,7 +2526,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)) {
@@ -2496,10 +2556,10 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 var import_node_fs11 = __toESM(require("fs"), 1);
 var import_node_crypto2 = __toESM(require("crypto"), 1);
-var import_node_module5 = require("module");
+var import_node_module6 = require("module");
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -2518,7 +2578,7 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = (0, import_node_module5.createRequire)(import_node_path13.default.resolve(root, "package.json"));
+    const require2 = (0, import_node_module6.createRequire)(import_node_path14.default.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
     const pkg = JSON.parse(import_node_fs11.default.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
@@ -2540,13 +2600,13 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = import_node_path13.default.join(cacheDir, `${worker.label}.worker.js`);
+    const cacheFile = import_node_path14.default.join(cacheDir, `${worker.label}.worker.js`);
     if (import_node_fs11.default.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 = (0, import_node_module5.createRequire)(import_node_path13.default.resolve(resolvedConfig.root, "package.json"));
+      const require2 = (0, import_node_module6.createRequire)(import_node_path14.default.resolve(resolvedConfig.root, "package.json"));
       let entry;
       try {
         entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });
@@ -2613,12 +2673,12 @@ function monacoEditorPlugin(options = {}) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
       const key = import_node_crypto2.default.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = import_node_path13.default.resolve(config.root, "node_modules/.nasti/monaco", key);
+      cacheDir = import_node_path14.default.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoDir = import_node_path13.default.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoDir = import_node_path14.default.resolve(resolvedConfig.root, "node_modules/monaco-editor");
       try {
         watcher?.unwatch?.(monacoDir);
       } catch {
@@ -2683,7 +2743,7 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? import_node_path13.default.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : import_node_path13.default.resolve(
+      ) : isCDN(publicPath) ? import_node_path14.default.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : import_node_path14.default.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
@@ -2692,7 +2752,7 @@ self.monaco = monaco;`,
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          import_node_fs11.default.copyFileSync(cacheFile, import_node_path13.default.join(outDir, `${worker.label}.worker.js`));
+          import_node_fs11.default.copyFileSync(cacheFile, import_node_path14.default.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}