@nasti-toolchain/nasti 1.3.10 → 1.4.0

package/dist/cli.js

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/config/defaults.ts
-var defaultResolve, defaultServer, defaultBuild, defaults;
+var defaultResolve, defaultServer, defaultBuild, defaultElectron, defaults;
 var init_defaults = __esm({
   "src/config/defaults.ts"() {
     "use strict";
@@ -37,14 +37,29 @@ var init_defaults = __esm({
       rolldownOptions: {},
       emptyOutDir: true
     };
+    defaultElectron = {
+      main: "src/electron/main.ts",
+      preload: "src/electron/preload.ts",
+      renderer: "index.html",
+      nodeTarget: "node22",
+      mainFormat: "cjs",
+      preloadFormat: "cjs",
+      electronPath: "",
+      electronArgs: [],
+      autoRestart: true,
+      minVersion: 41,
+      external: ["electron"]
+    };
     defaults = {
       root: ".",
       base: "/",
       mode: "development",
+      target: "web",
       framework: "auto",
       resolve: defaultResolve,
       server: defaultServer,
       build: defaultBuild,
+      electron: defaultElectron,
       plugins: [],
       envPrefix: ["NASTI_", "VITE_"],
       logLevel: "info"
@@ -123,6 +138,7 @@ async function resolveConfig(inlineConfig = {}, command) {
     root,
     base: merged.base ?? defaults.base,
     mode: command === "build" ? "production" : "development",
+    target: merged.target ?? defaults.target,
     framework: merged.framework ?? defaults.framework,
     command,
     resolve: {
@@ -135,6 +151,7 @@ async function resolveConfig(inlineConfig = {}, command) {
     plugins: [],
     server: { ...defaults.server, ...merged.server },
     build: { ...defaults.build, ...merged.build },
+    electron: { ...defaults.electron, ...merged.electron },
     envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
     logLevel: merged.logLevel ?? defaults.logLevel
   };
@@ -749,8 +766,8 @@ async function bundlePackageAsEsm(entryFile) {
   return esmBundleCache.get(entryFile);
 }
 async function doBundlePackage(entryFile) {
-  const { rolldown: rolldown2 } = await import("rolldown");
-  const bundle = await rolldown2({
+  const { rolldown: rolldown4 } = await import("rolldown");
+  const bundle = await rolldown4({
     input: entryFile,
     // 仅将其他 npm 包外部化；相对路径（包内部文件）全部内联打包
     external: (id) => {
@@ -799,8 +816,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire2 } = await import("module");
-    const req = createRequire2(entryFile);
+    const { createRequire: createRequire3 } = await import("module");
+    const req = createRequire3(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1423,10 +1440,11 @@ async function createServer(inlineConfig = {}) {
         let currentPort = finalPort;
         const onListening = () => {
           const actualPort = httpServer.address()?.port ?? currentPort;
+          config.server.port = actualPort;
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(pc.cyan("  nasti dev server") + pc.dim(` v${"1.3.10"}`));
+          console.log(pc.cyan("  nasti dev server") + pc.dim(` v${"1.4.0"}`));
           console.log();
           console.log(`  ${pc.green(">")} Local:   ${pc.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1488,6 +1506,45 @@ var init_server = __esm({
   }
 });
 
+// src/plugins/electron.ts
+import { builtinModules } from "module";
+function electronPlugin(config) {
+  const external = /* @__PURE__ */ new Set([
+    ...ELECTRON_MODULES,
+    ...NODE_BUILTINS,
+    ...config.electron.external ?? []
+  ]);
+  return {
+    name: "nasti:electron",
+    enforce: "pre",
+    resolveId(source) {
+      if (external.has(source)) {
+        return { id: source, external: true };
+      }
+      if (source.startsWith("electron/")) {
+        return { id: source, external: true };
+      }
+      return null;
+    }
+  };
+}
+var NODE_BUILTINS, ELECTRON_MODULES;
+var init_electron = __esm({
+  "src/plugins/electron.ts"() {
+    "use strict";
+    NODE_BUILTINS = /* @__PURE__ */ new Set([
+      ...builtinModules,
+      ...builtinModules.map((m) => `node:${m}`)
+    ]);
+    ELECTRON_MODULES = /* @__PURE__ */ new Set([
+      "electron",
+      "electron/main",
+      "electron/common",
+      "electron/renderer"
+    ]);
+  }
+});
+
 // src/build/index.ts
 var build_exports = {};
 __export(build_exports, {
@@ -1500,7 +1557,7 @@ import pc2 from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc2.cyan("\n\u{1F528} nasti build") + pc2.dim(` v${"1.3.10"}`));
+  console.log(pc2.cyan("\n\u{1F528} nasti build") + pc2.dim(` v${"1.4.0"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
   const outDir = path10.resolve(config.root, config.build.outDir);
@@ -1645,9 +1702,353 @@ var init_build = __esm({
   }
 });
 
+// src/build/electron.ts
+var electron_exports = {};
+__export(electron_exports, {
+  buildElectron: () => buildElectron,
+  detectInstalledElectron: () => detectInstalledElectron,
+  normalizePreload: () => normalizePreload
+});
+import path11 from "path";
+import fs9 from "fs";
+import { rolldown as rolldown2 } from "rolldown";
+import pc3 from "picocolors";
+async function buildElectron(inlineConfig = {}) {
+  const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
+  const startTime = performance.now();
+  assertElectronVersion(config);
+  console.log(pc3.cyan("\n\u26A1 nasti build (electron)") + pc3.dim(` v${"1.4.0"}`));
+  console.log(pc3.dim(`  root: ${config.root}`));
+  console.log(pc3.dim(`  mode: ${config.mode}`));
+  console.log(pc3.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
+  const outDir = path11.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
+    fs9.rmSync(outDir, { recursive: true, force: true });
+  }
+  fs9.mkdirSync(outDir, { recursive: true });
+  const rendererOutDir = path11.join(outDir, "renderer");
+  const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  await build2({
+    ...inlineConfig,
+    target: "web",
+    build: {
+      ...inlineConfig.build,
+      outDir: rendererOutDir,
+      emptyOutDir: false
+    }
+  });
+  const mainEntry = path11.resolve(config.root, config.electron.main);
+  if (!fs9.existsSync(mainEntry)) {
+    throw new Error(
+      `Electron main entry not found: ${config.electron.main}
+\u5728 nasti.config.ts \u7684 electron.main \u6307\u5B9A\u4E3B\u8FDB\u7A0B\u5165\u53E3\u6587\u4EF6\u3002`
+    );
+  }
+  const mainFile = await bundleNode(config, mainEntry, {
+    outFile: outFileName(outDir, "main", config.electron.mainFormat),
+    format: config.electron.mainFormat,
+    label: "main"
+  });
+  const preloadEntries = normalizePreload(config.electron.preload, config.root);
+  const preloadFiles = [];
+  for (const entry of preloadEntries) {
+    if (!fs9.existsSync(entry)) {
+      console.warn(pc3.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
+      continue;
+    }
+    const base = path11.basename(entry).replace(/\.[^.]+$/, "");
+    const out = outFileName(outDir, base, config.electron.preloadFormat);
+    await bundleNode(config, entry, {
+      outFile: out,
+      format: config.electron.preloadFormat,
+      label: `preload (${base})`
+    });
+    preloadFiles.push(out);
+  }
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
+  console.log(pc3.green(`
+\u2713 Electron build complete in ${elapsed}s`));
+  console.log(pc3.dim(`  renderer: ${path11.relative(config.root, rendererOutDir)}/`));
+  console.log(pc3.dim(`  main:     ${path11.relative(config.root, mainFile)}`));
+  for (const pf of preloadFiles) {
+    console.log(pc3.dim(`  preload:  ${path11.relative(config.root, pf)}`));
+  }
+  console.log();
+  return { rendererOutDir, mainFile, preloadFiles };
+}
+async function bundleNode(config, entry, opts) {
+  const env = loadEnv(config.mode, config.root, config.envPrefix);
+  const envDefine = {
+    ...buildEnvDefine(env, config.mode),
+    __ELECTRON__: "true",
+    __NASTI_TARGET__: JSON.stringify("electron")
+  };
+  const oxcTransformPlugin = {
+    name: "nasti:oxc-transform",
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      const result = transformCode(id, code, {
+        sourcemap: !!config.build.sourcemap,
+        jsxRuntime: "automatic",
+        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+      });
+      return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
+    }
+  };
+  const bundle = await rolldown2({
+    input: entry,
+    define: envDefine,
+    platform: "node",
+    plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
+    ...config.build.rolldownOptions
+  });
+  fs9.mkdirSync(path11.dirname(opts.outFile), { recursive: true });
+  await bundle.write({
+    file: opts.outFile,
+    format: opts.format === "cjs" ? "cjs" : "esm",
+    sourcemap: !!config.build.sourcemap,
+    minify: !!config.build.minify,
+    inlineDynamicImports: true
+  });
+  await bundle.close();
+  console.log(pc3.dim(`  \u2713 ${opts.label} \u2192 ${path11.relative(config.root, opts.outFile)}`));
+  return opts.outFile;
+}
+function outFileName(outDir, base, format) {
+  const ext = format === "cjs" ? ".cjs" : ".mjs";
+  return path11.join(outDir, base + ext);
+}
+function normalizePreload(preload, root) {
+  const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
+  return list.map((p) => path11.resolve(root, p));
+}
+function assertElectronVersion(config) {
+  const min = config.electron.minVersion;
+  const installed = detectInstalledElectron(config.root);
+  if (installed && installed < min) {
+    console.warn(
+      pc3.yellow(
+        `  \u26A0 \u68C0\u6D4B\u5230 Electron ${installed}\uFF0CNasti \u8981\u6C42 \u2265 ${min}\u3002\u65E7\u7248\u672C\u53EF\u80FD\u7F3A\u5C11 ESM \u4E3B\u8FDB\u7A0B\u652F\u6301\u3002`
+      )
+    );
+  }
+}
+function detectInstalledElectron(root) {
+  try {
+    const pkgPath = path11.resolve(root, "node_modules/electron/package.json");
+    if (!fs9.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+    const major = parseInt(String(pkg.version).split(".")[0], 10);
+    return Number.isFinite(major) ? major : null;
+  } catch {
+    return null;
+  }
+}
+var init_electron2 = __esm({
+  "src/build/electron.ts"() {
+    "use strict";
+    init_config();
+    init_resolve();
+    init_electron();
+    init_transformer();
+    init_env();
+  }
+});
+
+// src/server/electron-dev.ts
+var electron_dev_exports = {};
+__export(electron_dev_exports, {
+  startElectronDev: () => startElectronDev
+});
+import path12 from "path";
+import fs10 from "fs";
+import { createRequire as createRequire2 } from "module";
+import { spawn } from "child_process";
+import chokidar from "chokidar";
+import pc4 from "picocolors";
+import { rolldown as rolldown3 } from "rolldown";
+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.4.0"}`));
+  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");
+  fs10.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = path12.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 builtPreloadFiles = [];
+  const compileAll = async () => {
+    await compileNode(config, mainEntry, {
+      outFile: builtMainFile,
+      format: config.electron.mainFormat,
+      devUrl
+    });
+    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));
+      await compileNode(config, entry, {
+        outFile: out,
+        format: config.electron.preloadFormat,
+        devUrl
+      });
+      builtPreloadFiles.push(out);
+    }
+  };
+  await compileAll();
+  if (noSpawn) {
+    console.log(pc4.dim("  (noSpawn) \u5DF2\u7F16\u8BD1\u4E3B/preload\uFF0C\u8DF3\u8FC7\u542F\u52A8 Electron\u3002"));
+    return;
+  }
+  const electronBin = resolveElectronBinary(config);
+  if (!electronBin) {
+    console.warn(
+      pc4.yellow(
+        "  \u26A0 \u672A\u627E\u5230 Electron \u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u8BF7\u5148\u5B89\u88C5\uFF1Anpm install -D electron\n    \u5DF2\u7F16\u8BD1\u4E3B/preload \u81F3 .nasti/\uFF0C\u53EF\u624B\u52A8\u8FD0\u884C\u3002"
+      )
+    );
+    return;
+  }
+  let child = null;
+  const spawnElectron = () => {
+    const args = [builtMainFile, ...config.electron.electronArgs];
+    child = spawn(electronBin, args, {
+      stdio: "inherit",
+      env: { ...process.env, NASTI_DEV_SERVER_URL: devUrl, NASTI_TARGET: "electron" }
+    });
+    child.on("exit", (code) => {
+      if (code !== null && child && child.__nastiKilled !== true) {
+        console.log(pc4.dim(`  Electron exited (${code}).`));
+        process.exit(code ?? 0);
+      }
+    });
+  };
+  spawnElectron();
+  if (config.electron.autoRestart) {
+    const watchTargets = [mainEntry, ...preloadEntries].filter(fs10.existsSync);
+    const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
+    let restarting = null;
+    watcher.on("all", async () => {
+      if (restarting) return;
+      restarting = (async () => {
+        console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
+        try {
+          if (child && !child.killed) {
+            ;
+            child.__nastiKilled = true;
+            const dying = child;
+            await new Promise((resolve) => {
+              const timer = setTimeout(() => resolve(), 3e3);
+              dying.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+              });
+              dying.kill();
+            });
+          }
+          await compileAll();
+          spawnElectron();
+        } finally {
+          restarting = null;
+        }
+      })();
+    });
+  }
+}
+function extFor(format) {
+  return format === "cjs" ? ".cjs" : ".mjs";
+}
+async function compileNode(config, entry, opts) {
+  const env = loadEnv(config.mode, config.root, config.envPrefix);
+  const envDefine = {
+    ...buildEnvDefine(env, config.mode),
+    __ELECTRON__: "true",
+    __NASTI_TARGET__: JSON.stringify("electron"),
+    __NASTI_DEV_SERVER_URL__: JSON.stringify(opts.devUrl)
+  };
+  const oxcTransformPlugin = {
+    name: "nasti:oxc-transform",
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      const result = transformCode(id, code, {
+        sourcemap: !!config.build.sourcemap,
+        jsxRuntime: "automatic",
+        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+      });
+      return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
+    }
+  };
+  const bundle = await rolldown3({
+    input: entry,
+    transform: { define: envDefine },
+    platform: "node",
+    plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
+  });
+  fs10.mkdirSync(path12.dirname(opts.outFile), { recursive: true });
+  await bundle.write({
+    file: opts.outFile,
+    format: opts.format === "cjs" ? "cjs" : "esm",
+    sourcemap: false,
+    minify: false,
+    inlineDynamicImports: true
+  });
+  await bundle.close();
+}
+function resolveElectronBinary(config) {
+  if (config.electron.electronPath && fs10.existsSync(config.electron.electronPath)) {
+    return config.electron.electronPath;
+  }
+  try {
+    const require2 = createRequire2(path12.resolve(config.root, "package.json"));
+    const pathFile = require2.resolve("electron");
+    const electronModule = require2(pathFile);
+    if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
+      return electronModule;
+    }
+  } catch {
+  }
+  return null;
+}
+function warnElectronVersion(config) {
+  const installed = detectInstalledElectron(config.root);
+  if (installed === null) {
+    console.warn(
+      pc4.yellow(
+        `  \u26A0 \u672A\u68C0\u6D4B\u5230 Electron\uFF0C\u8BF7\u5B89\u88C5\uFF1Anpm install -D electron@^${config.electron.minVersion}`
+      )
+    );
+    return;
+  }
+  if (installed < config.electron.minVersion) {
+    console.warn(
+      pc4.yellow(
+        `  \u26A0 Electron ${installed} \u4F4E\u4E8E Nasti \u8981\u6C42\u7684 ${config.electron.minVersion}\uFF0C\u67D0\u4E9B\u7279\u6027\uFF08\u5982 ESM \u4E3B\u8FDB\u7A0B\uFF09\u4E0D\u53EF\u7528\u3002`
+      )
+    );
+  }
+}
+var init_electron_dev = __esm({
+  "src/server/electron-dev.ts"() {
+    "use strict";
+    init_config();
+    init_electron();
+    init_resolve();
+    init_transformer();
+    init_env();
+    init_electron2();
+  }
+});
+
 // src/cli.ts
 import { cac } from "cac";
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 var cli = cac("nasti");
 cli.command("[root]", "Start dev server").alias("dev").option("--port <port>", "Port number", { default: 3e3 }).option("--host [host]", "Hostname").option("--open [path]", "Open browser on startup").option("--mode <mode>", "Set env mode").action(async (root, options) => {
   try {
@@ -1663,56 +2064,114 @@ cli.command("[root]", "Start dev server").alias("dev").option("--port <port>", "
     });
     await server.listen();
   } catch (err) {
-    console.error(pc3.red(`
+    console.error(pc5.red(`
   Error starting dev server:
   ${err.message}
 `));
-    if (err.stack) console.error(pc3.dim(err.stack));
+    if (err.stack) console.error(pc5.dim(err.stack));
     process.exit(1);
   }
 });
-cli.command("build [root]", "Build for production").option("--outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap", "Generate source map").option("--minify", "Minify output", { default: true }).option("--mode <mode>", "Set env mode").action(async (root, options) => {
+cli.command("build [root]", "Build for production").option("--outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap", "Generate source map").option("--minify", "Minify output", { default: true }).option("--mode <mode>", "Set env mode").option("--target <target>", "Build target: web | electron", { default: "web" }).action(async (root, options) => {
   try {
-    const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-    await build2({
+    const target = options.target;
+    if (target !== "web" && target !== "electron") {
+      throw new Error(`Invalid --target "${target}". Expected "web" or "electron".`);
+    }
+    const inline = {
       root: root ?? ".",
       mode: options.mode ?? "production",
+      target,
       build: {
         outDir: options.outDir,
         sourcemap: options.sourcemap,
         minify: options.minify
       }
-    });
+    };
+    if (target === "electron") {
+      const { buildElectron: buildElectron2 } = await Promise.resolve().then(() => (init_electron2(), electron_exports));
+      await buildElectron2(inline);
+    } else {
+      const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+      await build2(inline);
+    }
   } catch (err) {
-    console.error(pc3.red(`
+    console.error(pc5.red(`
   Build failed:
   ${err.message}
 `));
-    if (err.stack) console.error(pc3.dim(err.stack));
+    if (err.stack) console.error(pc5.dim(err.stack));
+    process.exit(1);
+  }
+});
+cli.command("electron [root]", "Start Electron dev mode (requires electron ^41)").alias("electron-dev").option("--port <port>", "Renderer dev server port", { default: 3e3 }).option("--host [host]", "Hostname").option("--mode <mode>", "Set env mode").option("--no-spawn", "Compile main/preload but do not spawn Electron").option("--no-restart", "Disable auto-restart on main/preload changes").action(async (root, options) => {
+  try {
+    const { startElectronDev: startElectronDev2 } = await Promise.resolve().then(() => (init_electron_dev(), electron_dev_exports));
+    await startElectronDev2({
+      root: root ?? ".",
+      mode: options.mode ?? "development",
+      target: "electron",
+      server: {
+        port: options.port,
+        host: options.host
+      },
+      electron: {
+        autoRestart: options.restart !== false
+      },
+      noSpawn: options.spawn === false
+    });
+  } catch (err) {
+    console.error(pc5.red(`
+  Electron dev failed:
+  ${err.message}
+`));
+    if (err.stack) console.error(pc5.dim(err.stack));
+    process.exit(1);
+  }
+});
+cli.command("electron-build [root]", "Build Electron app for production").option("--outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap", "Generate source map").option("--minify", "Minify output", { default: true }).option("--mode <mode>", "Set env mode").action(async (root, options) => {
+  try {
+    const { buildElectron: buildElectron2 } = await Promise.resolve().then(() => (init_electron2(), electron_exports));
+    await buildElectron2({
+      root: root ?? ".",
+      mode: options.mode ?? "production",
+      target: "electron",
+      build: {
+        outDir: options.outDir,
+        sourcemap: options.sourcemap,
+        minify: options.minify
+      }
+    });
+  } catch (err) {
+    console.error(pc5.red(`
+  Electron build failed:
+  ${err.message}
+`));
+    if (err.stack) console.error(pc5.dim(err.stack));
     process.exit(1);
   }
 });
 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 path11 = await import("path");
+    const path13 = await import("path");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path11.resolve(root ?? ".");
-    const outDir = path11.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path13.resolve(root ?? ".");
+    const outDir = path13.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
     const host = options.host === true ? "0.0.0.0" : options.host ?? "localhost";
     http2.createServer(app).listen(port, host, () => {
       console.log();
-      console.log(pc3.cyan("  \u{1F50D} nasti preview"));
+      console.log(pc5.cyan("  \u{1F50D} nasti preview"));
       console.log();
-      console.log(`  ${pc3.green("\u279C")} Local: ${pc3.cyan(`http://localhost:${port}`)}`);
+      console.log(`  ${pc5.green("\u279C")} Local: ${pc5.cyan(`http://localhost:${port}`)}`);
       console.log();
     });
   } catch (err) {
-    console.error(pc3.red(`
+    console.error(pc5.red(`
   Preview failed:
   ${err.message}
 `));
@@ -1720,6 +2179,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("1.3.10");
+cli.version("1.4.0");
 cli.parse();
 //# sourceMappingURL=cli.js.map