create-vuepress-theme-plume 1.0.0-rc.91

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2021 - PRESENT by pengzhanbo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# create-vuepress-theme-plume
+
+The cli for create vuepress-theme-plume's project
+
+## Usage
+
+```sh
+# npm
+npm init vuepress-theme-plume@latest
+# pnpm
+pnpm create vuepress-theme-plume@latest
+# yarn
+yarn create vuepress-theme-plume@latest
+```

package/bin/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../lib/index.js'

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/index.js

@@ -0,0 +1,506 @@
+// src/index.ts
+import cac from "cac";
+
+// src/run.ts
+import { intro, outro, spinner } from "@clack/prompts";
+import { execaCommand as execaCommand3 } from "execa";
+import colors from "picocolors";
+
+// src/prompt.ts
+import process from "node:process";
+import { createRequire } from "node:module";
+import { cancel, confirm, group, select, text } from "@clack/prompts";
+
+// src/locales/en.ts
+var en = {
+  "question.root": "Where would you want to initialize VuePress?",
+  "question.site.name": "Site Name:",
+  "question.site.description": "Site Description:",
+  "question.bundler": "Select a bundler",
+  "question.multiLanguage": "Do you want to use multiple languages?",
+  "question.defaultLanguage": "Select the default language of the site",
+  "question.useTs": "Use TypeScript?",
+  "question.injectNpmScripts": "Inject npm scripts?",
+  "question.deploy": "Deploy type:",
+  "question.git": "Initialize a git repository?",
+  "question.installDeps": "Install dependencies?",
+  "spinner.start": "\u{1F680} Creating...",
+  "spinner.stop": "\u{1F389} Create success!",
+  "spinner.git": "\u{1F4C4} Initializing git repository...",
+  "spinner.install": "\u{1F4E6} Installing dependencies...",
+  "spinner.command": "\u{1F528} Execute the following command to start:",
+  "hint.cancel": "Operation cancelled.",
+  "hint.root": "The path cannot be an absolute path, and cannot contain the parent path.",
+  "hint.root.illegal": "Project names cannot contain special characters."
+};
+
+// src/locales/zh.ts
+var zh = {
+  "question.root": "\u60A8\u60F3\u5728\u54EA\u91CC\u521D\u59CB\u5316 VuePress\uFF1F",
+  "question.site.name": "\u7AD9\u70B9\u540D\u79F0\uFF1A",
+  "question.site.description": "\u7AD9\u70B9\u63CF\u8FF0\u4FE1\u606F\uFF1A",
+  "question.bundler": "\u8BF7\u9009\u62E9\u6253\u5305\u5DE5\u5177",
+  "question.multiLanguage": "\u662F\u5426\u4F7F\u7528\u591A\u8BED\u8A00\uFF1F",
+  "question.defaultLanguage": "\u8BF7\u9009\u62E9\u7AD9\u70B9\u9ED8\u8BA4\u8BED\u8A00",
+  "question.useTs": "\u662F\u5426\u4F7F\u7528 TypeScript\uFF1F",
+  "question.injectNpmScripts": "\u662F\u5426\u6CE8\u5165 npm \u811A\u672C\uFF1F",
+  "question.deploy": "\u90E8\u7F72\u65B9\u5F0F\uFF1A",
+  "question.git": "\u662F\u5426\u521D\u59CB\u5316 git \u4ED3\u5E93\uFF1F",
+  "question.installDeps": "\u662F\u5426\u5B89\u88C5\u4F9D\u8D56\uFF1F",
+  "spinner.start": "\u{1F680} \u6B63\u5728\u521B\u5EFA...",
+  "spinner.stop": "\u{1F389} \u521B\u5EFA\u6210\u529F!",
+  "spinner.git": "\u{1F4C4} \u521D\u59CB\u5316 git \u4ED3\u5E93...",
+  "spinner.install": "\u{1F4E6} \u5B89\u88C5\u4F9D\u8D56...",
+  "spinner.command": "\u{1F528} \u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u5373\u53EF\u542F\u52A8\uFF1A",
+  "hint.cancel": "\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3002",
+  "hint.root": "\u6587\u4EF6\u8DEF\u5F84\u4E0D\u80FD\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u4E0D\u80FD\u5305\u542B\u7236\u8DEF\u5F84\u3002",
+  "hint.root.illegal": "\u6587\u4EF6\u5939\u4E0D\u80FD\u5305\u542B\u7279\u6B8A\u5B57\u7B26\u3002"
+};
+
+// src/locales/index.ts
+var locales = {
+  "zh-CN": zh,
+  "en-US": en
+};
+
+// src/translate.ts
+function createTranslate(lang) {
+  let current = lang || "en-US";
+  return {
+    setLang: (lang2) => {
+      current = lang2;
+    },
+    t: (key) => locales[current][key]
+  };
+}
+var { t, setLang } = createTranslate();
+
+// src/constants.ts
+var languageOptions = [
+  { label: "English", value: "en-US" },
+  { label: "\u7B80\u4F53\u4E2D\u6587", value: "zh-CN" }
+];
+var bundlerOptions = [
+  { label: "Vite", value: "vite" },
+  { label: "Webpack", value: "webpack" }
+];
+var deployOptions = [
+  { label: "Custom", value: "custom" /* custom */ },
+  { label: "GitHub Pages", value: "github" /* github */ },
+  { label: "Vercel", value: "vercel" /* vercel */ },
+  { label: "Netlify", value: "netlify" /* netlify */ }
+];
+
+// src/prompt.ts
+var require2 = createRequire(process.cwd());
+var REG_DIR_CHAR = /[<>:"\\|?*[\]]/;
+async function prompt(mode, root) {
+  let hasTs = false;
+  if (mode === 0 /* init */) {
+    try {
+      hasTs = !!require2.resolve("typescript");
+    } catch {
+    }
+  }
+  const result = await group({
+    displayLang: async () => {
+      const lang = await select({
+        message: "Select a language to display / \u9009\u62E9\u663E\u793A\u8BED\u8A00",
+        options: languageOptions
+      });
+      if (typeof lang === "string")
+        setLang(lang);
+      return lang;
+    },
+    root: async () => {
+      if (root)
+        return root;
+      const DEFAULT_ROOT = mode === 0 /* init */ ? "./docs" : "./my-project";
+      return await text({
+        message: t("question.root"),
+        placeholder: DEFAULT_ROOT,
+        validate(value) {
+          if (value?.startsWith("/") || value?.startsWith(".."))
+            return t("hint.root");
+          if (value && REG_DIR_CHAR.test(value))
+            return t("hint.root.illegal");
+          return void 0;
+        },
+        defaultValue: DEFAULT_ROOT
+      });
+    },
+    siteName: () => text({
+      message: t("question.site.name"),
+      placeholder: "My Vuepress Site",
+      defaultValue: "My Vuepress Site"
+    }),
+    siteDescription: () => text({
+      message: t("question.site.description")
+    }),
+    multiLanguage: () => confirm({
+      message: t("question.multiLanguage"),
+      initialValue: false
+    }),
+    defaultLanguage: () => select({
+      message: t("question.defaultLanguage"),
+      options: languageOptions
+    }),
+    useTs: async () => {
+      if (mode === 0 /* init */)
+        return hasTs;
+      if (hasTs)
+        return true;
+      return await confirm({
+        message: t("question.useTs"),
+        initialValue: true
+      });
+    },
+    injectNpmScripts: async () => {
+      if (mode === 1 /* create */)
+        return true;
+      return await confirm({
+        message: t("question.injectNpmScripts"),
+        initialValue: true
+      });
+    },
+    bundler: () => select({
+      message: t("question.bundler"),
+      options: bundlerOptions
+    }),
+    deploy: async () => {
+      if (mode === 0 /* init */) {
+        return "custom" /* custom */;
+      }
+      return await select({
+        message: t("question.deploy"),
+        options: deployOptions,
+        initialValue: "custom" /* custom */
+      });
+    },
+    git: async () => {
+      if (mode === 0 /* init */)
+        return false;
+      return confirm({
+        message: t("question.git"),
+        initialValue: true
+      });
+    },
+    install: () => confirm({
+      message: t("question.installDeps"),
+      initialValue: true
+    })
+  }, {
+    onCancel: () => {
+      cancel(t("hint.cancel"));
+      process.exit(0);
+    }
+  });
+  return result;
+}
+
+// src/generate.ts
+import path3 from "node:path";
+import process3 from "node:process";
+import fs2 from "node:fs";
+import { execaCommand as execaCommand2 } from "execa";
+
+// src/packageJson.ts
+import { execaCommand } from "execa";
+import { kebabCase } from "@pengzhanbo/utils";
+
+// src/utils/index.ts
+import { fileURLToPath } from "node:url";
+import path2 from "node:path";
+
+// src/utils/fs.ts
+import path from "node:path";
+import fs from "node:fs/promises";
+async function readFiles(root) {
+  const filepaths = await fs.readdir(root, { recursive: true });
+  const files = [];
+  for (const file of filepaths) {
+    const filepath = path.join(root, file);
+    if ((await fs.stat(filepath)).isFile()) {
+      files.push({
+        filepath: file,
+        content: await fs.readFile(filepath, "utf-8")
+      });
+    }
+  }
+  return files;
+}
+async function writeFiles(files, target, rewrite) {
+  for (const { filepath, content } of files) {
+    let root = path.join(target, filepath).replace(/\.handlebars$/, "");
+    if (rewrite)
+      root = rewrite(root);
+    await fs.mkdir(path.dirname(root), { recursive: true });
+    await fs.writeFile(root, content);
+  }
+}
+async function readJsonFile(filepath) {
+  try {
+    const content = await fs.readFile(filepath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/depsVersion.ts
+var api = "https://api.pengzhanbo.cn/npm/dependencies/version";
+async function getDependenciesVersion(dependencies, version = "latest") {
+  const result = await fetch(api, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ dependencies, version })
+  }).then((res) => res.json());
+  return result;
+}
+
+// src/utils/getPackageManager.ts
+import process2 from "node:process";
+function getPackageManager() {
+  const name = process2.env?.npm_config_user_agent || "npm";
+  return name.split("/")[0];
+}
+
+// src/utils/index.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var resolve = (...args) => path2.resolve(__dirname, "../", ...args);
+var getTemplate = (dir) => resolve("templates", dir);
+
+// src/packageJson.ts
+async function createPackageJson(mode, pkg, {
+  docsDir,
+  siteName,
+  siteDescription,
+  bundler,
+  injectNpmScripts
+}) {
+  if (mode === 1 /* create */) {
+    pkg.name = kebabCase(siteName);
+    pkg.type = "module";
+    pkg.version = "1.0.0";
+    pkg.description = siteDescription;
+    const userInfo = await getUserInfo();
+    if (userInfo) {
+      pkg.author = userInfo.username + (userInfo.email ? ` <${userInfo.email}>` : "");
+    }
+    pkg.license = "MIT";
+  }
+  if (injectNpmScripts) {
+    pkg.scripts ??= {};
+    pkg.scripts = {
+      ...pkg.scripts,
+      "docs:dev": `vuepress dev ${docsDir}`,
+      "docs:dev-clean": `vuepress dev ${docsDir} --clean-cache --clean-temp`,
+      "docs:build": `vuepress build ${docsDir} --clean-cache --clean-temp`,
+      "docs:preview": `http-server ${docsDir}/.vuepress/dist`
+    };
+    if (mode === 1 /* create */) {
+      pkg.scripts["vp-update"] = "vp-update";
+    }
+  }
+  pkg.devDependencies ??= {};
+  const context = await readJsonFile(resolve("package.json"));
+  const meta = context["theme-plume"];
+  pkg.devDependencies.vuepress = `${meta.vuepress}`;
+  pkg.devDependencies["vuepress-theme-plume"] = `${context.version}`;
+  pkg.devDependencies[`@vuepress/bundler-${bundler}`] = `${meta.vuepress}`;
+  pkg.devDependencies["http-server"] = "^14.1.1";
+  const deps = [];
+  if (!pkg.dependencies?.vue && !pkg.devDependencies.vue)
+    deps.push("vue");
+  if (bundler === "webpack" && !pkg.dependencies?.["sass-loader"] && !pkg.devDependencies["sass-loader"])
+    deps.push("sass-loader");
+  const dv = await getDependenciesVersion(deps);
+  for (const [d, v] of Object.entries(dv))
+    pkg.devDependencies[d] = `^${v}`;
+  return {
+    filepath: "package.json",
+    content: JSON.stringify(pkg, null, 2)
+  };
+}
+async function getUserInfo() {
+  try {
+    const { stdout: username } = await execaCommand("git config --global user.name");
+    const { stdout: email } = await execaCommand("git config --global user.email");
+    return { username, email };
+  } catch {
+    return null;
+  }
+}
+
+// src/render.ts
+import handlebars from "handlebars";
+import { kebabCase as kebabCase2 } from "@pengzhanbo/utils";
+handlebars.registerHelper("removeLeadingSlash", (path4) => path4.replace(/^\//, ""));
+handlebars.registerHelper("equal", (a, b) => a === b);
+function createRender(result) {
+  const data = {
+    ...result,
+    name: kebabCase2(result.siteName),
+    isEN: result.defaultLanguage === "en-US",
+    locales: result.defaultLanguage === "en-US" ? [
+      { path: "/", lang: "en-US", isEn: true, prefix: "en" },
+      { path: "/zh/", lang: "zh-CN", isEn: false, prefix: "zh" }
+    ] : [
+      { path: "/", lang: "zh-CN", isEn: false, prefix: "zh" },
+      { path: "/en/", lang: "en-US", isEn: true, prefix: "en" }
+    ]
+  };
+  return function render(source) {
+    try {
+      const template = handlebars.compile(source);
+      return template(data);
+    } catch (e) {
+      console.error(e);
+      return source;
+    }
+  };
+}
+
+// src/generate.ts
+async function generate(mode, data) {
+  const cwd = process3.cwd();
+  let userPkg = {};
+  if (mode === 0 /* init */) {
+    const pkgPath = path3.join(cwd, "package.json");
+    if (fs2.existsSync(pkgPath)) {
+      userPkg = await readJsonFile(pkgPath) || {};
+    }
+  }
+  const fileList = [
+    // add package.json
+    await createPackageJson(mode, userPkg, data),
+    // add docs files
+    ...await createDocsFiles(data),
+    // add vuepress and theme-plume configs
+    ...updateFileListTarget(await readFiles(getTemplate(".vuepress")), `${data.docsDir}/.vuepress`)
+  ];
+  if (mode === 1 /* create */) {
+    fileList.push(...await readFiles(getTemplate("common")));
+    if (data.packageManager === "pnpm") {
+      fileList.push({
+        filepath: ".npmrc",
+        content: "shamefully-hoist=true\nshell-emulator=true"
+      });
+    }
+    if (data.packageManager === "yarn") {
+      const { stdout: yarnVersion } = await execaCommand2("yarn --version");
+      if (yarnVersion.startsWith("2")) {
+        fileList.push({
+          filepath: ".yarnrc.yml",
+          content: "nodeLinker: 'node-modules'\n"
+        });
+      }
+    }
+  }
+  if (data.git)
+    fileList.push(...await readFiles(getTemplate("git")));
+  if (mode === 0 /* init */) {
+    const gitignorePath = path3.join(cwd, ".gitignore");
+    const docs = data.docsDir;
+    if (fs2.existsSync(gitignorePath)) {
+      const content = await fs2.promises.readFile(gitignorePath, "utf-8");
+      fileList.push({
+        filepath: ".gitignore",
+        content: `${content}
+${docs}/.vuepress/.cache
+${docs}/.vuepress/.temp
+${docs}/.vuepress/dist
+`
+      });
+    }
+  }
+  if (data.deploy !== "custom" /* custom */) {
+    fileList.push(...await readFiles(getTemplate(`deploy/${data.deploy}`)));
+  }
+  const render = createRender(data);
+  const renderedFiles = fileList.map((file) => {
+    if (file.filepath.endsWith(".handlebars"))
+      file.content = render(file.content);
+    return file;
+  });
+  const ext = data.useTs ? "" : userPkg.type !== "module" ? ".mjs" : ".js";
+  const REG_EXT = /\.ts$/;
+  const output = mode === 1 /* create */ ? path3.join(cwd, data.root) : cwd;
+  await writeFiles(renderedFiles, output, (filepath) => {
+    if (filepath.endsWith(".d.ts"))
+      return filepath;
+    if (ext)
+      return filepath.replace(REG_EXT, ext);
+    return filepath;
+  });
+}
+async function createDocsFiles(data) {
+  const fileList = [];
+  if (data.multiLanguage) {
+    const enDocs = await readFiles(getTemplate("docs/en"));
+    const zhDocs = await readFiles(getTemplate("docs/zh"));
+    if (data.defaultLanguage === "en-US") {
+      fileList.push(...enDocs);
+      fileList.push(...updateFileListTarget(zhDocs, "zh"));
+    } else {
+      fileList.push(...zhDocs);
+      fileList.push(...updateFileListTarget(enDocs, "en"));
+    }
+  } else {
+    if (data.defaultLanguage === "en-US")
+      fileList.push(...await readFiles(getTemplate("docs/en")));
+    else
+      fileList.push(...await readFiles(getTemplate("docs/zh")));
+  }
+  return updateFileListTarget(fileList, data.docsDir);
+}
+function updateFileListTarget(fileList, target) {
+  return fileList.map(({ filepath, content }) => ({
+    filepath: path3.join(target, filepath),
+    content
+  }));
+}
+
+// src/run.ts
+async function run(mode, root) {
+  intro(colors.cyan("Welcome to VuePress and vuepress-theme-plume !"));
+  const result = await prompt(mode, root);
+  const data = resolveData(result, mode);
+  const progress = spinner();
+  progress.start(t("spinner.start"));
+  await generate(mode, data);
+  if (data.git) {
+    progress.message(t("spinner.git"));
+    await execaCommand3("git init");
+  }
+  const pm = data.packageManager;
+  if (data.install) {
+    progress.message(t("spinner.install"));
+    await execaCommand3(pm === "yarn" ? "yarn" : `${pm} install`);
+  }
+  const cdCommand = mode === 1 /* create */ ? colors.green(`cd ${data.root}`) : "";
+  const runCommand = colors.green(pm === "yarn" ? "yarn dev" : `${pm} run dev`);
+  const installCommand = colors.green(pm === "yarn" ? "yarn" : `${pm} install`);
+  progress.stop(t("spinner.stop"));
+  if (mode === 1 /* create */) {
+    outro(`${t("spinner.command")}
+      ${cdCommand}
+      ${data.install ? "" : `${installCommand} && `}${runCommand}`);
+  }
+}
+function resolveData(result, mode) {
+  return {
+    ...result,
+    packageManager: getPackageManager(),
+    docsDir: mode === 1 /* create */ ? "docs" : result.root.replace(/^\.\//, "").replace(/\/$/, ""),
+    siteDescription: result.siteDescription || ""
+  };
+}
+
+// src/index.ts
+var cli = cac("create-vuepress-theme-plume");
+cli.command("[root]", "create a new vuepress-theme-plume project / \u521B\u5EFA\u65B0\u7684 vuepress-theme-plume \u9879\u76EE").action((root) => run(1 /* create */, root));
+cli.command("init [root]", "Initial vuepress-theme-plume in the existing project / \u5728\u73B0\u6709\u9879\u76EE\u4E2D\u521D\u59CB\u5316 vuepress-theme-plume").action((root) => run(0 /* init */, root));
+cli.help();
+cli.version("1.0.0-rc.90");
+cli.parse();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "create-vuepress-theme-plume",
+  "type": "module",
+  "version": "1.0.0-rc.91",
+  "description": "The cli for create vuepress-theme-plume's project",
+  "author": "pengzhanbo <q942450674@outlook.com> (https://github.com/pengzhanbo/)",
+  "license": "MIT",
+  "homepage": "https://theme-plume.vuejs.press/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pengzhanbo/vuepress-theme-plume.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/pengzhanbo/vuepress-theme-plume/issues"
+  },
+  "keywords": [
+    "VuePress",
+    "theme",
+    "plume",
+    "cli"
+  ],
+  "bin": "./bin/index.js",
+  "files": [
+    "bin",
+    "lib",
+    "templates"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "@pengzhanbo/utils": "^1.1.2",
+    "cac": "^6.7.14",
+    "execa": "^9.3.1",
+    "handlebars": "^4.7.8",
+    "picocolors": "^1.0.1"
+  },
+  "theme-plume": {
+    "vuepress": "2.0.0-rc.15"
+  },
+  "scripts": {
+    "build": "tsup"
+  }
+}

package/templates/.vuepress/client.ts.handlebars

@@ -0,0 +1,12 @@
+import { defineClientConfig } from 'vuepress/client'
+import RepoCard from 'vuepress-theme-plume/features/RepoCard.vue'
+import CustomComponent from './theme/components/Custom.vue'
+
+import './theme/styles/custom.css'
+
+export default defineClientConfig({
+  enhance({ app }) {
+    app.component('RepoCard', RepoCard)
+    app.component('CustomComponent', CustomComponent)
+  },
+})

package/templates/.vuepress/config.ts.handlebars

@@ -0,0 +1,90 @@
+import { defineUserConfig } from 'vuepress'
+import { {{ bundler }}Bundler } from '@vuepress/bundler-{{ bundler }}'
+import { plumeTheme } from 'vuepress-theme-plume'
+
+export default defineUserConfig({
+  base: '/',
+  lang: '{{ defaultLanguage }}',
+  {{#if multiLanguage}}
+  locales: {
+    {{#each locales}}
+    '{{ path }}': {
+      title: '{{ ../siteName }}',
+      lang: '{{ lang }}',
+      description: '{{ ../siteDescription }}',
+    },
+    {{/each}}
+  },
+  {{else}}
+  title: '{{ siteName }}',
+  description: '{{ siteDescription }}',
+  {{/if}}
+
+  bundler: {{ bundler }}Bundler(),
+
+  theme: plumeTheme({
+    // 添加您的部署域名
+    // hostname: 'https://your_site_url',
+
+    plugins: {
+      /**
+       * Shiki 代码高亮
+       * @see https://theme-plume.vuejs.press/config/plugins/code-highlight/
+       */
+      // shiki: {
+      //   languages: ['shell', 'bash', 'typescript', 'javascript'],
+      //   twoslash: true,
+      // },
+
+      /**
+       * markdown enhance
+       * @see https://theme-plume.vuejs.press/config/plugins/markdown-enhance/
+       */
+      markdownEnhance: {
+        demo: true,
+      //   include: true,
+      //   chart: true,
+      //   echarts: true,
+      //   mermaid: true,
+      //   flowchart: true,
+      },
+
+      /**
+       *  markdown power
+       * @see https://theme-plume.vuejs.press/config/plugin/markdown-power/
+       */
+      // markdownPower: {
+      //   pdf: true,
+      //   caniuse: true,
+      //   plot: true,
+      //   bilibili: true,
+      //   youtube: true,
+      //   icons: true,
+      //   codepen: true,
+      //   replit: true,
+      //   codeSandbox: true,
+      //   jsfiddle: true,
+      //   repl: {
+      //     go: true,
+      //     rust: true,
+      //     kotlin: true,
+      //   },
+      // },
+
+      /**
+       * comments
+       * @see https://theme-plume.vuejs.press/guide/features/comments/
+       */
+      // comment: {
+      //   provider: '', // "Artalk" | "Giscus" | "Twikoo" | "Waline"
+      //   comment: true,
+      //   repo: '',
+      //   repoId: '',
+      //   categoryId: '',
+      //   mapping: 'pathname',
+      //   reactionsEnabled: true,
+      //   inputPosition: 'top',
+      // },
+    },
+  }),
+})