@nasti-toolchain/nasti 1.1.0

package/dist/cli.cjs

@@ -0,0 +1,1369 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/config/defaults.ts
+var defaultResolve, defaultServer, defaultBuild, defaults;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
+    "use strict";
+    defaultResolve = {
+      alias: {},
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".vue"],
+      conditions: ["import", "module", "browser", "default"],
+      mainFields: ["module", "jsnext:main", "jsnext", "main"]
+    };
+    defaultServer = {
+      port: 3e3,
+      host: "localhost",
+      https: false,
+      open: false,
+      proxy: {},
+      cors: true,
+      hmr: true
+    };
+    defaultBuild = {
+      outDir: "dist",
+      assetsDir: "assets",
+      minify: true,
+      sourcemap: false,
+      target: "es2022",
+      rolldownOptions: {},
+      emptyOutDir: true
+    };
+    defaults = {
+      root: ".",
+      base: "/",
+      mode: "development",
+      framework: "auto",
+      resolve: defaultResolve,
+      server: defaultServer,
+      build: defaultBuild,
+      plugins: [],
+      envPrefix: ["NASTI_", "VITE_"],
+      logLevel: "info"
+    };
+  }
+});
+
+// src/config/index.ts
+async function loadConfigFromFile(root) {
+  for (const file of CONFIG_FILES) {
+    const filePath = import_node_path.default.resolve(root, file);
+    if (!import_node_fs.default.existsSync(filePath)) continue;
+    if (file.endsWith(".ts") || file.endsWith(".mts")) {
+      return await loadTsConfig(filePath);
+    }
+    const mod = await import((0, import_node_url.pathToFileURL)(filePath).href);
+    return mod.default ?? mod;
+  }
+  return {};
+}
+async function loadTsConfig(filePath) {
+  const { transformSync: transformSync2 } = await import("oxc-transform");
+  const code = import_node_fs.default.readFileSync(filePath, "utf-8");
+  const result = transformSync2(filePath, code, {
+    typescript: {}
+  });
+  const tmpFile = filePath + ".timestamp-" + Date.now() + ".mjs";
+  try {
+    import_node_fs.default.writeFileSync(tmpFile, result.code);
+    const mod = await import((0, import_node_url.pathToFileURL)(tmpFile).href);
+    return mod.default ?? mod;
+  } finally {
+    import_node_fs.default.unlinkSync(tmpFile);
+  }
+}
+async function resolveConfig(inlineConfig = {}, command) {
+  const root = import_node_path.default.resolve(inlineConfig.root ?? defaults.root);
+  const fileConfig = await loadConfigFromFile(root);
+  const merged = deepMerge(deepMerge({}, fileConfig), inlineConfig);
+  const rawPlugins = [
+    ...fileConfig.plugins ?? [],
+    ...inlineConfig.plugins ?? []
+  ];
+  const env = { mode: merged.mode ?? defaults.mode, command };
+  for (const plugin of rawPlugins) {
+    if (plugin.config) {
+      const result = await plugin.config(merged, env);
+      if (result) Object.assign(merged, result);
+    }
+  }
+  const filteredPlugins = rawPlugins.filter((p) => {
+    if (!p.apply) return true;
+    if (typeof p.apply === "function") return p.apply(resolved, env);
+    return p.apply === command;
+  });
+  const resolved = {
+    root,
+    base: merged.base ?? defaults.base,
+    mode: command === "build" ? "production" : "development",
+    framework: merged.framework ?? defaults.framework,
+    command,
+    resolve: {
+      alias: { ...defaults.resolve.alias, ...merged.resolve?.alias },
+      extensions: merged.resolve?.extensions ?? defaults.resolve.extensions,
+      conditions: merged.resolve?.conditions ?? defaults.resolve.conditions,
+      mainFields: merged.resolve?.mainFields ?? defaults.resolve.mainFields
+    },
+    plugins: filteredPlugins,
+    server: { ...defaults.server, ...merged.server },
+    build: { ...defaults.build, ...merged.build },
+    envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
+    logLevel: merged.logLevel ?? defaults.logLevel
+  };
+  for (const plugin of resolved.plugins) {
+    if (plugin.configResolved) {
+      await plugin.configResolved(resolved);
+    }
+  }
+  return resolved;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      result[key] = deepMerge(
+        result[key] ?? {},
+        val
+      );
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+var import_node_url, import_node_path, import_node_fs, CONFIG_FILES;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    import_node_url = require("url");
+    import_node_path = __toESM(require("path"), 1);
+    import_node_fs = __toESM(require("fs"), 1);
+    init_defaults();
+    CONFIG_FILES = [
+      "nasti.config.ts",
+      "nasti.config.js",
+      "nasti.config.mjs",
+      "nasti.config.mts"
+    ];
+  }
+});
+
+// src/core/plugin-container.ts
+function sortPlugins(plugins) {
+  const pre = [];
+  const normal = [];
+  const post = [];
+  for (const plugin of plugins) {
+    if (plugin.enforce === "pre") pre.push(plugin);
+    else if (plugin.enforce === "post") post.push(plugin);
+    else normal.push(plugin);
+  }
+  return [...pre, ...normal, ...post];
+}
+var PluginContainer;
+var init_plugin_container = __esm({
+  "src/core/plugin-container.ts"() {
+    "use strict";
+    PluginContainer = class {
+      plugins;
+      config;
+      ctx;
+      constructor(config) {
+        this.config = config;
+        this.plugins = sortPlugins(config.plugins);
+        this.ctx = this.createContext();
+      }
+      createContext() {
+        const container = this;
+        return {
+          async resolve(source, importer) {
+            return container.resolveId(source, importer);
+          },
+          emitFile(_file) {
+            return "";
+          },
+          getModuleInfo(_id) {
+            return null;
+          }
+        };
+      }
+      async buildStart() {
+        for (const plugin of this.plugins) {
+          if (plugin.buildStart) {
+            await plugin.buildStart.call(this.ctx);
+          }
+        }
+      }
+      async buildEnd(error) {
+        for (const plugin of this.plugins) {
+          if (plugin.buildEnd) {
+            await plugin.buildEnd.call(this.ctx, error);
+          }
+        }
+      }
+      async resolveId(source, importer, options = {}) {
+        for (const plugin of this.plugins) {
+          if (!plugin.resolveId) continue;
+          const result = await plugin.resolveId.call(
+            this.ctx,
+            source,
+            importer ?? void 0,
+            { isEntry: options.isEntry ?? false, ssr: false }
+          );
+          if (result != null) return result;
+        }
+        return null;
+      }
+      async load(id) {
+        for (const plugin of this.plugins) {
+          if (!plugin.load) continue;
+          const result = await plugin.load.call(this.ctx, id);
+          if (result != null) return result;
+        }
+        return null;
+      }
+      async transform(code, id) {
+        let currentCode = code;
+        for (const plugin of this.plugins) {
+          if (!plugin.transform) continue;
+          const result = await plugin.transform.call(this.ctx, currentCode, id);
+          if (result == null) continue;
+          if (typeof result === "string") {
+            currentCode = result;
+          } else {
+            currentCode = result.code;
+          }
+        }
+        return currentCode === code ? null : { code: currentCode };
+      }
+      /** 完整的模块处理管道: resolveId → load → transform */
+      async processModule(source, importer) {
+        const resolveResult = await this.resolveId(source, importer, {
+          isEntry: !importer
+        });
+        if (resolveResult == null) return null;
+        const id = typeof resolveResult === "string" ? resolveResult : resolveResult.id;
+        const loadResult = await this.load(id);
+        if (loadResult == null) return null;
+        const loadedCode = typeof loadResult === "string" ? loadResult : loadResult.code;
+        const transformResult = await this.transform(loadedCode, id);
+        const finalCode = transformResult == null ? loadedCode : typeof transformResult === "string" ? transformResult : transformResult.code;
+        return { id, code: finalCode };
+      }
+      getPlugins() {
+        return this.plugins;
+      }
+    };
+  }
+});
+
+// src/core/module-graph.ts
+var ModuleGraph;
+var init_module_graph = __esm({
+  "src/core/module-graph.ts"() {
+    "use strict";
+    ModuleGraph = class {
+      urlToModuleMap = /* @__PURE__ */ new Map();
+      idToModuleMap = /* @__PURE__ */ new Map();
+      fileToModulesMap = /* @__PURE__ */ new Map();
+      getModuleByUrl(url) {
+        return this.urlToModuleMap.get(url);
+      }
+      getModuleById(id) {
+        return this.idToModuleMap.get(id);
+      }
+      getModulesByFile(file) {
+        return this.fileToModulesMap.get(file);
+      }
+      async ensureEntryFromUrl(url) {
+        let mod = this.urlToModuleMap.get(url);
+        if (mod) return mod;
+        mod = this.createModule(url);
+        this.urlToModuleMap.set(url, mod);
+        return mod;
+      }
+      createModule(url, id) {
+        const mod = {
+          id: id ?? url,
+          file: null,
+          url,
+          type: url.endsWith(".css") ? "css" : "js",
+          importers: /* @__PURE__ */ new Set(),
+          importedModules: /* @__PURE__ */ new Set(),
+          acceptedHmrDeps: /* @__PURE__ */ new Set(),
+          transformResult: null,
+          lastHMRTimestamp: 0,
+          isSelfAccepting: false
+        };
+        this.idToModuleMap.set(mod.id, mod);
+        return mod;
+      }
+      /** 注册文件路径到模块的映射 */
+      registerModule(mod, file) {
+        mod.file = file;
+        let mods = this.fileToModulesMap.get(file);
+        if (!mods) {
+          mods = /* @__PURE__ */ new Set();
+          this.fileToModulesMap.set(file, mods);
+        }
+        mods.add(mod);
+      }
+      /** 更新模块依赖关系 */
+      updateModuleImports(mod, importedIds) {
+        for (const imported of mod.importedModules) {
+          imported.importers.delete(mod);
+        }
+        mod.importedModules.clear();
+        for (const id of importedIds) {
+          const importedMod = this.idToModuleMap.get(id);
+          if (importedMod) {
+            mod.importedModules.add(importedMod);
+            importedMod.importers.add(mod);
+          }
+        }
+      }
+      /** 使模块的转换缓存失效 */
+      invalidateModule(mod) {
+        mod.transformResult = null;
+        mod.lastHMRTimestamp = Date.now();
+      }
+      /** 使所有模块缓存失效 */
+      invalidateAll() {
+        for (const mod of this.idToModuleMap.values()) {
+          this.invalidateModule(mod);
+        }
+      }
+      /** 获取 HMR 传播边界 - 从变更模块向上遍历找到接受更新的边界 */
+      getHmrBoundaries(mod) {
+        const boundaries = [];
+        const visited = /* @__PURE__ */ new Set();
+        const propagate = (node, via) => {
+          if (visited.has(node)) return true;
+          visited.add(node);
+          if (node.isSelfAccepting) {
+            boundaries.push({ boundary: node, acceptedVia: via });
+            return true;
+          }
+          if (node.acceptedHmrDeps.has(via)) {
+            boundaries.push({ boundary: node, acceptedVia: via });
+            return true;
+          }
+          if (node.importers.size === 0) return false;
+          for (const importer of node.importers) {
+            if (!propagate(importer, node)) return false;
+          }
+          return true;
+        };
+        if (mod.isSelfAccepting) {
+          boundaries.push({ boundary: mod, acceptedVia: mod });
+          return boundaries;
+        }
+        for (const importer of mod.importers) {
+          if (!propagate(importer, mod)) {
+            return [];
+          }
+        }
+        return boundaries;
+      }
+    };
+  }
+});
+
+// src/server/ws.ts
+function createWebSocketServer(server) {
+  const wss = new import_ws.WebSocketServer({ noServer: true });
+  const clients = /* @__PURE__ */ new Set();
+  server.on("upgrade", (req, socket, head) => {
+    if (req.headers["sec-websocket-protocol"] === "nasti-hmr") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    }
+  });
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    ws.send(JSON.stringify({ type: "connected" }));
+    ws.on("close", () => {
+      clients.delete(ws);
+    });
+    ws.on("error", (err) => {
+      console.error("[nasti] WebSocket error:", err);
+      clients.delete(ws);
+    });
+  });
+  return {
+    send(payload) {
+      const data = JSON.stringify(payload);
+      for (const client of clients) {
+        if (client.readyState === 1) {
+          client.send(data);
+        }
+      }
+    },
+    close() {
+      clients.clear();
+      wss.close();
+    }
+  };
+}
+var import_ws;
+var init_ws = __esm({
+  "src/server/ws.ts"() {
+    "use strict";
+    import_ws = require("ws");
+  }
+});
+
+// src/core/transformer.ts
+function shouldTransform(id) {
+  return TS_EXTENSIONS.test(id) || JSX_EXTENSIONS.test(id) || JS_EXTENSIONS.test(id) && false;
+}
+function transformCode(filename, code, options = {}) {
+  const isTS = TS_EXTENSIONS.test(filename) || /\.tsx$/.test(filename);
+  const isJSX = JSX_EXTENSIONS.test(filename);
+  const result = (0, import_oxc_transform.transformSync)(filename, code, {
+    typescript: isTS ? {} : void 0,
+    jsx: isJSX || /\.tsx$/.test(filename) ? {
+      runtime: options.jsxRuntime ?? "automatic",
+      importSource: options.jsxImportSource ?? "react",
+      refresh: options.reactRefresh ?? false
+    } : void 0,
+    sourcemap: options.sourcemap ?? true
+  });
+  return {
+    code: result.code,
+    map: result.map ? JSON.stringify(result.map) : null
+  };
+}
+var import_oxc_transform, JS_EXTENSIONS, TS_EXTENSIONS, JSX_EXTENSIONS;
+var init_transformer = __esm({
+  "src/core/transformer.ts"() {
+    "use strict";
+    import_oxc_transform = require("oxc-transform");
+    JS_EXTENSIONS = /\.(js|mjs|cjs)$/;
+    TS_EXTENSIONS = /\.(ts|mts|cts)$/;
+    JSX_EXTENSIONS = /\.(jsx|tsx)$/;
+  }
+});
+
+// src/plugins/html.ts
+function htmlPlugin(config) {
+  return {
+    name: "nasti:html",
+    enforce: "post",
+    transformIndexHtml(html) {
+      const tags = [];
+      if (config.command === "serve") {
+        tags.push({
+          tag: "script",
+          attrs: { type: "module", src: "/@nasti/client" },
+          injectTo: "head-prepend"
+        });
+      }
+      return { html, tags };
+    }
+  };
+}
+function processHtml(html, tags) {
+  const headPrepend = tags.filter((t) => t.injectTo === "head-prepend");
+  const head = tags.filter((t) => t.injectTo === "head" || !t.injectTo);
+  const bodyPrepend = tags.filter((t) => t.injectTo === "body-prepend");
+  const body = tags.filter((t) => t.injectTo === "body");
+  if (headPrepend.length) {
+    html = html.replace(/<head([^>]*)>/i, `<head$1>
+${serializeTags(headPrepend)}`);
+  }
+  if (head.length) {
+    html = html.replace(/<\/head>/i, `${serializeTags(head)}
+</head>`);
+  }
+  if (bodyPrepend.length) {
+    html = html.replace(/<body([^>]*)>/i, `<body$1>
+${serializeTags(bodyPrepend)}`);
+  }
+  if (body.length) {
+    html = html.replace(/<\/body>/i, `${serializeTags(body)}
+</body>`);
+  }
+  return html;
+}
+function serializeTags(tags) {
+  return tags.map(serializeTag).join("\n");
+}
+function serializeTag(tag) {
+  const attrs = tag.attrs ? " " + Object.entries(tag.attrs).map(([k, v]) => v === true ? k : `${k}="${v}"`).join(" ") : "";
+  const children = typeof tag.children === "string" ? tag.children : tag.children ? serializeTags(tag.children) : "";
+  const selfClosing = ["link", "meta", "br", "hr", "img", "input"].includes(tag.tag);
+  if (selfClosing && !children) {
+    return `  <${tag.tag}${attrs} />`;
+  }
+  return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
+}
+async function readHtmlFile(root) {
+  const htmlPath = import_node_path2.default.resolve(root, "index.html");
+  if (!import_node_fs2.default.existsSync(htmlPath)) return null;
+  return import_node_fs2.default.readFileSync(htmlPath, "utf-8");
+}
+var import_node_path2, import_node_fs2;
+var init_html = __esm({
+  "src/plugins/html.ts"() {
+    "use strict";
+    import_node_path2 = __toESM(require("path"), 1);
+    import_node_fs2 = __toESM(require("fs"), 1);
+  }
+});
+
+// src/server/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  transformMiddleware: () => transformMiddleware,
+  transformRequest: () => transformRequest
+});
+function transformMiddleware(ctx) {
+  return async (req, res, next) => {
+    const url = req.url ?? "/";
+    if (req.method !== "GET") return next();
+    if (url === "/@nasti/client") {
+      res.setHeader("Content-Type", "application/javascript");
+      res.end(getHmrClientCode());
+      return;
+    }
+    if (url === "/" || url.endsWith(".html")) {
+      const html = await readHtmlFile(ctx.config.root);
+      if (html) {
+        let processedHtml = html;
+        for (const plugin of ctx.config.plugins) {
+          if (plugin.transformIndexHtml) {
+            const result = await plugin.transformIndexHtml(processedHtml);
+            if (typeof result === "string") {
+              processedHtml = result;
+            } else if (result && "html" in result) {
+              processedHtml = processHtml(result.html, result.tags);
+            } else if (Array.isArray(result)) {
+              processedHtml = processHtml(processedHtml, result);
+            }
+          }
+        }
+        processedHtml = processedHtml.replace(
+          "<head>",
+          '<head>\n  <script type="module" src="/@nasti/client"></script>'
+        );
+        res.setHeader("Content-Type", "text/html");
+        res.end(processedHtml);
+        return;
+      }
+    }
+    if (isModuleRequest(url)) {
+      try {
+        const result = await transformRequest(url, ctx);
+        if (result) {
+          const contentType = url.endsWith(".css") ? "application/javascript" : "application/javascript";
+          res.setHeader("Content-Type", contentType);
+          res.setHeader("Cache-Control", "no-cache");
+          res.end(typeof result === "string" ? result : result.code);
+          return;
+        }
+      } catch (err) {
+        console.error(`[nasti] Transform error: ${url}`, err.message);
+        res.statusCode = 500;
+        res.end(`Transform error: ${err.message}`);
+        return;
+      }
+    }
+    next();
+  };
+}
+async function transformRequest(url, ctx) {
+  const { config, pluginContainer, moduleGraph } = ctx;
+  const cached = moduleGraph.getModuleByUrl(url);
+  if (cached?.transformResult) {
+    return cached.transformResult;
+  }
+  const filePath = resolveUrlToFile(url, config.root);
+  if (!filePath || !import_node_fs3.default.existsSync(filePath)) return null;
+  const mod = await moduleGraph.ensureEntryFromUrl(url);
+  moduleGraph.registerModule(mod, filePath);
+  let code = import_node_fs3.default.readFileSync(filePath, "utf-8");
+  const pluginResult = await pluginContainer.transform(code, filePath);
+  if (pluginResult) {
+    code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
+  }
+  if (shouldTransform(filePath)) {
+    const result = transformCode(filePath, code, {
+      sourcemap: true,
+      jsxRuntime: "automatic",
+      jsxImportSource: config.framework === "vue" ? "vue" : "react",
+      reactRefresh: config.framework !== "vue"
+    });
+    code = result.code;
+  }
+  code = rewriteImports(code, config);
+  const transformResult = { code };
+  mod.transformResult = transformResult;
+  return transformResult;
+}
+function rewriteImports(code, config) {
+  return code.replace(
+    /from\s+['"]([^'"./][^'"]*)['"]/g,
+    (match, specifier) => {
+      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
+      return `from "/@modules/${specifier}"`;
+    }
+  ).replace(
+    /import\s+['"]([^'"./][^'"]*)['"]/g,
+    (match, specifier) => {
+      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
+      return `import "/@modules/${specifier}"`;
+    }
+  );
+}
+function resolveUrlToFile(url, root) {
+  const cleanUrl = url.split("?")[0];
+  if (cleanUrl.startsWith("/@modules/")) {
+    const moduleName = cleanUrl.slice("/@modules/".length);
+    try {
+      const { createRequire: createRequire2 } = require("module");
+      const req = createRequire2(import_node_path3.default.resolve(root, "package.json"));
+      return req.resolve(moduleName);
+    } catch {
+      return null;
+    }
+  }
+  return import_node_path3.default.resolve(root, cleanUrl.replace(/^\//, ""));
+}
+function isModuleRequest(url) {
+  const cleanUrl = url.split("?")[0];
+  return /\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl) || cleanUrl.startsWith("/@modules/");
+}
+function getHmrClientCode() {
+  return `
+// Nasti HMR Client
+const socket = new WebSocket(\`ws://\${location.host}\`, 'nasti-hmr');
+const hotModulesMap = new Map();
+
+socket.addEventListener('message', ({ data }) => {
+  const payload = JSON.parse(data);
+  switch (payload.type) {
+    case 'connected':
+      console.log('[nasti] connected.');
+      break;
+    case 'update':
+      payload.updates.forEach((update) => {
+        if (update.type === 'js-update') {
+          fetchUpdate(update);
+        } else if (update.type === 'css-update') {
+          updateCss(update.path);
+        }
+      });
+      break;
+    case 'full-reload':
+      console.log('[nasti] full reload');
+      location.reload();
+      break;
+    case 'error':
+      console.error('[nasti] error:', payload.err.message);
+      showErrorOverlay(payload.err);
+      break;
+  }
+});
+
+async function fetchUpdate(update) {
+  const mod = hotModulesMap.get(update.path);
+  if (mod) {
+    const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
+    mod.callbacks.forEach((cb) => cb(newMod));
+  } else {
+    // \u6CA1\u6709\u6CE8\u518C hot \u56DE\u8C03\uFF0C\u5C1D\u8BD5\u91CD\u65B0 import
+    await import(update.path + '?t=' + update.timestamp);
+  }
+}
+
+function updateCss(path) {
+  const el = document.querySelector(\`style[data-nasti-css="\${path}"]\`);
+  if (el) {
+    fetch(path + '?t=' + Date.now())
+      .then(r => r.text())
+      .then(css => { el.textContent = css; });
+  }
+}
+
+function showErrorOverlay(err) {
+  const overlay = document.createElement('div');
+  overlay.id = 'nasti-error-overlay';
+  overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
+  overlay.innerHTML = \`<h2 style="color:#ff5555">Build Error</h2><pre>\${err.message}\\n\${err.stack || ''}</pre><button onclick="this.parentElement.remove()" style="margin-top:1rem;padding:0.5rem 1rem;cursor:pointer">Close</button>\`;
+  document.body.appendChild(overlay);
+}
+
+// import.meta.hot API
+const createHotContext = (ownerPath) => ({
+  accept(deps, callback) {
+    if (typeof deps === 'function' || !deps) {
+      // self-accepting
+      const callbacks = hotModulesMap.get(ownerPath)?.callbacks || [];
+      callbacks.push(deps || (() => {}));
+      hotModulesMap.set(ownerPath, { callbacks });
+    }
+  },
+  prune(callback) {
+    // \u6A21\u5757\u88AB\u79FB\u9664\u65F6\u6267\u884C
+  },
+  dispose(callback) {
+    // \u6A21\u5757\u66F4\u65B0\u524D\u6267\u884C\u6E05\u7406
+  },
+  invalidate() {
+    location.reload();
+  },
+  data: {},
+});
+
+// \u66B4\u9732\u7ED9\u6A21\u5757\u4F7F\u7528
+if (!window.__nasti_hot_map) window.__nasti_hot_map = new Map();
+window.__NASTI_HMR__ = { createHotContext };
+`;
+}
+var import_node_path3, import_node_fs3;
+var init_middleware = __esm({
+  "src/server/middleware.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_fs3 = __toESM(require("fs"), 1);
+    init_transformer();
+    init_html();
+  }
+});
+
+// src/server/hmr.ts
+async function handleFileChange(file, server) {
+  const { moduleGraph, ws, config } = server;
+  const relativePath = "/" + import_node_path4.default.relative(config.root, file);
+  const mods = moduleGraph.getModulesByFile(file);
+  if (!mods || mods.size === 0) {
+    return;
+  }
+  const updates = [];
+  const timestamp = Date.now();
+  for (const mod of mods) {
+    moduleGraph.invalidateModule(mod);
+    const ctx = {
+      file,
+      timestamp,
+      modules: [mod],
+      read: () => import_node_fs4.default.readFileSync(file, "utf-8"),
+      server
+    };
+    let affectedModules = [mod];
+    for (const plugin of config.plugins) {
+      if (plugin.handleHotUpdate) {
+        const result = await plugin.handleHotUpdate(ctx);
+        if (result) {
+          affectedModules = result;
+        }
+      }
+    }
+    for (const affected of affectedModules) {
+      const boundaries = moduleGraph.getHmrBoundaries(affected);
+      if (boundaries.length === 0) {
+        ws.send({ type: "full-reload", path: relativePath });
+        return;
+      }
+      for (const { boundary } of boundaries) {
+        updates.push({
+          type: boundary.type === "css" ? "css-update" : "js-update",
+          path: boundary.url,
+          acceptedPath: affected.url,
+          timestamp
+        });
+      }
+    }
+  }
+  if (updates.length > 0) {
+    ws.send({ type: "update", updates });
+  }
+}
+var import_node_path4, import_node_fs4;
+var init_hmr = __esm({
+  "src/server/hmr.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"), 1);
+    import_node_fs4 = __toESM(require("fs"), 1);
+  }
+});
+
+// src/plugins/resolve.ts
+function resolvePlugin(config) {
+  const { alias, extensions } = config.resolve;
+  const require2 = (0, import_node_module.createRequire)(import_node_path5.default.resolve(config.root, "package.json"));
+  return {
+    name: "nasti:resolve",
+    enforce: "pre",
+    resolveId(source, importer) {
+      for (const [key, value] of Object.entries(alias)) {
+        if (source === key || source.startsWith(key + "/")) {
+          source = source.replace(key, value);
+          if (!import_node_path5.default.isAbsolute(source)) {
+            source = import_node_path5.default.resolve(config.root, source);
+          }
+          break;
+        }
+      }
+      if (import_node_path5.default.isAbsolute(source)) {
+        const resolved = tryResolveFile(source, extensions);
+        if (resolved) return resolved;
+      }
+      if (source.startsWith(".")) {
+        const dir = importer ? import_node_path5.default.dirname(importer) : config.root;
+        const absolute = import_node_path5.default.resolve(dir, source);
+        const resolved = tryResolveFile(absolute, extensions);
+        if (resolved) return resolved;
+      }
+      if (!source.startsWith("/") && !source.startsWith(".")) {
+        try {
+          const resolved = require2.resolve(source, {
+            paths: [importer ? import_node_path5.default.dirname(importer) : config.root]
+          });
+          return resolved;
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    },
+    load(id) {
+      if (import_node_fs5.default.existsSync(id)) {
+        return import_node_fs5.default.readFileSync(id, "utf-8");
+      }
+      return null;
+    }
+  };
+}
+function tryResolveFile(file, extensions) {
+  if (import_node_fs5.default.existsSync(file) && import_node_fs5.default.statSync(file).isFile()) {
+    return file;
+  }
+  for (const ext of extensions) {
+    const withExt = file + ext;
+    if (import_node_fs5.default.existsSync(withExt) && import_node_fs5.default.statSync(withExt).isFile()) {
+      return withExt;
+    }
+  }
+  if (import_node_fs5.default.existsSync(file) && import_node_fs5.default.statSync(file).isDirectory()) {
+    for (const ext of extensions) {
+      const indexFile = import_node_path5.default.join(file, "index" + ext);
+      if (import_node_fs5.default.existsSync(indexFile)) {
+        return indexFile;
+      }
+    }
+  }
+  return null;
+}
+var import_node_path5, import_node_fs5, import_node_module;
+var init_resolve = __esm({
+  "src/plugins/resolve.ts"() {
+    "use strict";
+    import_node_path5 = __toESM(require("path"), 1);
+    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_module = require("module");
+  }
+});
+
+// src/plugins/css.ts
+function cssPlugin(config) {
+  return {
+    name: "nasti:css",
+    resolveId(source) {
+      if (source.endsWith(".css")) return null;
+      return null;
+    },
+    transform(code, id) {
+      if (!id.endsWith(".css")) return null;
+      if (config.command === "serve") {
+        const escaped = JSON.stringify(code);
+        return {
+          code: `
+const css = ${escaped};
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+style.textContent = css;
+document.head.appendChild(style);
+
+// HMR
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.prune(() => {
+    style.remove();
+  });
+}
+
+export default css;
+`
+        };
+      }
+      return null;
+    }
+  };
+}
+var import_node_path6;
+var init_css = __esm({
+  "src/plugins/css.ts"() {
+    "use strict";
+    import_node_path6 = __toESM(require("path"), 1);
+  }
+});
+
+// src/plugins/assets.ts
+function assetsPlugin(config) {
+  return {
+    name: "nasti:assets",
+    resolveId(source) {
+      if (source.endsWith("?url") || source.endsWith("?raw")) {
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      const ext = import_node_path7.default.extname(id.replace(/\?.*$/, ""));
+      if (id.endsWith("?raw")) {
+        const file = id.slice(0, -4);
+        if (import_node_fs6.default.existsSync(file)) {
+          const content = import_node_fs6.default.readFileSync(file, "utf-8");
+          return `export default ${JSON.stringify(content)}`;
+        }
+      }
+      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
+        const file = id.replace(/\?.*$/, "");
+        if (!import_node_fs6.default.existsSync(file)) return null;
+        if (config.command === "serve") {
+          const url = "/" + import_node_path7.default.relative(config.root, file);
+          return `export default ${JSON.stringify(url)}`;
+        }
+        const content = import_node_fs6.default.readFileSync(file);
+        const hash = import_node_crypto.default.createHash("sha256").update(content).digest("hex").slice(0, 8);
+        const basename = import_node_path7.default.basename(file, ext);
+        const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
+        return `export default ${JSON.stringify(config.base + hashedName)}`;
+      }
+      return null;
+    }
+  };
+}
+var import_node_path7, import_node_fs6, import_node_crypto, ASSET_EXTENSIONS;
+var init_assets = __esm({
+  "src/plugins/assets.ts"() {
+    "use strict";
+    import_node_path7 = __toESM(require("path"), 1);
+    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_crypto = __toESM(require("crypto"), 1);
+    ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".webp",
+      ".avif",
+      ".mp4",
+      ".webm",
+      ".ogg",
+      ".mp3",
+      ".wav",
+      ".flac",
+      ".aac",
+      ".woff",
+      ".woff2",
+      ".eot",
+      ".ttf",
+      ".otf",
+      ".pdf",
+      ".txt"
+    ]);
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+async function createServer(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "serve");
+  const allPlugins = [
+    resolvePlugin(config),
+    cssPlugin(config),
+    assetsPlugin(config),
+    htmlPlugin(config),
+    ...config.plugins
+  ];
+  const configWithPlugins = { ...config, plugins: allPlugins };
+  const moduleGraph = new ModuleGraph();
+  const pluginContainer = new PluginContainer(configWithPlugins);
+  const app = (0, import_connect.default)();
+  app.use(transformMiddleware({
+    config: configWithPlugins,
+    pluginContainer,
+    moduleGraph
+  }));
+  const publicDir = import_node_path8.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 watcher = (0, import_chokidar.watch)(config.root, {
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      `**/${config.build.outDir}/**`
+    ],
+    ignoreInitial: true
+  });
+  let server;
+  watcher.on("change", (file) => {
+    handleFileChange(file, server);
+  });
+  watcher.on("add", (file) => {
+    handleFileChange(file, server);
+  });
+  const postMiddlewares = [];
+  for (const plugin of allPlugins) {
+    if (plugin.configureServer) {
+      const result = await plugin.configureServer(server);
+      if (typeof result === "function") {
+        postMiddlewares.push(result);
+      }
+    }
+  }
+  server = {
+    config: configWithPlugins,
+    middlewares: app,
+    moduleGraph,
+    watcher,
+    ws,
+    async listen(port) {
+      const finalPort = port ?? config.server.port;
+      const host = config.server.host === true ? "0.0.0.0" : config.server.host;
+      await pluginContainer.buildStart();
+      return new Promise((resolve, reject) => {
+        httpServer.listen(finalPort, host, () => {
+          const localUrl = `http://localhost:${finalPort}`;
+          const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${finalPort}` : null;
+          console.log();
+          console.log(import_picocolors.default.cyan("  nasti dev server") + import_picocolors.default.dim(` v0.0.1`));
+          console.log();
+          console.log(`  ${import_picocolors.default.green(">")} Local:   ${import_picocolors.default.cyan(localUrl)}`);
+          if (networkUrl) {
+            console.log(`  ${import_picocolors.default.green(">")} Network: ${import_picocolors.default.cyan(networkUrl)}`);
+          }
+          console.log();
+          resolve(server);
+        });
+        httpServer.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            console.log(import_picocolors.default.yellow(`Port ${finalPort} is in use, trying ${finalPort + 1}...`));
+            httpServer.listen(finalPort + 1, host);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    },
+    async transformRequest(url) {
+      const { transformRequest: transformRequest2 } = await Promise.resolve().then(() => (init_middleware(), middleware_exports));
+      return transformRequest2(url, { config: configWithPlugins, pluginContainer, moduleGraph });
+    },
+    async close() {
+      await pluginContainer.buildEnd();
+      watcher.close();
+      ws.close();
+      httpServer.close();
+    }
+  };
+  return server;
+}
+function getNetworkAddress() {
+  const os = require("os");
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] ?? []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "localhost";
+}
+var import_node_http, import_node_path8, import_connect, import_sirv, import_chokidar, import_picocolors;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    import_node_http = __toESM(require("http"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    import_connect = __toESM(require("connect"), 1);
+    import_sirv = __toESM(require("sirv"), 1);
+    import_chokidar = require("chokidar");
+    import_picocolors = __toESM(require("picocolors"), 1);
+    init_config();
+    init_plugin_container();
+    init_module_graph();
+    init_ws();
+    init_middleware();
+    init_hmr();
+    init_resolve();
+    init_css();
+    init_assets();
+    init_html();
+  }
+});
+
+// src/build/index.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "build");
+  const startTime = performance.now();
+  console.log(import_picocolors2.default.cyan("\n\u{1F528} nasti build") + import_picocolors2.default.dim(` v${process.env.npm_package_version ?? "0.0.1"}`));
+  console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
+  console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
+  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 html = await readHtmlFile(config.root);
+  let entryPoints = [];
+  if (html) {
+    const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
+    for (const match of scriptMatches) {
+      const src = match[1];
+      if (src && !src.startsWith("http")) {
+        entryPoints.push(import_node_path9.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_path9.default.resolve(config.root, entry);
+      if (import_node_fs7.default.existsSync(fullPath)) {
+        entryPoints.push(fullPath);
+        break;
+      }
+    }
+  }
+  if (entryPoints.length === 0) {
+    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
+  }
+  const builtinPlugins = [
+    resolvePlugin(config),
+    cssPlugin(config),
+    assetsPlugin(config)
+  ];
+  const allPlugins = [...builtinPlugins, ...config.plugins];
+  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 (0, import_rolldown.rolldown)({
+    input: entryPoints,
+    plugins: [
+      oxcTransformPlugin,
+      // 转换 Nasti 插件为 Rolldown 插件格式
+      ...allPlugins.map((p) => ({
+        name: p.name,
+        resolveId: p.resolveId,
+        load: p.load,
+        transform: p.transform,
+        buildStart: p.buildStart,
+        buildEnd: p.buildEnd
+      }))
+    ],
+    ...config.build.rolldownOptions
+  });
+  const { output } = await bundle.write({
+    dir: outDir,
+    format: "esm",
+    sourcemap: !!config.build.sourcemap,
+    entryFileNames: "assets/[name].[hash].js",
+    chunkFileNames: "assets/[name].[hash].js",
+    assetFileNames: "assets/[name].[hash][extname]"
+  });
+  await bundle.close();
+  if (html) {
+    let processedHtml = html;
+    const htmlPlugin_ = htmlPlugin(config);
+    if (htmlPlugin_.transformIndexHtml) {
+      const result = await htmlPlugin_.transformIndexHtml(processedHtml);
+      if (typeof result === "string") {
+        processedHtml = result;
+      } else if (result && "html" in result) {
+        processedHtml = processHtml(result.html, result.tags);
+      } else if (Array.isArray(result)) {
+        processedHtml = processHtml(processedHtml, result);
+      }
+    }
+    for (const chunk of output) {
+      if (chunk.type === "chunk" && chunk.isEntry) {
+        const originalEntry = import_node_path9.default.relative(config.root, entryPoints[0]);
+        processedHtml = processedHtml.replace(
+          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
+          `$1${config.base}${chunk.fileName}$3`
+        );
+      }
+    }
+    import_node_fs7.default.writeFileSync(import_node_path9.default.resolve(outDir, "index.html"), processedHtml);
+  }
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
+  const totalSize = output.reduce((sum, chunk) => {
+    if (chunk.type === "chunk" && chunk.code) return sum + chunk.code.length;
+    return sum;
+  }, 0);
+  console.log(import_picocolors2.default.green(`
+\u2713 Built in ${elapsed}s`));
+  console.log(import_picocolors2.default.dim(`  ${output.length} files, ${formatSize(totalSize)} total`));
+  console.log(import_picocolors2.default.dim(`  output: ${config.build.outDir}/
+`));
+  return { output };
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var import_node_path9, import_node_fs7, import_rolldown, import_picocolors2;
+var init_build = __esm({
+  "src/build/index.ts"() {
+    "use strict";
+    import_node_path9 = __toESM(require("path"), 1);
+    import_node_fs7 = __toESM(require("fs"), 1);
+    import_rolldown = require("rolldown");
+    init_config();
+    init_resolve();
+    init_css();
+    init_assets();
+    init_html();
+    init_transformer();
+    import_picocolors2 = __toESM(require("picocolors"), 1);
+  }
+});
+
+// src/cli.ts
+var import_cac = require("cac");
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var cli = (0, import_cac.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 {
+    const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const server = await createServer2({
+      root: root ?? ".",
+      mode: options.mode ?? "development",
+      server: {
+        port: options.port,
+        host: options.host,
+        open: options.open
+      }
+    });
+    await server.listen();
+  } catch (err) {
+    console.error(import_picocolors3.default.red(`
+  Error starting dev server:
+  ${err.message}
+`));
+    if (err.stack) console.error(import_picocolors3.default.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) => {
+  try {
+    const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+    await build2({
+      root: root ?? ".",
+      mode: options.mode ?? "production",
+      build: {
+        outDir: options.outDir,
+        sourcemap: options.sourcemap,
+        minify: options.minify
+      }
+    });
+  } catch (err) {
+    console.error(import_picocolors3.default.red(`
+  Build failed:
+  ${err.message}
+`));
+    if (err.stack) console.error(import_picocolors3.default.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 path10 = await import("path");
+    const sirv2 = (await import("sirv")).default;
+    const connect2 = (await import("connect")).default;
+    const resolvedRoot = path10.resolve(root ?? ".");
+    const outDir = path10.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(import_picocolors3.default.cyan("  \u{1F50D} nasti preview"));
+      console.log();
+      console.log(`  ${import_picocolors3.default.green("\u279C")} Local: ${import_picocolors3.default.cyan(`http://localhost:${port}`)}`);
+      console.log();
+    });
+  } catch (err) {
+    console.error(import_picocolors3.default.red(`
+  Preview failed:
+  ${err.message}
+`));
+    process.exit(1);
+  }
+});
+cli.help();
+cli.version("0.0.1");
+cli.parse();
+//# sourceMappingURL=cli.cjs.map