valaxy 0.25.10 → 0.26.0

package/dist/{chunk-JHXXCWZC.js → chunk-INEH2Z2Z.js}

@@ -1,17 +1,17 @@
 // node/cli/index.ts
-import process15 from "process";
+import process16 from "process";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
 // package.json
-var version = "0.25.10";
+var version = "0.26.0";
 
 // node/modules/fuse.ts
 import path4 from "path";
-import { consola as consola9 } from "consola";
+import { consola as consola8 } from "consola";
 import { colors as colors7 } from "consola/utils";
 import fg2 from "fast-glob";
-import fs7 from "fs-extra";
+import fs6 from "fs-extra";
 import matter from "gray-matter";
 
 // node/modules/index.ts
@@ -37,12 +37,12 @@ function commonOptions(args) {
 import { dirname as dirname2 } from "path";
 import process4 from "process";
 import { ensureSuffix, uniq } from "@antfu/utils";
-import { consola as consola7 } from "consola";
+import { consola as consola6 } from "consola";
 import { colors as colors6 } from "consola/utils";
 import _debug from "debug";
 import fg from "fast-glob";
-import fs5 from "fs-extra";
-import { resolve as resolve4 } from "pathe";
+import fs4 from "fs-extra";
+import { resolve as resolve3 } from "pathe";
 
 // node/build/bundle.ts
 import path from "path";
@@ -155,12 +155,12 @@ function getRollupOptions(options) {
 
 // node/config/addon.ts
 import path2 from "path";
-import fs2 from "fs-extra";
+import fs from "fs-extra";
 
 // node/config/valaxy.ts
 import process2 from "process";
 import { isFunction } from "@antfu/utils";
-import { consola as consola4 } from "consola";
+import { consola as consola3 } from "consola";
 import { colors as colors2 } from "consola/utils";
 import { createDefu } from "defu";
 import { mergeConfig as mergeViteConfig } from "vite";
@@ -180,43 +180,18 @@ function countPerformanceTime() {
 
 // node/config/site.ts
 import { webcrypto } from "crypto";
-import { consola as consola3 } from "consola";
+import { consola as consola2 } from "consola";
 import { colors } from "consola/utils";
 import { options as floatingVueOptions } from "floating-vue";
 
 // node/config/utils.ts
 import process from "process";
-import { consola as consola2 } from "consola";
-import fs from "fs-extra";
-import { createJiti } from "jiti";
-import { resolve } from "pathe";
-var jiti = createJiti(import.meta.url, {
-  // for hmr
-  moduleCache: false
-});
-async function loadConfig(options) {
-  const { name, cwd } = options;
-  const filePath = resolve(cwd, `${name}.config.ts`);
-  let data = {};
-  if (await fs.exists(filePath)) {
-    try {
-      data = await jiti.import(filePath, { default: true });
-    } catch (e) {
-      console.error(e);
-      consola2.error(`Failed to load config file: ${filePath}`);
-    }
-  } else {
-    consola2.debug(`Config file not found: ${filePath}`);
-  }
-  return {
-    config: data,
-    configFile: filePath
-  };
-}
+import { loadConfig } from "define-config-ts";
 async function loadConfigFromFile(file, options = {}) {
   const { config, configFile } = await loadConfig({
     name: file,
-    cwd: options.cwd || process.cwd()
+    cwd: options.cwd || process.cwd(),
+    throwOnNotFound: false
   });
   let userConfig = config;
   if (typeof config === "function")
@@ -327,7 +302,7 @@ async function resolveSiteConfig(root) {
   const { config: userSiteConfig, configFile: siteConfigFile } = await resolveSiteConfigFromRoot(root);
   const duration = endCount();
   if (userSiteConfig && siteConfigFile)
-    consola3.success(`Resolve ${colors.cyan("siteConfig")} from ${colors.dim(siteConfigFile)} ${colors.yellow(duration)}`);
+    consola2.success(`Resolve ${colors.cyan("siteConfig")} from ${colors.dim(siteConfigFile)} ${colors.yellow(duration)}`);
   return {
     siteConfig: userSiteConfig,
     siteConfigFile
@@ -407,7 +382,7 @@ async function resolveValaxyConfig(options) {
   const { config: userValaxyConfig, configFile } = await resolveValaxyConfigFromRoot(configRoot);
   const duration = endCount();
   if (configFile && userValaxyConfig && Object.keys(userValaxyConfig).length !== 0)
-    consola4.success(`Resolve ${colors2.cyan("userValaxyConfig")} from ${colors2.dim(configFile)} ${colors2.yellow(duration)}`);
+    consola3.success(`Resolve ${colors2.cyan("userValaxyConfig")} from ${colors2.dim(configFile)} ${colors2.yellow(duration)}`);
   const theme = options.theme || userValaxyConfig?.theme || "yun";
   return {
     config: userValaxyConfig,
@@ -425,7 +400,7 @@ async function resolveAddonsConfig(addons, options) {
   let valaxyConfig = {};
   for (const addon of addons) {
     const addonConfigPath = path2.resolve(addon.root, "valaxy.config.ts");
-    if (!await fs2.exists(addonConfigPath))
+    if (!await fs.exists(addonConfigPath))
       continue;
     const { config, configFile } = await resolveValaxyConfigFromRoot(addon.root, options);
     if (!config)
@@ -441,10 +416,10 @@ import { colors as colors4 } from "consola/utils";
 import defu from "defu";
 
 // node/logger/index.ts
-import { consola as consola5 } from "consola";
+import { consola as consola4 } from "consola";
 import { colors as colors3 } from "consola/utils";
 import ora from "ora";
-var logger = consola5.create({});
+var logger = consola4.create({});
 var valaxyPrefix = colors3.magenta("[valaxy]");
 var vLogger = {
   success: (...args) => logger.success(valaxyPrefix, ...args),
@@ -499,7 +474,7 @@ var replaceArrMerge = createDefu2((obj, key, value) => {
 // node/utils/getGitTimestamp.ts
 import { spawn } from "cross-spawn";
 function getGitTimestamp(file, type = "updated") {
-  return new Promise((resolve15, _reject) => {
+  return new Promise((resolve14, _reject) => {
     const params = ["log"];
     if (type === "updated")
       params.push("-1");
@@ -510,10 +485,10 @@ function getGitTimestamp(file, type = "updated") {
     let output = "";
     child.stdout.on("data", (d) => output += String(d));
     child.on("close", () => {
-      resolve15(+new Date(output));
+      resolve14(+new Date(output));
     });
     child.on("error", () => {
-      resolve15(0);
+      resolve14(0);
     });
   });
 }
@@ -547,7 +522,7 @@ function $t(key) {
 
 // node/utils/resolve.ts
 import { ensurePrefix, slash } from "@antfu/utils";
-import { consola as consola6 } from "consola";
+import { consola as consola5 } from "consola";
 import { resolvePath } from "mlly";
 import { resolveGlobal } from "resolve-global";
 var isInstalledGlobally = {};
@@ -563,7 +538,7 @@ async function resolveImportPath(importName, ensure = false) {
       url: import.meta.url
     });
   } catch (error) {
-    consola6.log(error);
+    consola5.log(error);
   }
   if (isInstalledGlobally.value) {
     try {
@@ -574,33 +549,33 @@ async function resolveImportPath(importName, ensure = false) {
   if (ensure)
     throw new Error(`Failed to resolve package ${importName}`);
   else
-    consola6.warn(`Failed to resolve package ${importName}`);
+    consola5.warn(`Failed to resolve package ${importName}`);
 }
 
 // node/utils/addons.ts
 import process3 from "process";
 import { colors as colors5 } from "consola/utils";
 import defu2 from "defu";
-import fs4 from "fs-extra";
+import fs3 from "fs-extra";
 import ora2 from "ora";
-import { resolve as resolve3 } from "pathe";
+import { resolve as resolve2 } from "pathe";
 
 // node/utils/root.ts
 import { dirname } from "path";
-import fs3 from "fs-extra";
-import { resolve as resolve2 } from "pathe";
+import fs2 from "fs-extra";
+import { resolve } from "pathe";
 async function getModuleRoot(name, entry) {
   if (!name)
     return "";
   if (isPath(name)) {
     if (entry) {
-      const isFile = fs3.lstatSync(entry).isFile();
-      return resolve2(isFile ? dirname(entry) : entry, name);
+      const isFile = fs2.lstatSync(entry).isFile();
+      return resolve(isFile ? dirname(entry) : entry, name);
     } else {
       throw new Error(`entry is required when ${name} is path`);
     }
   } else {
-    return resolve2(dirname(await resolveImportPath(`${name}/package.json`) || ""));
+    return resolve(dirname(await resolveImportPath(`${name}/package.json`) || ""));
   }
 }
 
@@ -631,12 +606,12 @@ async function parseAddons(addons, userRoot2 = process3.cwd()) {
 }
 async function readAddonModule(name, options = {}) {
   const root = await getAddonRoot(name, options.cwd || process3.cwd());
-  const packageJSONPath = resolve3(root, "./package.json");
-  if (!await fs4.exists(packageJSONPath)) {
+  const packageJSONPath = resolve2(root, "./package.json");
+  if (!await fs3.exists(packageJSONPath)) {
     logger.error(`No addon named ${name} found`);
     return;
   }
-  const packageJSON = await fs4.readJSON(packageJSONPath);
+  const packageJSON = await fs3.readJSON(packageJSONPath);
   const resolver = {
     enable: true,
     name: packageJSON.name,
@@ -714,9 +689,9 @@ async function processSiteConfig(options) {
   const siteConfig = config.siteConfig;
   siteConfig.url = ensureSuffix("/", siteConfig.url || "");
   siteConfig.cdn.prefix = ensureSuffix("/", siteConfig.cdn.prefix || "");
-  const themePkgPath = resolve4(themeRoot, "package.json");
+  const themePkgPath = resolve3(themeRoot, "package.json");
   try {
-    config.themeConfig.pkg = await fs5.readJson(themePkgPath, "utf-8");
+    config.themeConfig.pkg = await fs4.readJson(themePkgPath, "utf-8");
   } catch (e) {
     console.error(`valaxy-theme-${theme} doesn't have package.json`);
   }
@@ -754,16 +729,16 @@ async function processValaxyOptions(valaxyOptions, valaxyConfig) {
 }
 async function resolveOptions(options = { userRoot: process4.cwd() }, mode = "dev") {
   const pkgRoot = dirname2(await resolveImportPath("valaxy/package.json", true));
-  const clientRoot = resolve4(pkgRoot, "client");
-  const userRoot2 = resolve4(options.userRoot || process4.cwd());
-  consola7.start(`Resolve ${colors6.magenta("valaxy")} config ...`);
+  const clientRoot = resolve3(pkgRoot, "client");
+  const userRoot2 = resolve3(options.userRoot || process4.cwd());
+  consola6.start(`Resolve ${colors6.magenta("valaxy")} config ...`);
   const [resolvedValaxy, resolvedSite, resolvedTheme, pages] = await Promise.all([
     resolveValaxyConfig(options),
     resolveSiteConfig(options.userRoot),
     // resolveThemeConfig(options),
     resolveThemeConfigFromRoot(options.userRoot),
     fg(["**.md"], {
-      cwd: resolve4(userRoot2, "pages"),
+      cwd: resolve3(userRoot2, "pages"),
       ignore: ["**/node_modules"]
     })
   ]);
@@ -776,7 +751,7 @@ async function resolveOptions(options = { userRoot: process4.cwd() }, mode = "de
   let valaxyOptions = {
     mode,
     pkgRoot,
-    tempDir: resolve4(userRoot2, ".valaxy"),
+    tempDir: resolve3(userRoot2, ".valaxy"),
     clientRoot,
     userRoot: userRoot2,
     themeRoot,
@@ -808,7 +783,7 @@ async function resolveOptions(options = { userRoot: process4.cwd() }, mode = "de
   const themeValaxyConfig = await resolveThemeValaxyConfig(valaxyOptions);
   const valaxyConfig = mergeValaxyConfig(userValaxyConfig, themeValaxyConfig);
   valaxyOptions = await processValaxyOptions(valaxyOptions, valaxyConfig);
-  fs5.ensureDirSync(valaxyOptions.tempDir);
+  fs4.ensureDirSync(valaxyOptions.tempDir);
   return valaxyOptions;
 }
 async function resolveThemeValaxyConfig(options) {
@@ -816,7 +791,7 @@ async function resolveThemeValaxyConfig(options) {
   const { config: themeValaxyConfig } = await resolveValaxyConfigFromRoot(options.themeRoot, options);
   const duration = endCount();
   if (themeValaxyConfig)
-    consola7.success(`Resolve ${colors6.cyan("valaxy.config.ts")} from ${colors6.blue(`theme(${options.theme})`)} ${colors6.yellow(duration)}`);
+    consola6.success(`Resolve ${colors6.cyan("valaxy.config.ts")} from ${colors6.blue(`theme(${options.theme})`)} ${colors6.yellow(duration)}`);
   return themeValaxyConfig;
 }
 
@@ -874,15 +849,15 @@ var matterOptions = {
 // node/utils/env.ts
 import path3 from "path";
 import process5 from "process";
-import { consola as consola8 } from "consola";
-import fs6 from "fs-extra";
+import { consola as consola7 } from "consola";
+import fs5 from "fs-extra";
 function isProd() {
   return process5.env.NODE_ENV === "production";
 }
 function setEnv(env = "development") {
   process5.env.NODE_ENV = env;
-  consola8.level = isProd() ? 2 : 3;
-  logger.level = consola8.level;
+  consola7.level = isProd() ? 2 : 3;
+  logger.level = consola7.level;
 }
 function setEnvProd() {
   return setEnv("production");
@@ -891,7 +866,7 @@ function setTimezone(timezone) {
   process5.env.TZ = timezone;
 }
 async function isPagesDirExist(root) {
-  const exist = await fs6.exists(path3.resolve(root, "pages"));
+  const exist = await fs5.exists(path3.resolve(root, "pages"));
   if (!exist)
     logger.error(`No pages directory found in ${root}`);
   return exist;
@@ -899,16 +874,16 @@ async function isPagesDirExist(root) {
 
 // node/modules/fuse.ts
 async function generateFuseList(options) {
-  consola9.start(`Generate List for Fuse Search by (${colors7.cyan("fuse.js")}) ...`);
+  consola8.start(`Generate List for Fuse Search by (${colors7.cyan("fuse.js")}) ...`);
   const pattern = options.config.siteConfig.fuse.pattern || path4.join(options.userRoot, "pages/**/*.md");
   const files = await fg2(pattern);
   const posts = [];
   for await (const i of files) {
-    const raw = fs7.readFileSync(i, "utf-8");
+    const raw = fs6.readFileSync(i, "utf-8");
     const { data, excerpt, content } = matter(raw, matterOptions);
     const fmData = data;
     if (fmData.draft) {
-      consola9.warn(`Ignore draft post: ${colors7.dim(i)}`);
+      consola8.warn(`Ignore draft post: ${colors7.dim(i)}`);
       continue;
     }
     if (fmData.hide)
@@ -938,30 +913,30 @@ async function generateFuseList(options) {
   return posts;
 }
 async function execFuse(options) {
-  consola9.info("Start generate fuse list...");
+  consola8.info("Start generate fuse list...");
   const fuseList = await generateFuseList(options);
-  await fs7.ensureDir("./dist");
+  await fs6.ensureDir("./dist");
   const publicFolder = path4.resolve(options.userRoot, "public");
   const publicFuseFile = path4.resolve(publicFolder, options.config.siteConfig.fuse.dataPath);
   const publicRelativeFile = path4.join("public", options.config.siteConfig.fuse.dataPath);
-  await fs7.ensureFile(publicFuseFile);
-  fs7.writeJSONSync(publicFuseFile, fuseList);
-  consola9.success(`Generate fuse list in ${colors7.dim(publicFolder)}`);
+  await fs6.ensureFile(publicFuseFile);
+  fs6.writeJSONSync(publicFuseFile, fuseList);
+  consola8.success(`Generate fuse list in ${colors7.dim(publicFolder)}`);
   const distFolder = path4.resolve(options.userRoot, "dist");
   const distFuseFile = path4.resolve(distFolder, options.config.siteConfig.fuse.dataPath);
-  await fs7.ensureDir(distFolder);
-  fs7.writeJSONSync(distFuseFile, fuseList);
-  consola9.success(`Generate fuse list in ${colors7.dim(distFolder)}`);
+  await fs6.ensureDir(distFolder);
+  fs6.writeJSONSync(distFuseFile, fuseList);
+  consola8.success(`Generate fuse list in ${colors7.dim(distFolder)}`);
   try {
     const gitignorePath = path4.resolve(options.userRoot, ".gitignore");
-    const gitignore = await fs7.readFile(gitignorePath, "utf-8");
+    const gitignore = await fs6.readFile(gitignorePath, "utf-8");
     const ignorePath = publicRelativeFile.replace(/\\/g, "/");
     if (!gitignore.includes(ignorePath)) {
-      await fs7.appendFile(gitignorePath, `
+      await fs6.appendFile(gitignorePath, `
 # valaxy fuse
 ${ignorePath}
 `);
-      consola9.success(`Add ${colors7.dim(ignorePath)} to ${colors7.dim(".gitignore")}`);
+      consola8.success(`Add ${colors7.dim(ignorePath)} to ${colors7.dim(".gitignore")}`);
     }
   } catch {
   }
@@ -991,26 +966,26 @@ var fuseModule = defineValaxyModule({
 
 // node/modules/rss/utils.ts
 import { readFile } from "fs/promises";
-import { dirname as dirname3, join, resolve as resolve5 } from "path";
+import { dirname as dirname3, join, resolve as resolve4 } from "path";
 import { ensurePrefix as ensurePrefix2 } from "@antfu/utils";
-import { consola as consola10 } from "consola";
+import { consola as consola9 } from "consola";
 import { colors as colors8 } from "consola/utils";
 import dayjs from "dayjs";
 import fg3 from "fast-glob";
 import { Feed } from "feed";
-import fs9 from "fs-extra";
+import fs8 from "fs-extra";
 import matter2 from "gray-matter";
 import MarkdownIt from "markdown-it";
 import ora3 from "ora";
 import { getBorderCharacters, table } from "table";
 
 // node/utils/date.ts
-import fs8 from "fs-extra";
+import fs7 from "fs-extra";
 async function getCreatedTime(file) {
-  return await getGitTimestamp(file, "created") || (await fs8.stat(file)).ctime;
+  return await getGitTimestamp(file, "created") || (await fs7.stat(file)).ctime;
 }
 async function getUpdatedTime(file) {
-  return await getGitTimestamp(file, "created") || (await fs8.stat(file)).mtime;
+  return await getGitTimestamp(file, "created") || (await fs7.stat(file)).mtime;
 }
 
 // node/modules/rss/utils.ts
@@ -1025,7 +1000,7 @@ async function build(options) {
   const siteConfig = config.siteConfig;
   const lang = siteConfig.lang || "en";
   if (!siteConfig.url || siteConfig.url === "/") {
-    consola10.error("You must set `url` (like `https://example.com`) in `site.config.ts` to generate rss.");
+    consola9.error("You must set `url` (like `https://example.com`) in `site.config.ts` to generate rss.");
     return;
   }
   const siteUrl = siteConfig.url;
@@ -1128,9 +1103,9 @@ async function getPosts(params, options) {
 async function writeFeed(feedOptions, posts, options, feedNameMap) {
   const feed = new Feed(feedOptions);
   posts.forEach((item) => feed.addItem(item));
-  await fs9.ensureDir(dirname3(`./dist/${feedNameMap.atom}`));
-  const path18 = resolve5(options.userRoot, "./dist");
-  const publicFolder = resolve5(options.userRoot, "public");
+  await fs8.ensureDir(dirname3(`./dist/${feedNameMap.atom}`));
+  const path18 = resolve4(options.userRoot, "./dist");
+  const publicFolder = resolve4(options.userRoot, "public");
   const { config } = options;
   const siteConfig = config.siteConfig;
   const now = dayjs().format("YYYY-MM-DD HH:mm:ss zzz");
@@ -1149,24 +1124,24 @@ async function writeFeed(feedOptions, posts, options, feedNameMap) {
       data = feed.atom1();
     else if (type === "json")
       data = feed.json1();
-    await fs9.writeFile(distFeedPath, data, "utf-8");
-    consola10.debug(`[${colors8.cyan(type)}] dist: ${colors8.dim(distFeedPath)}`);
+    await fs8.writeFile(distFeedPath, data, "utf-8");
+    consola9.debug(`[${colors8.cyan(type)}] dist: ${colors8.dim(distFeedPath)}`);
     tableData.push([colors8.cyan(type), colors8.yellow("dist"), colors8.dim(distFeedPath)]);
-    const publicFeedPath = resolve5(publicFolder, feedNameMap[type]);
+    const publicFeedPath = resolve4(publicFolder, feedNameMap[type]);
     const publicRelativeFile = join("public", feedNameMap[type]);
-    await fs9.writeFile(publicFeedPath, data, "utf-8");
-    consola10.debug(`[${colors8.cyan(type)}] public: ${colors8.dim(publicFeedPath)}`);
+    await fs8.writeFile(publicFeedPath, data, "utf-8");
+    consola9.debug(`[${colors8.cyan(type)}] public: ${colors8.dim(publicFeedPath)}`);
     tableData.push(["", colors8.green("public"), colors8.dim(publicFeedPath)]);
     try {
-      const gitignorePath = resolve5(options.userRoot, ".gitignore");
-      const gitignore = await fs9.readFile(gitignorePath, "utf-8");
+      const gitignorePath = resolve4(options.userRoot, ".gitignore");
+      const gitignore = await fs8.readFile(gitignorePath, "utf-8");
       const ignorePath = publicRelativeFile.replace(/\\/g, "/");
       if (!gitignore.includes(ignorePath)) {
-        await fs9.appendFile(gitignorePath, `
+        await fs8.appendFile(gitignorePath, `
 # valaxy rss
 ${ignorePath}
 `);
-        consola10.success(`Add ${colors8.dim(ignorePath)} to ${colors8.dim(".gitignore")}`);
+        consola9.success(`Add ${colors8.dim(ignorePath)} to ${colors8.dim(".gitignore")}`);
       }
     } catch {
     }
@@ -1217,15 +1192,74 @@ var rssModule = defineValaxyModule({
 // node/cli/build.ts
 import path14 from "path";
 import process9 from "process";
-import { consola as consola16 } from "consola";
+import { consola as consola15 } from "consola";
 import { colors as colors15 } from "consola/utils";
 import { mergeConfig as mergeConfig4 } from "vite";
 
+// node/app/index.ts
+import { createHooks } from "hookable";
+
+// node/app/state.ts
+var StateManager = class {
+  /**
+   * @zh 文章 ID 映射
+   */
+  idMap = /* @__PURE__ */ new Map();
+};
+
+// node/app/class.ts
+var Valaxy = class {
+  /**
+   * version
+   */
+  static version = version;
+  /**
+   * file state
+   */
+  static state = new StateManager();
+  constructor() {
+  }
+};
+
+// node/app/index.ts
+var buildHooks = [
+  "build:before",
+  "build:after"
+];
+function createValaxyNode(options) {
+  const hooks = createHooks();
+  if (typeof options.config.hooks === "object") {
+    Object.keys(options.config.hooks).forEach((name) => {
+      const hookName = name;
+      const hook = options.config.hooks[hookName];
+      if (typeof hook !== "function")
+        return;
+      if (buildHooks.includes(hookName)) {
+        if (options.mode === "build")
+          hooks.hook(hookName, hook);
+      } else {
+        hooks.hook(hookName, hook);
+      }
+    });
+  }
+  const valaxyNode = {
+    version,
+    hooks,
+    hook: hooks.hook,
+    options
+  };
+  options.addons.forEach((addon) => {
+    if (typeof addon.setup === "function")
+      addon.setup(valaxyNode);
+  });
+  return valaxyNode;
+}
+
 // node/build.ts
-import { join as join8, resolve as resolve13 } from "path";
-import { consola as consola14 } from "consola";
+import { join as join8, resolve as resolve12 } from "path";
+import { consola as consola13 } from "consola";
 import { colors as colors12 } from "consola/utils";
-import fs22 from "fs-extra";
+import fs21 from "fs-extra";
 import { mergeConfig as mergeViteConfig2, build as viteBuild } from "vite";
 import generateSitemap from "vite-ssg-sitemap";
 import { build as viteSsgBuild } from "vite-ssg/node";
@@ -1233,21 +1267,21 @@ import { build as viteSsgBuild } from "vite-ssg/node";
 // node/plugins/preset.ts
 import VueI18n from "@intlify/unplugin-vue-i18n/vite";
 import UnheadVite from "@unhead/addons/vite";
-import { consola as consola13 } from "consola";
-import { resolve as resolve12 } from "pathe";
+import { consola as consola12 } from "consola";
+import { resolve as resolve11 } from "pathe";
 import Components from "unplugin-vue-components/vite";
 import Layouts from "vite-plugin-vue-layouts";
 import { groupIconVitePlugin } from "vitepress-plugin-group-icons";
 
 // node/plugins/extendConfig.ts
-import { dirname as dirname4, join as join3, resolve as resolve6 } from "path";
+import { dirname as dirname4, join as join3, resolve as resolve5 } from "path";
 import { uniq as uniq3 } from "@antfu/utils";
 import { mergeConfig as mergeConfig2, searchForWorkspaceRoot } from "vite";
 
 // node/common.ts
 import { join as join2 } from "path";
 import { uniq as uniq2 } from "@antfu/utils";
-import fs10 from "fs-extra";
+import fs9 from "fs-extra";
 import { loadConfigFromFile as loadConfigFromFile2, mergeConfig } from "vite";
 async function mergeViteConfigs({ userRoot: userRoot2, themeRoot }, command) {
   const configEnv = {
@@ -1257,7 +1291,7 @@ async function mergeViteConfigs({ userRoot: userRoot2, themeRoot }, command) {
   let resolvedConfig = {};
   const files = uniq2([themeRoot, userRoot2]).map((i) => join2(i, "vite.config.ts"));
   const loadViteConfigPromiseArr = files.map(async (file) => {
-    if (!await fs10.exists(file))
+    if (!await fs9.exists(file))
       return;
     return loadConfigFromFile2(configEnv, file);
   });
@@ -1305,9 +1339,9 @@ async function getIndexHtml({ clientRoot, themeRoot, userRoot: userRoot2, config
   }
   for (const root of roots) {
     const path18 = join2(root, "index.html");
-    if (!fs10.existsSync(path18))
+    if (!fs9.existsSync(path18))
       continue;
-    const indexHtml = await fs10.readFile(path18, "utf-8");
+    const indexHtml = await fs9.readFile(path18, "utf-8");
     head += `
 ${(indexHtml.match(/<head>([\s\S]*?)<\/head>/i)?.[1] || "").trim()}`;
     body += `
@@ -1398,7 +1432,7 @@ function createConfigPlugin(options) {
         },
         optimizeDeps: {
           // do not entry node file
-          entries: [resolve6(options.clientRoot, "main.ts")],
+          entries: [resolve5(options.clientRoot, "main.ts")],
           // must need it
           include: includedDeps,
           exclude: EXCLUDE
@@ -1445,14 +1479,14 @@ async function getAlias(options) {
     { find: /^#valaxy\/(.*)/, replacement: "/@valaxyjs/$1" },
     { find: "~/", replacement: `${toAtFS(options.userRoot)}/` },
     { find: "valaxy/client/", replacement: `${toAtFS(options.clientRoot)}/` },
-    { find: "valaxy/package.json", replacement: toAtFS(resolve6(options.clientRoot, "../package.json")) },
-    { find: /^valaxy$/, replacement: toAtFS(resolve6(options.clientRoot, "index.ts")) },
+    { find: "valaxy/package.json", replacement: toAtFS(resolve5(options.clientRoot, "../package.json")) },
+    { find: /^valaxy$/, replacement: toAtFS(resolve5(options.clientRoot, "index.ts")) },
     { find: "@valaxyjs/client/", replacement: `${toAtFS(options.clientRoot)}/` },
     // import theme
     { find: "virtual:valaxy-theme", replacement: `${toAtFS(options.themeRoot)}/client/index.ts` },
-    { find: `valaxy-theme-${options.theme}/client`, replacement: `${toAtFS(resolve6(options.themeRoot))}/client/index.ts` },
-    { find: `valaxy-theme-${options.theme}/`, replacement: `${toAtFS(resolve6(options.themeRoot))}/` },
-    { find: `valaxy-theme-${options.theme}`, replacement: `${toAtFS(resolve6(options.themeRoot))}/client/index.ts` }
+    { find: `valaxy-theme-${options.theme}/client`, replacement: `${toAtFS(resolve5(options.themeRoot))}/client/index.ts` },
+    { find: `valaxy-theme-${options.theme}/`, replacement: `${toAtFS(resolve5(options.themeRoot))}/` },
+    { find: `valaxy-theme-${options.theme}`, replacement: `${toAtFS(resolve5(options.themeRoot))}/client/index.ts` }
   ];
   if (options.config.vue?.browserTemplateCompilation) {
     alias.push(
@@ -1462,20 +1496,20 @@ async function getAlias(options) {
   options.addons.forEach((addon) => {
     alias.push({
       find: `${addon.name}/client/`,
-      replacement: `${toAtFS(`${resolve6(addon.root)}`)}/client/`
+      replacement: `${toAtFS(`${resolve5(addon.root)}`)}/client/`
     });
     alias.push({
       find: `${addon.name}/App.vue`,
-      replacement: `${toAtFS(resolve6(addon.root))}/App.vue`
+      replacement: `${toAtFS(resolve5(addon.root))}/App.vue`
     });
     alias.push({
       find: addon.name,
-      replacement: `${toAtFS(resolve6(addon.root))}/client/index.ts`
+      replacement: `${toAtFS(resolve5(addon.root))}/client/index.ts`
     });
   });
   alias.push({
     find: /^valaxy-addon-(.*)$/,
-    replacement: toAtFS(resolve6(options.clientRoot, "./addons/index.ts"))
+    replacement: toAtFS(resolve5(options.clientRoot, "./addons/index.ts"))
   });
   return alias;
 }
@@ -2061,7 +2095,7 @@ function preWrapperPlugin(md3, options) {
     const lang = extractLang(token.info);
     const rawCode = fence(...args);
     const codeHeightLimitClass = getCodeHeightLimitStyle(options, env);
-    return `<div class="language-${lang}${active}${codeHeightLimitClass}"><button title="${options.codeCopyButtonTitle || "Copy code"}" class="copy"></button><span class="lang">${lang}</span>${rawCode}<button class="collapse"></button></div>`;
+    return `<div class="language-${lang}${active}${codeHeightLimitClass}"><button title="${options.codeCopyButtonTitle || "Copy code"}" class="copy"></button><span class="lang">${lang}</span>${rawCode}<button class="code-block-unfold-btn"></button></div>`;
   };
 }
 
@@ -2412,7 +2446,7 @@ function lineNumberPlugin(md3, enable = false) {
 }
 
 // node/plugins/markdown/plugins/markdown-it/snippet.ts
-import fs11 from "fs-extra";
+import fs10 from "fs-extra";
 import path5 from "pathe";
 var rawPathRegexp = /^(.+?(?:\.([a-z0-9]+))?)(#[\w-]+)?(?: ?\{(\d+(?:[,-]\d+)*)? ?(\S+)?\})? ?(?:\[(.+)\])?$/;
 function rawPathToToken(rawPath) {
@@ -2515,13 +2549,13 @@ function snippetPlugin(md3, srcDir) {
       return fence(...args);
     if (includes)
       includes.push(src);
-    const isAFile = fs11.statSync(src).isFile();
-    if (!fs11.existsSync(src) || !isAFile) {
+    const isAFile = fs10.statSync(src).isFile();
+    if (!fs10.existsSync(src) || !isAFile) {
       token.content = isAFile ? `Code snippet path not found: ${src}` : `Invalid code snippet option`;
       token.info = "";
       return fence(...args);
     }
-    let content = fs11.readFileSync(src, "utf8");
+    let content = fs10.readFileSync(src, "utf8");
     if (regionName) {
       const lines = content.split(/\r?\n/);
       const region = findRegion(lines, regionName);
@@ -2644,28 +2678,6 @@ async function setupMarkdownPlugins(md3, options, base = "/") {
 // node/plugins/markdown/transform/index.ts
 import Markdown from "unplugin-vue-markdown/vite";
 
-// node/app/state.ts
-var StateManager = class {
-  /**
-   * @zh 文章 ID 映射
-   */
-  idMap = /* @__PURE__ */ new Map();
-};
-
-// node/app/class.ts
-var Valaxy = class {
-  /**
-   * version
-   */
-  static version = version;
-  /**
-   * file state
-   */
-  static state = new StateManager();
-  constructor() {
-  }
-};
-
 // node/plugins/markdown/transform/include.ts
 import { slash as slash2 } from "@antfu/utils";
 import path7 from "pathe";
@@ -2684,7 +2696,7 @@ function treatAsHtml(filename) {
 
 // node/plugins/markdown/utils/processInclude.ts
 import path6 from "path";
-import fs12 from "fs-extra";
+import fs11 from "fs-extra";
 function processIncludes(srcDir, src, file) {
   const includesRE = /<!--\s*@include:\s*(.*?)\s*-->/g;
   const rangeRE = /\{(\d*),(\d*)\}$/;
@@ -2696,7 +2708,7 @@ function processIncludes(srcDir, src, file) {
     const atPresent = m1[0] === "@";
     try {
       const includePath = atPresent ? path6.join(srcDir, m1.slice(m1[1] === "/" ? 2 : 1)) : path6.join(path6.dirname(file), m1);
-      let content = fs12.readFileSync(includePath, "utf-8");
+      let content = fs11.readFileSync(includePath, "utf-8");
       if (range) {
         const [, startLine, endLine] = range;
         const lines = content.split(/\r?\n/);
@@ -2847,10 +2859,10 @@ function createFixPlugins(options) {
 
 // node/plugins/setupClient.ts
 import { existsSync } from "fs";
-import { join as join4, resolve as resolve7 } from "path";
+import { join as join4, resolve as resolve6 } from "path";
 import { slash as slash3, uniq as uniq4 } from "@antfu/utils";
 function createClientSetupPlugin({ clientRoot, themeRoot, userRoot: userRoot2 }) {
-  const setupEntry = slash3(resolve7(clientRoot, "setup"));
+  const setupEntry = slash3(resolve6(clientRoot, "setup"));
   return {
     name: "valaxy:setup",
     enforce: "pre",
@@ -2889,25 +2901,25 @@ function createClientSetupPlugin({ clientRoot, themeRoot, userRoot: userRoot2 })
 }
 
 // node/plugins/unocss.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve8 } from "path";
 import defu3 from "defu";
-import fs14 from "fs-extra";
-import { createJiti as createJiti3 } from "jiti";
+import fs13 from "fs-extra";
+import { createJiti as createJiti2 } from "jiti";
 import {
   presetAttributify,
   presetIcons,
   presetTypography,
-  presetUno,
+  presetWind4,
   transformerDirectives,
   transformerVariantGroup
 } from "unocss";
 
 // node/plugins/setupNode.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve7 } from "path";
 import { isObject } from "@antfu/utils";
-import fs13 from "fs-extra";
-import { createJiti as createJiti2 } from "jiti";
-var jiti2 = createJiti2(import.meta.url);
+import fs12 from "fs-extra";
+import { createJiti } from "jiti";
+var jiti = createJiti(import.meta.url);
 function deepMerge(a, b, rootPath = "") {
   a = { ...a };
   Object.keys(b).forEach((key) => {
@@ -2923,9 +2935,9 @@ function deepMerge(a, b, rootPath = "") {
 async function loadSetups(roots, name, arg, initial, merge = true) {
   let returns = initial;
   for (const root of roots) {
-    const path18 = resolve8(root, "setup", name);
-    if (fs13.existsSync(path18)) {
-      const setup = await jiti2.import(path18, { default: true });
+    const path18 = resolve7(root, "setup", name);
+    if (fs12.existsSync(path18)) {
+      const setup = await jiti.import(path18, { default: true });
       const result = await setup(arg);
       if (result !== null) {
         returns = merge ? deepMerge(returns, result) : result;
@@ -2936,7 +2948,7 @@ async function loadSetups(roots, name, arg, initial, merge = true) {
 }
 
 // node/plugins/unocss.ts
-var jiti3 = createJiti3(import.meta.url);
+var jiti2 = createJiti2(import.meta.url);
 async function createSafelist(options) {
   const { config } = options;
   const safeIcons = [
@@ -2985,7 +2997,7 @@ async function createUnocssConfig(options) {
       ["va-card", "shadow hover:shadow-lg bg-$va-c-bg-light"]
     ],
     presets: [
-      presetUno(pluginOptions.unocssPresets?.uno),
+      presetWind4(pluginOptions.unocssPresets?.wind4),
       presetAttributify(pluginOptions.unocssPresets?.attributify),
       presetIcons({
         scale: 1.2,
@@ -3035,14 +3047,14 @@ async function createUnocssPlugin(options) {
   const dirs = [themeRoot, clientRoot];
   dirs.forEach(
     (dir) => unoConfigFiles.forEach(
-      (file) => configFiles.push(resolve9(dir, file))
+      (file) => configFiles.push(resolve8(dir, file))
     )
   );
   let config = {};
   const configDeps = [];
   for (const configFile of configFiles) {
-    if (await fs14.exists(configFile)) {
-      const uConfig = await jiti3.import(configFile, { default: true });
+    if (await fs13.exists(configFile)) {
+      const uConfig = await jiti2.import(configFile, { default: true });
       config = defu3(config, uConfig);
       configDeps.push(configFile);
     }
@@ -3056,19 +3068,19 @@ async function createUnocssPlugin(options) {
 }
 
 // node/plugins/valaxy/index.ts
-import { consola as consola12 } from "consola";
+import { consola as consola11 } from "consola";
 import { colors as colors11 } from "consola/utils";
-import fs20 from "fs-extra";
-import { join as join7, relative, resolve as resolve10 } from "pathe";
+import fs19 from "fs-extra";
+import { join as join7, relative, resolve as resolve9 } from "pathe";
 
 // node/virtual/addons.ts
-import fs15 from "fs-extra";
+import fs14 from "fs-extra";
 import pascalCase from "pascalcase";
 import { join as join5 } from "pathe";
 var templateAddons = {
   id: "/@valaxyjs/addons",
   async getContent(options) {
-    const globalAddonComponents = options.addons.filter((v) => v.global).filter((v) => fs15.existsSync(join5(v.root, "./App.vue")));
+    const globalAddonComponents = options.addons.filter((v) => v.global).filter((v) => fs14.existsSync(join5(v.root, "./App.vue")));
     const spliceImportName = (str) => `Addon${pascalCase(str)}App`;
     const imports = globalAddonComponents.map((addon) => `import ${spliceImportName(addon.name)} from "${addon.name}/App.vue"`).join("\n");
     const components = globalAddonComponents.map((addon) => `{ component: ${spliceImportName(addon.name)}, props: ${JSON.stringify(addon.props)} }`).join(",");
@@ -3079,17 +3091,17 @@ export default [${components}]`;
 
 // node/virtual/blogs.ts
 import path8 from "path";
-import fs16 from "fs-extra";
+import fs15 from "fs-extra";
 function createBlogTemplate(name) {
   return {
     id: `/@valaxyjs/blog/${name}s`,
     async getContent({ userRoot: userRoot2 }) {
       const root = path8.resolve(userRoot2, "pages", "collections");
-      if (!await fs16.pathExists(root)) {
+      if (!await fs15.pathExists(root)) {
         return `export default []`;
       }
-      const isDir = (file) => fs16.statSync(path8.join(root, file)).isDirectory();
-      const files = fs16.readdirSync(root).filter((file) => isDir(file)).map((file) => path8.join(root, file, "index.ts"));
+      const isDir = (file) => fs15.statSync(path8.join(root, file)).isDirectory();
+      const files = fs15.readdirSync(root).filter((file) => isDir(file)).map((file) => path8.join(root, file, "index.ts"));
       const imports = [];
       const getImportedName = (idx) => `__valaxy_${name}_${idx + 1}`;
       files.forEach((file, idx) => {
@@ -3125,7 +3137,7 @@ var templateConfig = {
 };
 
 // node/virtual/locales.ts
-import fs17 from "fs-extra";
+import fs16 from "fs-extra";
 var templateLocales = {
   id: "/@valaxyjs/locales",
   async getContent({ roots, config }) {
@@ -3145,7 +3157,7 @@ var templateLocales = {
     roots.forEach((root, i) => {
       languages.forEach((lang) => {
         const langYml = `${root}/locales/${lang}.yml`;
-        if (fs17.existsSync(langYml) && fs17.readFileSync(langYml, "utf-8")) {
+        if (fs16.existsSync(langYml) && fs16.readFileSync(langYml, "utf-8")) {
           const varName = lang.replace("-", "") + i;
           imports.unshift(`import ${varName} from "${toAtFS(langYml)}"`);
           imports.push(`messages['${lang}'] = replaceArrMerge(${varName}, messages['${lang}'])`);
@@ -3203,41 +3215,6 @@ import _debug2 from "debug";
 import { LRUCache } from "lru-cache";
 import path12 from "pathe";
 
-// node/app/index.ts
-import { createHooks } from "hookable";
-var buildHooks = [
-  "build:before",
-  "build:after"
-];
-function createValaxyNode(options) {
-  const hooks = createHooks();
-  if (typeof options.config.hooks === "object") {
-    Object.keys(options.config.hooks).forEach((name) => {
-      const hookName = name;
-      const hook = options.config.hooks[hookName];
-      if (typeof hook !== "function")
-        return;
-      if (buildHooks.includes(hookName)) {
-        if (options.mode === "build")
-          hooks.hook(hookName, hook);
-      } else {
-        hooks.hook(hookName, hook);
-      }
-    });
-  }
-  const valaxyNode = {
-    version,
-    hooks,
-    hook: hooks.hook,
-    options
-  };
-  options.addons.forEach((addon) => {
-    if (typeof addon.setup === "function")
-      addon.setup(valaxyNode);
-  });
-  return valaxyNode;
-}
-
 // node/plugins/markdown/transform/code-block.ts
 function handleCodeHeightLimit(mainContentMd, options, codeHeightLimit) {
   if (typeof codeHeightLimit !== "number" || codeHeightLimit <= 0)
@@ -3260,7 +3237,7 @@ function createTransformCodeBlock(options) {
 
 // node/plugins/markdown/transform/dead-links.ts
 import { slash as slash4 } from "@antfu/utils";
-import fs18 from "fs-extra";
+import fs17 from "fs-extra";
 import path9 from "pathe";
 function createScanDeadLinks(options) {
   const srcDir = path9.resolve(options.userRoot, "pages");
@@ -3307,7 +3284,7 @@ function createScanDeadLinks(options) {
           )
           // /index => /
         ).replace(/\/index$/, "");
-        if (!options.pages.includes(resolved) && !fs18.existsSync(path9.resolve(dir, publicDir, `${resolved}.html`)) && !shouldIgnoreDeadLink(url)) {
+        if (!options.pages.includes(resolved) && !fs17.existsSync(path9.resolve(dir, publicDir, `${resolved}.html`)) && !shouldIgnoreDeadLink(url)) {
           recordDeadLink(url);
         }
       }
@@ -3454,11 +3431,11 @@ function transformFootnoteTooltip(code, _id) {
 }
 
 // node/plugins/markdown/transform/hexo.ts
-import { consola as consola11 } from "consola";
+import { consola as consola10 } from "consola";
 import { colors as colors10 } from "consola/utils";
 function transformHexoTags(code, id) {
   if (code.includes("{%") && code.includes("%}")) {
-    consola11.error(
+    consola10.error(
       `${`${id}
 `}        Please ${colors10.red("remove")} ${colors10.cyan("{% %}")}, because it conflicts with ${colors10.yellow("markdown-it-attrs")}.`
     );
@@ -3470,7 +3447,7 @@ function transformHexoTags(code, id) {
 
 // node/plugins/markdown/transform/markdown.ts
 import path10 from "path";
-import fs19 from "fs-extra";
+import fs18 from "fs-extra";
 function genProvideCode(name, data) {
   return [
     `const $${name} = ${transformObject(data)}`,
@@ -3502,7 +3479,7 @@ function injectPageDataCode(pageData) {
 }
 function createTransformMarkdown(options) {
   const loaderVuePath = path10.resolve(options.clientRoot, "templates", "loader.vue");
-  const loaderVue = fs19.readFileSync(loaderVuePath, "utf-8");
+  const loaderVue = fs18.readFileSync(loaderVuePath, "utf-8");
   return (code, id, pageData) => {
     const isDev = options.mode === "dev";
     if (!isDev) {
@@ -3654,7 +3631,7 @@ async function createMarkdownToVueRenderFn(options, _viteConfig) {
 var nullVue = 'import { defineComponent } from "vue"; export default defineComponent({ render: () => null });';
 function generateAppVue(root) {
   const appVue = join7(root, "App.vue");
-  if (!fs20.existsSync(appVue))
+  if (!fs19.existsSync(appVue))
     return nullVue;
   const scripts = [
     `import AppVue from "${toAtFS(appVue)}"`,
@@ -3726,8 +3703,8 @@ async function createValaxyPlugin(options, serverOptions = {}) {
           const { code: newCode, deadLinks, includes } = await markdownToVue(code, id);
           if (deadLinks.length) {
             hasDeadLinks = true;
-            consola12.error(`Dead links found in ${id}`);
-            consola12.error(deadLinks);
+            consola11.error(`Dead links found in ${id}`);
+            consola11.error(deadLinks);
           }
           if (includes.length) {
             includes.forEach((i) => {
@@ -3774,7 +3751,7 @@ async function createValaxyPlugin(options, serverOptions = {}) {
           valaxyConfig.themeConfig = themeConfig;
           return reloadConfigAndEntries(valaxyConfig);
         }
-        if (file === resolve10(options.themeRoot, "valaxy.config.ts")) {
+        if (file === resolve9(options.themeRoot, "valaxy.config.ts")) {
           const themeValaxyConfig = await resolveThemeValaxyConfig(options);
           const valaxyConfig2 = mergeValaxyConfig(options.config, themeValaxyConfig);
           const { config } = await processValaxyOptions(options, valaxyConfig2);
@@ -3813,11 +3790,11 @@ async function createValaxyPlugin(options, serverOptions = {}) {
 }
 
 // node/plugins/vueRouter.ts
-import fs21 from "fs-extra";
+import fs20 from "fs-extra";
 import matter3 from "gray-matter";
 import { convert } from "html-to-text";
 import { MarkdownItAsync } from "markdown-it-async";
-import { resolve as resolve11 } from "pathe";
+import { resolve as resolve10 } from "pathe";
 import VueRouter from "unplugin-vue-router/vite";
 
 // node/plugins/presets/statistics.ts
@@ -3894,7 +3871,7 @@ async function createRouterPlugin(valaxyApp) {
   return VueRouter({
     extensions: [".vue", ".md"],
     routesFolder: roots.map((root) => `${root}/pages`),
-    dts: resolve11(options.tempDir, "typed-router.d.ts"),
+    dts: resolve10(options.tempDir, "typed-router.d.ts"),
     ...valaxyConfig.router,
     /**
      * @experimental See https://github.com/posva/unplugin-vue-router/issues/43
@@ -3933,7 +3910,7 @@ async function createRouterPlugin(valaxyApp) {
       }
       const path18 = route.components.get("default") || "";
       if (path18.endsWith(".md")) {
-        const md3 = fs21.readFileSync(path18, "utf-8");
+        const md3 = fs20.readFileSync(path18, "utf-8");
         const { data, excerpt, content } = matter3(md3, matterOptions);
         const mdFm = data;
         const lastUpdated = options.config.siteConfig.lastUpdated;
@@ -3943,10 +3920,10 @@ async function createRouterPlugin(valaxyApp) {
           delete mdFm.photos;
         }
         if (!mdFm.date)
-          mdFm.date = (await fs21.stat(path18)).mtime;
+          mdFm.date = (await fs20.stat(path18)).mtime;
         if (lastUpdated) {
           if (!mdFm.updated)
-            mdFm.updated = (await fs21.stat(path18)).ctime;
+            mdFm.updated = (await fs20.stat(path18)).ctime;
         }
         if (mdFm.from) {
           if (Array.isArray(mdFm.from)) {
@@ -4075,7 +4052,7 @@ async function ViteValaxyPlugins(valaxyApp, serverOptions = {}) {
        * latter override former
        */
       dirs: componentsDirs,
-      dts: resolve12(options.tempDir, "components.d.ts"),
+      dts: resolve11(options.tempDir, "components.d.ts"),
       ...valaxyConfig.components
     }),
     // https://github.com/antfu/unocss
@@ -4103,10 +4080,10 @@ async function ViteValaxyPlugins(valaxyApp, serverOptions = {}) {
       );
     } catch (e) {
       console.error(e);
-      consola13.error("Failed to load rollup-plugin-visualizer");
-      consola13.error("Please install `rollup-plugin-visualizer` to enable the feature");
+      consola12.error("Failed to load rollup-plugin-visualizer");
+      consola12.error("Please install `rollup-plugin-visualizer` to enable the feature");
       console.log();
-      consola13.info("pnpm add -D rollup-plugin-visualizer");
+      consola12.info("pnpm add -D rollup-plugin-visualizer");
       console.log();
     }
   }
@@ -4219,7 +4196,7 @@ async function ssgBuild(valaxyApp, viteConfig = {}) {
       const newPaths = paths;
       const posts = paths.filter((path18) => path18.startsWith("/posts/"));
       const pageNumber = Math.ceil(posts.length / options.config.siteConfig.pageSize);
-      consola14.info(`Generate ${colors12.yellow(pageNumber)} pages for pagination.`);
+      consola13.info(`Generate ${colors12.yellow(pageNumber)} pages for pagination.`);
       for (let i = 1; i <= pageNumber; i++)
         newPaths.push(`/page/${i}`);
       if (!options.config.vite?.ssgOptions?.includeAllRoutes)
@@ -4233,28 +4210,28 @@ async function ssgBuild(valaxyApp, viteConfig = {}) {
 }
 async function postProcessForSSG(options) {
   const { userRoot: userRoot2 } = options;
-  const indexPath = resolve13(userRoot2, "dist/index.html");
-  if (fs22.existsSync(indexPath)) {
-    consola14.info("post process for ssg...");
-    const indexFile = await fs22.readFile(indexPath, "utf-8");
+  const indexPath = resolve12(userRoot2, "dist/index.html");
+  if (fs21.existsSync(indexPath)) {
+    consola13.info("post process for ssg...");
+    const indexFile = await fs21.readFile(indexPath, "utf-8");
     const htmlTag = "</html>";
     if (!indexFile.endsWith(htmlTag)) {
-      consola14.warn("fix incomplete index.html...");
+      consola13.warn("fix incomplete index.html...");
       const htmlTagStart = indexFile.lastIndexOf(htmlTag);
-      await fs22.writeFile(indexPath, indexFile.slice(0, htmlTagStart + htmlTag.length), "utf-8");
+      await fs21.writeFile(indexPath, indexFile.slice(0, htmlTagStart + htmlTag.length), "utf-8");
     }
   }
   if (!options.config.siteConfig.redirects?.useVueRouter)
     await generateClientRedirects(options);
 }
 async function generateClientRedirects(options) {
-  consola14.info("generate client redirects...");
-  const outputPath = resolve13(options.userRoot, "dist");
+  consola13.info("generate client redirects...");
+  const outputPath = resolve12(options.userRoot, "dist");
   const redirectRules = collectRedirects(options.redirects);
   const task = redirectRules.map(async (rule) => {
     const fromPath = join8(outputPath, `${rule.from}.html`);
     const toPath = join8(outputPath, `${rule.to}.html`);
-    const routeExist = await fs22.pathExists(toPath);
+    const routeExist = await fs21.pathExists(toPath);
     if (!routeExist)
       throw new Error(`the route of '${rule.to}' not exists`);
     await writeRedirectFiles(rule.to, fromPath);
@@ -4262,6 +4239,21 @@ async function generateClientRedirects(options) {
   await Promise.all(task);
 }
 
+// node/cli/utils/cli.ts
+import os from "os";
+import path13 from "path";
+import process8 from "process";
+import { consola as consola14 } from "consola";
+import { colors as colors14 } from "consola/utils";
+import ora4 from "ora";
+import { mergeConfig as mergeConfig3 } from "vite";
+
+// node/env.ts
+var GLOBAL_STATE = {
+  valaxyApp: void 0,
+  server: void 0
+};
+
 // node/server.ts
 import process7 from "process";
 import { colors as colors13 } from "consola/utils";
@@ -4295,21 +4287,6 @@ async function createServer(valaxyApp, viteConfig = {}, serverOptions = {}) {
   return server;
 }
 
-// node/cli/utils/cli.ts
-import os from "os";
-import path13 from "path";
-import process8 from "process";
-import { consola as consola15 } from "consola";
-import { colors as colors14 } from "consola/utils";
-import ora4 from "ora";
-import { mergeConfig as mergeConfig3 } from "vite";
-
-// node/env.ts
-var GLOBAL_STATE = {
-  valaxyApp: void 0,
-  server: void 0
-};
-
 // node/cli/utils/cli.ts
 function printInfo(options, port, remote) {
   const themeVersion = colors14.blue(`v${options.config.themeConfig?.pkg?.version}`) || "unknown";
@@ -4371,7 +4348,7 @@ async function initServer(valaxyApp, viteConfig) {
     serverSpinner.succeed(`${valaxyPrefix} ${colors14.green("server ready.")}`);
     return server;
   } catch (e) {
-    consola15.error("failed to start server. error:\n");
+    consola14.error("failed to start server. error:\n");
     console.error(e);
     process8.exit(1);
   }
@@ -4379,7 +4356,7 @@ async function initServer(valaxyApp, viteConfig) {
 if (import.meta.hot) {
   await import.meta.hot.data.stopping;
   let reload = async () => {
-    consola15.info("HMR: Stop Server");
+    consola14.info("HMR: Stop Server");
     await GLOBAL_STATE.server?.close();
   };
   import.meta.hot.on("vite:beforeFullReload", () => {
@@ -4426,19 +4403,19 @@ async function execBuild({ ssg, root, output, log }) {
   );
   await callHookWithLog("config:init", valaxyApp);
   await callHookWithLog("build:before", valaxyApp);
-  consola16.box("\u{1F320} Start building...");
+  consola15.box("\u{1F320} Start building...");
   try {
     if (ssg) {
-      consola16.info(`use ${colors15.yellow("vite-ssg")} to do ssg build...`);
+      consola15.info(`use ${colors15.yellow("vite-ssg")} to do ssg build...`);
       try {
         await ssgBuild(valaxyApp, viteConfig);
         await postProcessForSSG(options);
       } catch (e) {
-        consola16.error("[vite-ssg] An internal error occurred.");
+        consola15.error("[vite-ssg] An internal error occurred.");
         console.log(e);
       }
     } else {
-      consola16.info("use vite do spa build...");
+      consola15.info("use vite do spa build...");
       await build2(valaxyApp, viteConfig);
     }
   } catch (e) {
@@ -4478,35 +4455,35 @@ function registerBuildCommand(cli2) {
 // node/cli/clean.ts
 import path15 from "path";
 import process10 from "process";
-import { consola as consola17 } from "consola";
-import fs23 from "fs-extra";
+import { consola as consola16 } from "consola";
+import fs22 from "fs-extra";
 async function cleanDist() {
   const distDir = path15.join(process10.cwd(), "dist");
   const cacheDir = path15.join(process10.cwd(), ".valaxy");
-  consola17.box("\u{1F9F9} Starting clean...");
-  if (await fs23.exists(distDir)) {
-    consola17.info("dist directory exists, removing...");
+  consola16.box("\u{1F9F9} Starting clean...");
+  if (await fs22.exists(distDir)) {
+    consola16.info("dist directory exists, removing...");
     try {
-      await fs23.rm(distDir, { recursive: true, force: true });
-      consola17.success("dist directory has been successfully removed.");
+      await fs22.rm(distDir, { recursive: true, force: true });
+      consola16.success("dist directory has been successfully removed.");
     } catch (error) {
-      consola17.error("Failed to remove dist directory.");
-      consola17.error(error);
+      consola16.error("Failed to remove dist directory.");
+      consola16.error(error);
     }
   } else {
-    consola17.info("No dist directory found, nothing to clean.");
+    consola16.info("No dist directory found, nothing to clean.");
   }
-  if (await fs23.exists(cacheDir)) {
-    consola17.info(".valaxy cache directory exists, removing...");
+  if (await fs22.exists(cacheDir)) {
+    consola16.info(".valaxy cache directory exists, removing...");
     try {
-      await fs23.rm(cacheDir, { recursive: true, force: true });
-      consola17.success(".valaxy cache directory has been successfully removed.");
+      await fs22.rm(cacheDir, { recursive: true, force: true });
+      consola16.success(".valaxy cache directory has been successfully removed.");
     } catch (error) {
-      consola17.error("Failed to remove .valaxy cache directory.");
-      consola17.error(error);
+      consola16.error("Failed to remove .valaxy cache directory.");
+      consola16.error(error);
     }
   } else {
-    consola17.info("No .valaxy cache directory found, nothing to clean.");
+    consola16.info("No .valaxy cache directory found, nothing to clean.");
   }
 }
 function registerCleanCommand(cli2) {
@@ -4522,15 +4499,21 @@ function registerCleanCommand(cli2) {
 }
 
 // node/cli/debug.ts
-import { consola as consola18 } from "consola";
+import os2 from "os";
+import process11 from "process";
+import { consola as consola17 } from "consola";
+import { colors as colors16 } from "consola/utils";
 function registerDebugCommand(cli2) {
   cli2.command("debug", "Debug your blog", async () => {
-    consola18.info("\u63D0\u95EE\u524D\u8BF7\u643A\u5E26\u4EE5\u4E0B\u4FE1\u606F\uFF1A");
+    console.log();
+    consola17.log("  Operating System:", colors16.green(os2.platform()));
+    consola17.log("  Node.JS Version:", colors16.green(process11.version));
+    consola17.log("  Valaxy Version:", colors16.cyan(`v${version}`));
   });
 }
 
 // node/cli/deploy.ts
-import process11 from "process";
+import process12 from "process";
 import { confirm, intro, outro, select } from "@clack/prompts";
 function registerDeployCommand(cli2) {
   cli2.command("deploy", "deploy your blog to the cloud", async () => {
@@ -4539,7 +4522,7 @@ function registerDeployCommand(cli2) {
       message: "Do you want to build your blog before deploying?"
     });
     if (shouldBuild) {
-      await execBuild({ ssg: true, root: process11.cwd(), output: "dist", log: "info" });
+      await execBuild({ ssg: true, root: process12.cwd(), output: "dist", log: "info" });
     }
     const deployType = await select({
       message: "Where do you want to deploy?",
@@ -4579,7 +4562,7 @@ function registerDeployCommand(cli2) {
 
 // node/cli/dev.ts
 import path16 from "path";
-import process13 from "process";
+import process14 from "process";
 import { mergeConfig as mergeConfig5 } from "vite";
 
 // node/utils/net.ts
@@ -4590,28 +4573,28 @@ async function findFreePort(start) {
   return await findFreePort(start + 1);
 }
 function isPortFree(port) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve14) => {
     const server = net.createServer((socket) => {
       socket.write("Echo server\r\n");
       socket.pipe(socket);
     });
     server.listen(port, "0.0.0.0");
     server.on("error", () => {
-      resolve15(false);
+      resolve14(false);
     });
     server.on("listening", () => {
       server.close();
-      resolve15(true);
+      resolve14(true);
     });
   });
 }
 
 // node/cli/utils/shortcuts.ts
 import { exec } from "child_process";
-import os2 from "os";
-import process12 from "process";
+import os3 from "os";
+import process13 from "process";
 import * as readline from "readline";
-import { colors as colors16 } from "consola/utils";
+import { colors as colors17 } from "consola/utils";
 import qrcode from "qrcode";
 var SHORTCUTS = [
   {
@@ -4636,7 +4619,7 @@ var SHORTCUTS = [
     key: "q",
     description: "qr",
     action(server) {
-      const addresses = Object.values(os2.networkInterfaces()).flat().filter((details) => details?.family === "IPv4" && !details.address.includes("127.0.0.1"));
+      const addresses = Object.values(os3.networkInterfaces()).flat().filter((details) => details?.family === "IPv4" && !details.address.includes("127.0.0.1"));
       const port = server.config.server.port;
       const remoteUrl = `http://${addresses[0]?.address || "localhost"}:${port}`;
       qrcode.toString(remoteUrl, { type: "terminal" }, (err, qrCode) => {
@@ -4650,7 +4633,7 @@ var SHORTCUTS = [
     key: "e",
     description: "edit",
     action() {
-      exec(`code "${process12.cwd()}"`, (err) => {
+      exec(`code "${process13.cwd()}"`, (err) => {
         if (err)
           console.error("Failed to open editor", err);
       });
@@ -4658,18 +4641,18 @@ var SHORTCUTS = [
   }
 ];
 function bindShortcuts(server, createDevServer) {
-  if (!server.httpServer || process12.env.CI) {
-    console.log("restart server to enable shortcuts", server.httpServer, process12.stdin.isTTY, process12.env.CI);
+  if (!server.httpServer || process13.env.CI) {
+    console.log("restart server to enable shortcuts", server.httpServer, process13.stdin.isTTY, process13.env.CI);
     return;
   }
-  process12.stdin.resume();
-  process12.stdin.setEncoding("utf8");
-  readline.emitKeypressEvents(process12.stdin);
-  if (process12.stdin.isTTY)
-    process12.stdin.setRawMode(true);
+  process13.stdin.resume();
+  process13.stdin.setEncoding("utf8");
+  readline.emitKeypressEvents(process13.stdin);
+  if (process13.stdin.isTTY)
+    process13.stdin.setRawMode(true);
   async function onKeyPress(str, key) {
     if (key.ctrl && key.name === "c") {
-      process12.exit();
+      process13.exit();
     } else {
       const shortcut = SHORTCUTS.find((shortcut2) => shortcut2.key === str);
       if (!shortcut)
@@ -4677,19 +4660,19 @@ function bindShortcuts(server, createDevServer) {
       try {
         await shortcut.action(server, createDevServer);
       } catch (error) {
-        console.error(colors16.red("Error executing shortcut:"), key, error);
+        console.error(colors17.red("Error executing shortcut:"), key, error);
       }
     }
   }
-  process12.stdin.on("keypress", onKeyPress);
+  process13.stdin.on("keypress", onKeyPress);
   server.httpServer.on("close", () => {
-    process12.stdin.off("keypress", onKeyPress);
+    process13.stdin.off("keypress", onKeyPress);
   });
 }
 
 // node/cli/dev.ts
 async function startValaxyDev({
-  root = process13.cwd(),
+  root = process14.cwd(),
   port,
   remote,
   log,
@@ -4697,7 +4680,7 @@ async function startValaxyDev({
 }) {
   setEnv();
   if (!isPagesDirExist(root))
-    process13.exit(0);
+    process14.exit(0);
   port = port || await findFreePort(4859);
   const resolvedOptions = await resolveOptions({ userRoot: root });
   setTimezone(resolvedOptions.config.siteConfig.timezone);
@@ -4765,16 +4748,16 @@ function registerDevCommand(cli2) {
 }
 
 // node/cli/utils/post.ts
-import { dirname as dirname5, join as join9, resolve as resolve14 } from "path";
-import { consola as consola19 } from "consola";
-import { colors as colors17 } from "consola/utils";
+import { dirname as dirname5, join as join9, resolve as resolve13 } from "path";
+import { consola as consola18 } from "consola";
+import { colors as colors18 } from "consola/utils";
 import dayjs2 from "dayjs";
 import { render } from "ejs";
-import fs25 from "fs-extra";
+import fs24 from "fs-extra";
 
 // node/cli/utils/constants.ts
-import process14 from "process";
-var userRoot = process14.cwd();
+import process15 from "process";
+var userRoot = process15.cwd();
 var defaultPostTemplate = `---
 layout: <%=layout%>
 title: <%=title%>
@@ -4785,13 +4768,13 @@ date: <%=date%>
 // node/cli/utils/scaffold.ts
 import { readFile as readFile2 } from "fs/promises";
 import path17 from "path";
-import fs24 from "fs-extra";
+import fs23 from "fs-extra";
 async function getTemplate(layout) {
   const { clientRoot, themeRoot } = await resolveOptions({ userRoot });
   const roots = [userRoot, themeRoot, clientRoot];
   for (const root of roots) {
     const scaffoldPath = path17.resolve(root, "scaffolds", `${layout}.md`);
-    if (await fs24.exists(scaffoldPath))
+    if (await fs23.exists(scaffoldPath))
       return readFile2(scaffoldPath, "utf-8");
   }
   return false;
@@ -4799,22 +4782,22 @@ async function getTemplate(layout) {
 
 // node/cli/utils/post.ts
 async function create(params) {
-  const pagesPath = resolve14(userRoot, params.path || "pages");
+  const pagesPath = resolve13(userRoot, params.path || "pages");
   let counter = 0;
   while (true) {
     const postFileName = `${params.title}${counter ? `-${counter}` : ""}`;
     const postFilePath = params.folder ? join9(postFileName, "index.md") : `${postFileName}.md`;
-    const targetPath = resolve14(pagesPath, "posts", postFilePath);
-    if (!await fs25.exists(targetPath)) {
-      await fs25.ensureDir(dirname5(targetPath));
+    const targetPath = resolve13(pagesPath, "posts", postFilePath);
+    if (!await fs24.exists(targetPath)) {
+      await fs24.ensureDir(dirname5(targetPath));
       const content = await genLayoutTemplate(params);
       try {
-        await fs25.writeFile(targetPath, content, "utf-8");
-        consola19.success(`[valaxy new]: successfully generated file ${colors17.magenta(targetPath)}`);
+        await fs24.writeFile(targetPath, content, "utf-8");
+        consola18.success(`[valaxy new]: successfully generated file ${colors18.magenta(targetPath)}`);
       } catch (e) {
         console.log(e);
-        consola19.error(`[valaxy new]: failed to write file ${targetPath}`);
-        consola19.warn(`You should run ${colors17.green("valaxy new")} in your valaxy project root directory.`);
+        consola18.error(`[valaxy new]: failed to write file ${targetPath}`);
+        consola18.warn(`You should run ${colors18.green("valaxy new")} in your valaxy project root directory.`);
       }
       return targetPath;
     }
@@ -4875,7 +4858,7 @@ function registerNewCommand(cli2) {
 }
 
 // node/cli/index.ts
-var cli = yargs(hideBin(process15.argv)).scriptName("valaxy").usage("$0 [args]").version(version).showHelpOnFail(false).alias("h", "help").alias("v", "version");
+var cli = yargs(hideBin(process16.argv)).scriptName("valaxy").usage("$0 [args]").version(version).showHelpOnFail(false).alias("h", "help").alias("v", "version");
 registerDevCommand(cli);
 registerBuildCommand(cli);
 registerNewCommand(cli);
@@ -4911,7 +4894,6 @@ export {
   resolveImportPath,
   mergeViteConfigs,
   getIndexHtml,
-  loadConfig,
   loadConfigFromFile,
   defaultSiteConfig,
   defineSiteConfig,
@@ -4940,6 +4922,7 @@ export {
   ssgBuild,
   postProcessForSSG,
   generateClientRedirects,
+  GLOBAL_STATE,
   getServerInfoText,
   createServer,
   startValaxyDev,