@tnotesjs/core 0.1.2 → 0.1.3

package/dist/vitepress/config/index.js

@@ -0,0 +1,993 @@
+import {
+  NoteIndexCache,
+  RenameNoteCommand,
+  UpdateNoteConfigCommand,
+  generateAnchor,
+  logger
+} from "../../chunk-H2NACWVJ.js";
+import {
+  __commonJS,
+  __toESM
+} from "../../chunk-UIXF3LPU.js";
+
+// node_modules/.pnpm/markdown-it-task-lists@2.1.1/node_modules/markdown-it-task-lists/index.js
+var require_markdown_it_task_lists = __commonJS({
+  "node_modules/.pnpm/markdown-it-task-lists@2.1.1/node_modules/markdown-it-task-lists/index.js"(exports, module) {
+    var disableCheckboxes = true;
+    var useLabelWrapper = false;
+    var useLabelAfter = false;
+    module.exports = function(md, options) {
+      if (options) {
+        disableCheckboxes = !options.enabled;
+        useLabelWrapper = !!options.label;
+        useLabelAfter = !!options.labelAfter;
+      }
+      md.core.ruler.after("inline", "github-task-lists", function(state) {
+        var tokens = state.tokens;
+        for (var i = 2; i < tokens.length; i++) {
+          if (isTodoItem(tokens, i)) {
+            todoify(tokens[i], state.Token);
+            attrSet(tokens[i - 2], "class", "task-list-item" + (!disableCheckboxes ? " enabled" : ""));
+            attrSet(tokens[parentToken(tokens, i - 2)], "class", "contains-task-list");
+          }
+        }
+      });
+    };
+    function attrSet(token, name, value) {
+      var index = token.attrIndex(name);
+      var attr = [name, value];
+      if (index < 0) {
+        token.attrPush(attr);
+      } else {
+        token.attrs[index] = attr;
+      }
+    }
+    function parentToken(tokens, index) {
+      var targetLevel = tokens[index].level - 1;
+      for (var i = index - 1; i >= 0; i--) {
+        if (tokens[i].level === targetLevel) {
+          return i;
+        }
+      }
+      return -1;
+    }
+    function isTodoItem(tokens, index) {
+      return isInline(tokens[index]) && isParagraph(tokens[index - 1]) && isListItem(tokens[index - 2]) && startsWithTodoMarkdown(tokens[index]);
+    }
+    function todoify(token, TokenConstructor) {
+      token.children.unshift(makeCheckbox(token, TokenConstructor));
+      token.children[1].content = token.children[1].content.slice(3);
+      token.content = token.content.slice(3);
+      if (useLabelWrapper) {
+        if (useLabelAfter) {
+          token.children.pop();
+          var id = "task-item-" + Math.ceil(Math.random() * (1e4 * 1e3) - 1e3);
+          token.children[0].content = token.children[0].content.slice(0, -1) + ' id="' + id + '">';
+          token.children.push(afterLabel(token.content, id, TokenConstructor));
+        } else {
+          token.children.unshift(beginLabel(TokenConstructor));
+          token.children.push(endLabel(TokenConstructor));
+        }
+      }
+    }
+    function makeCheckbox(token, TokenConstructor) {
+      var checkbox = new TokenConstructor("html_inline", "", 0);
+      var disabledAttr = disableCheckboxes ? ' disabled="" ' : "";
+      if (token.content.indexOf("[ ] ") === 0) {
+        checkbox.content = '<input class="task-list-item-checkbox"' + disabledAttr + 'type="checkbox">';
+      } else if (token.content.indexOf("[x] ") === 0 || token.content.indexOf("[X] ") === 0) {
+        checkbox.content = '<input class="task-list-item-checkbox" checked=""' + disabledAttr + 'type="checkbox">';
+      }
+      return checkbox;
+    }
+    function beginLabel(TokenConstructor) {
+      var token = new TokenConstructor("html_inline", "", 0);
+      token.content = "<label>";
+      return token;
+    }
+    function endLabel(TokenConstructor) {
+      var token = new TokenConstructor("html_inline", "", 0);
+      token.content = "</label>";
+      return token;
+    }
+    function afterLabel(content, id, TokenConstructor) {
+      var token = new TokenConstructor("html_inline", "", 0);
+      token.content = '<label class="task-list-item-label" for="' + id + '">' + content + "</label>";
+      token.attrs = [{ for: id }];
+      return token;
+    }
+    function isInline(token) {
+      return token.type === "inline";
+    }
+    function isParagraph(token) {
+      return token.type === "paragraph_open";
+    }
+    function isListItem(token) {
+      return token.type === "list_item_open";
+    }
+    function startsWithTodoMarkdown(token) {
+      return token.content.indexOf("[ ] ") === 0 || token.content.indexOf("[x] ") === 0 || token.content.indexOf("[X] ") === 0;
+    }
+  }
+});
+
+// vitepress/config/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { defineConfig } from "vitepress";
+
+// vitepress/configs/constants.ts
+function getIgnoreList(config) {
+  return [...config.ignore_dirs.map((dir) => `**/${dir}/**`)];
+}
+function getGithubPageUrl(config) {
+  return "https://" + config.author.toLowerCase() + ".github.io/" + config.repoName + "/";
+}
+
+// vitepress/configs/head.config.ts
+function getHeadConfig(config, githubPageUrl) {
+  const head = [
+    [
+      "meta",
+      {
+        name: "keywords",
+        content: config.keywords.join(", ")
+      }
+    ],
+    ["meta", { name: "author", content: config.author }],
+    ["link", { rel: "canonical", href: githubPageUrl }],
+    ["link", { rel: "icon", href: githubPageUrl + "favicon.ico" }],
+    ["link", { rel: "preconnect", href: "https://fonts.googleapis.com" }]
+  ];
+  return head;
+}
+
+// vitepress/configs/markdown.config.ts
+var import_markdown_it_task_lists = __toESM(require_markdown_it_task_lists(), 1);
+import markdownItContainer from "markdown-it-container";
+import mila from "markdown-it-link-attributes";
+import fs from "fs";
+import path from "path";
+function esc(s = "") {
+  return s.replace(
+    /[&<>"']/g,
+    (ch) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    })[ch]
+  );
+}
+var simpleMermaidMarkdown = (md) => {
+  const fence = md.renderer.rules.fence ? md.renderer.rules.fence.bind(md.renderer.rules) : () => "";
+  md.renderer.rules.fence = (tokens, index, options, env, slf) => {
+    const token = tokens[index];
+    if (token.info.trim() === "mermaid") {
+      try {
+        const key = `mermaid-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const content = token.content;
+        return `<Mermaid id="${key}" graph="${encodeURIComponent(content)}" />`;
+      } catch (err) {
+        return `<pre>${err}</pre>`;
+      }
+    }
+    if (token.info.trim() === "mmd") {
+      tokens[index].info = "mermaid";
+    }
+    return fence(tokens, index, options, env, slf);
+  };
+};
+function configureMarkMapContainer(md) {
+  md.use(markdownItContainer, "markmap", {
+    marker: "`",
+    validate(params) {
+      const p = (params || "").trim();
+      return p.startsWith("markmap");
+    },
+    render() {
+      return "";
+    }
+  });
+  md.core.ruler.after("block", "tn_replace_markmap_container", (state) => {
+    const src = state.env.source || "";
+    const lines = src.split("\n");
+    const tokens = state.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.type === "container_markmap_open") {
+        let j = i + 1;
+        while (j < tokens.length && tokens[j].type !== "container_markmap_close")
+          j++;
+        if (j >= tokens.length) continue;
+        const open = t;
+        const startLine = open.map ? open.map[0] + 1 : null;
+        const endLine = open.map ? open.map[1] - 1 : null;
+        let params = {};
+        if (open.map && typeof open.map[0] === "number") {
+          const openLine = (lines[open.map[0]] || "").trim();
+          let paramPart = "";
+          const braceMatch = openLine.match(/\{([^}]*)\}/);
+          if (braceMatch) {
+            paramPart = braceMatch[1].trim();
+          } else {
+            const after = openLine.replace(/^`+\s*/, "");
+            if (after.startsWith("markmap")) {
+              paramPart = after.slice("markmap".length).trim();
+            }
+          }
+          if (paramPart) {
+            const tokenArr = paramPart.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+            let startIdx = 0;
+            if (tokenArr.length > 0 && /^\d+$/.test(tokenArr[0])) {
+              params.initialExpandLevel = Number(tokenArr[0]);
+              startIdx = 1;
+            }
+            for (let k = startIdx; k < tokenArr.length; k++) {
+              const pair = tokenArr[k];
+              if (!pair) continue;
+              const m = pair.match(/^([^=:\s]+)\s*(=|:)\s*(.+)$/);
+              if (m) {
+                const key = m[1];
+                let val = m[3];
+                if (/^".*"$/.test(val) && val.length >= 2 || /^'.*'$/.test(val) && val.length >= 2) {
+                  val = val.slice(1, -1);
+                } else if (/^\d+$/.test(val)) {
+                  val = String(Number(val));
+                }
+                params[key] = val;
+              }
+            }
+          }
+        }
+        let content = "";
+        if (startLine !== null && endLine !== null) {
+          for (let k = startLine; k <= endLine && k < lines.length; k++) {
+            content += lines[k] + "\n";
+          }
+        } else {
+          for (let k = i + 1; k < j; k++) {
+            content += tokens[k].content || "";
+          }
+        }
+        const firstNonEmptyLine = (content || "").split("\n").find((ln) => ln.trim() !== "") || "";
+        const refMatch = firstNonEmptyLine.trim().match(/^<<<\s*(.+)$/);
+        if (refMatch) {
+          let refRaw = refMatch[1].trim().replace(/^['"]|['"]$/g, "");
+          try {
+            const env = state.env || {};
+            const possibleRel = env.relativePath || env.path || env.filePath || env.file || "";
+            let refFullPath = refRaw;
+            if (!path.isAbsolute(refRaw)) {
+              if (possibleRel) {
+                const currentDir = path.dirname(possibleRel);
+                refFullPath = path.resolve(process.cwd(), currentDir, refRaw);
+              } else {
+                refFullPath = path.resolve(process.cwd(), refRaw);
+              }
+            } else {
+              refFullPath = refRaw;
+            }
+            const fileContent = fs.readFileSync(refFullPath, "utf-8");
+            content = fileContent;
+          } catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            content = `Failed to load referenced file: ${esc(
+              String(refRaw)
+            )}
+
+Error: ${esc(errorMsg)}`;
+          }
+        }
+        const encodedContent = encodeURIComponent(content.trim());
+        let propsStr = `content="${encodedContent}"`;
+        for (const [k, v] of Object.entries(params)) {
+          if (typeof v === "number" || /^\d+$/.test(String(v))) {
+            propsStr += ` :${k}="${v}"`;
+          } else {
+            const safe = String(v).replace(/"/g, "&quot;");
+            propsStr += ` ${k}="${safe}"`;
+          }
+        }
+        const html = `<MarkMap ${propsStr}></MarkMap>
+`;
+        const htmlToken = new state.Token("html_block", "", 0);
+        htmlToken.content = html;
+        tokens.splice(i, j - i + 1, htmlToken);
+      }
+    }
+    return true;
+  });
+}
+function configureSwiperContainer(md) {
+  let __tn_swiper_uid = 0;
+  let __tn_rules_stack = [];
+  md.core.ruler.before("block", "tn_swiper_reset_uid", () => {
+    __tn_swiper_uid = 0;
+    __tn_rules_stack = [];
+    return true;
+  });
+  md.use(markdownItContainer, "swiper", {
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        __tn_rules_stack.push({
+          image: md.renderer.rules.image,
+          pOpen: md.renderer.rules.paragraph_open,
+          pClose: md.renderer.rules.paragraph_close
+        });
+        md.renderer.rules.paragraph_open = () => "";
+        md.renderer.rules.paragraph_close = () => "";
+        md.renderer.rules.image = (tokens2, i) => {
+          const token = tokens2[i];
+          const src = token.attrGet("src") || "";
+          const alt = token.content || "";
+          const title = alt && alt.trim() ? alt : "img";
+          return `<div class="swiper-slide" data-title="${esc(
+            title
+          )}"><img src="${esc(src)}" alt="${esc(alt)}"></div>`;
+        };
+        const id = `tn-swiper-${++__tn_swiper_uid}`;
+        return `
+<div class="tn-swiper" data-swiper-id="${id}">
+  <div class="tn-swiper-tabs"></div>
+  <div class="swiper-container">
+    <div class="swiper-wrapper">
+`;
+      } else {
+        const prev = __tn_rules_stack.pop() || {
+          image: null,
+          pOpen: null,
+          pClose: null
+        };
+        md.renderer.rules.image = prev.image;
+        md.renderer.rules.paragraph_open = prev.pOpen;
+        md.renderer.rules.paragraph_close = prev.pClose;
+        return `
+    </div>
+    <!-- \u4E0B\u4E00\u9875\u6309\u94AE -->
+    <!-- <div class="swiper-button-next"></div> -->
+    <!-- \u4E0A\u4E00\u9875\u6309\u94AE -->
+    <!-- <div class="swiper-button-prev"></div> -->
+    <!-- \u5206\u9875\u5BFC\u822A -->
+    <!-- <div class="swiper-pagination"></div> -->
+  </div>
+</div>
+`;
+      }
+    }
+  });
+}
+function getMarkdownConfig() {
+  const markdown = {
+    lineNumbers: true,
+    math: true,
+    config(md) {
+      md.core.ruler.before("normalize", "save-source", (state) => {
+        state.env.source = state.src;
+        return true;
+      });
+      simpleMermaidMarkdown(md);
+      configureMarkMapContainer(md);
+      md.use(import_markdown_it_task_lists.default);
+      md.use(mila, {
+        attrs: {
+          target: "_self",
+          rel: "noopener"
+        }
+      });
+      configureSwiperContainer(md);
+    },
+    anchor: {
+      slugify: generateAnchor
+    },
+    image: {
+      lazyLoading: true
+    }
+  };
+  return markdown;
+}
+
+// vitepress/configs/theme.config.ts
+function getThemeConfig(config) {
+  const themeConfig = {
+    docFooter: {
+      prev: "\u4E0A\u4E00\u7BC7",
+      next: "\u4E0B\u4E00\u7BC7"
+    },
+    externalLinkIcon: true,
+    outline: {
+      level: [2, 3],
+      label: "\u76EE\u5F55"
+    },
+    nav: [
+      {
+        text: "\u{1F440} README",
+        link: "/README"
+      },
+      {
+        text: "Menus",
+        items: config.menuItems
+      }
+    ],
+    search: {
+      // 使用本地搜索（不依赖远程服务器）
+      provider: "local",
+      options: {
+        miniSearch: {
+          /**
+           * 控制如何对文档进行分词、字段提取等预处理
+           * @type {Pick<import('minisearch').Options, 'extractField' | 'tokenize' | 'processTerm'>}
+           */
+          options: {
+            // 自定义分词逻辑
+            tokenize: (text, language) => {
+              if (language === "zh") {
+                return text.match(/[\u4e00-\u9fa5]+|\S+/g) || [];
+              }
+              return text.split(/\s+/);
+            },
+            // 将所有词转为小写，确保大小写不敏感匹配
+            processTerm: (term) => term.toLowerCase()
+          },
+          /**
+           * 控制搜索时的行为（如模糊匹配、权重）
+           * @type {import('minisearch').SearchOptions}
+           * @default
+           * { fuzzy: 0.2, prefix: true, boost: { title: 4, text: 2, titles: 1 } }
+           */
+          searchOptions: {
+            fuzzy: 0.2,
+            // 模糊匹配阈值（0-1），允许拼写错误的阈值（数值越低越严格）
+            prefix: true,
+            // 是否启用前缀匹配（输入"jav"可匹配"javascript"）
+            boost: {
+              title: 10,
+              // 文件名作为 h1 标题，权重最高
+              headings: 5,
+              // h2 - h6
+              text: 3,
+              // 正文内容索引
+              code: 1
+              // 代码块索引权重
+            }
+          }
+        },
+        /**
+         * 控制哪些 Markdown 内容参与本地搜索引擎索引
+         * @param {string} src 当前 Markdown 文件的原始内容（即 .md 文件中的文本）
+         * @param {import('vitepress').MarkdownEnv} env 包含当前页面环境信息的对象，比如 frontmatter、路径等
+         * @param {import('markdown-it-async')} md 一个 Markdown 渲染器实例，用来将 Markdown 转换为 HTML
+         */
+        async _render(src, env, md) {
+          const filePath = env.relativePath;
+          if (filePath.includes("TOC.md")) return "";
+          const notesIndex = filePath.indexOf("notes/");
+          let folderName = "";
+          if (notesIndex !== -1) {
+            const pathAfterNotes = filePath.slice(notesIndex + "notes/".length);
+            folderName = pathAfterNotes.split("/")[0];
+          }
+          const titleField = `# ${folderName}
+`;
+          const html = md.render(titleField + "\n\n" + src, env);
+          return html;
+        }
+      }
+    },
+    // sidebar: [...sidebar],
+    sidebar: [
+      {
+        text: "\u{1F440} README",
+        link: "/README"
+      }
+    ],
+    socialLinks: config.socialLinks
+  };
+  return themeConfig;
+}
+
+// vitepress/plugins/updateConfigPlugin.ts
+function updateConfigPlugin() {
+  let updateCommand;
+  return {
+    name: "tnotes-update-config",
+    configureServer(server) {
+      updateCommand = new UpdateNoteConfigCommand();
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url === "/__tnotes_update_config" && req.method === "POST") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const data = JSON.parse(body);
+              const { noteIndex, config } = data;
+              if (!noteIndex || !config) {
+                res.statusCode = 400;
+                res.end("Missing noteIndex or config");
+                return;
+              }
+              await updateCommand.updateConfig({
+                noteIndex,
+                config: {
+                  done: config.done,
+                  enableDiscussions: config.enableDiscussions,
+                  description: config.description
+                }
+              });
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: true }));
+            } catch (error) {
+              console.error("\u66F4\u65B0\u914D\u7F6E\u5931\u8D25:", error);
+              res.statusCode = 500;
+              res.end(error instanceof Error ? error.message : String(error));
+            }
+          });
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/renameNotePlugin.ts
+function renameNotePlugin() {
+  const renameCommand = new RenameNoteCommand();
+  return {
+    name: "tnotes-rename-note",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url === "/__tnotes_rename_note" && req.method === "POST") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const { noteIndex, newTitle } = JSON.parse(body);
+              if (!noteIndex || !newTitle) {
+                res.statusCode = 400;
+                res.end("Missing noteIndex or newTitle");
+                return;
+              }
+              const startTime = Date.now();
+              await renameCommand.renameNote({ noteIndex, newTitle });
+              const duration = Date.now() - startTime;
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  duration,
+                  newTitle,
+                  message: "\u91CD\u547D\u540D\u5B8C\u6210"
+                })
+              );
+            } catch (error) {
+              res.statusCode = 500;
+              res.end(error instanceof Error ? error.message : "Rename failed");
+            }
+          });
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/getNoteByConfigIdPlugin.ts
+function getNoteByConfigIdPlugin() {
+  return {
+    name: "tnotes-get-note-by-config-id",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url?.startsWith("/__tnotes_get_note?") && req.method === "GET") {
+          try {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const configId = url.searchParams.get("configId");
+            if (!configId) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: "Missing configId parameter"
+                })
+              );
+              return;
+            }
+            const noteIndexCache = NoteIndexCache.getInstance();
+            if (!noteIndexCache.isInitialized()) {
+              res.statusCode = 503;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: "Service not initialized"
+                })
+              );
+              return;
+            }
+            const noteItem = noteIndexCache.getByConfigId(configId);
+            if (!noteItem) {
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  found: false,
+                  data: null
+                })
+              );
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: true,
+                found: true,
+                data: {
+                  noteIndex: noteItem.noteIndex,
+                  folderName: noteItem.folderName,
+                  // 构建笔记的完整 URL（包含 README）
+                  url: `/notes/${encodeURIComponent(
+                    noteItem.folderName
+                  )}/README`
+                }
+              })
+            );
+            logger.debug(
+              `\u67E5\u8BE2\u7B14\u8BB0: configId=${configId}, noteIndex=${noteItem.noteIndex}`
+            );
+          } catch (error) {
+            logger.error("\u67E5\u8BE2\u7B14\u8BB0\u5931\u8D25:", error);
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+              })
+            );
+          }
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/buildProgressPlugin.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync
+} from "fs";
+import { join } from "path";
+var CACHE_DIR = join(process.cwd(), "node_modules", ".tnotes-progress");
+var CACHE_FILE = join(CACHE_DIR, "build-cache.json");
+function getCacheData() {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return { transformCount: 0, chunkCount: 0 };
+}
+function setCacheData(data) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+function countSourceFiles(srcDir) {
+  let count = 0;
+  const extensions = /\.(vue|ts|js|jsx|tsx|css|scss|sass|styl|less|md)$/i;
+  const scan = (dir) => {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+          scan(fullPath);
+        } else if (entry.isFile() && extensions.test(entry.name)) {
+          count++;
+        }
+      }
+    } catch {
+    }
+  };
+  scan(srcDir);
+  return count;
+}
+var globalStartTime = 0;
+var globalTransformCount = 0;
+var globalChunkCount = 0;
+var globalHasError = false;
+var globalIsBuilding = false;
+var globalOutDir = "";
+var globalLastPercent = 0;
+var globalFileCount = 0;
+var globalLastLoggedPercent = -1;
+var isTTY = !!(process.stdout.isTTY && process.stderr.isTTY);
+var isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL);
+var useSingleLineMode = isTTY && !isCI;
+var originalStdoutWrite = null;
+var originalStderrWrite = null;
+function interceptOutput() {
+  if (originalStdoutWrite) return;
+  originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const filter = (chunk) => {
+    const str = chunk.toString();
+    return str.includes("\u{1F528}") || str.includes("\u2705 \u6784\u5EFA\u6210\u529F") || str.includes("\u274C \u6784\u5EFA\u5931\u8D25") || str.includes("\u{1F4C1}") || str.includes("\u{1F4CA}") || str.includes("\u{1F4E6}") || str.includes("\u23F1\uFE0F") || str.includes("\x1B[2K");
+  };
+  process.stdout.write = ((chunk, encodingOrCallback, callback) => {
+    if (filter(chunk)) {
+      return originalStdoutWrite(chunk, encodingOrCallback, callback);
+    }
+    if (typeof encodingOrCallback === "function") encodingOrCallback();
+    else if (callback) callback();
+    return true;
+  });
+  process.stderr.write = ((chunk, encodingOrCallback, callback) => {
+    const str = chunk.toString();
+    if (filter(chunk) || str.toLowerCase().includes("error")) {
+      return originalStderrWrite(chunk, encodingOrCallback, callback);
+    }
+    if (typeof encodingOrCallback === "function") encodingOrCallback();
+    else if (callback) callback();
+    return true;
+  });
+}
+function restoreOutput() {
+  if (originalStdoutWrite) {
+    process.stdout.write = originalStdoutWrite;
+    originalStdoutWrite = null;
+  }
+  if (originalStderrWrite) {
+    process.stderr.write = originalStderrWrite;
+    originalStderrWrite = null;
+  }
+}
+function renderProgress(percent, transforms, chunks, width, complete, incomplete, isFinal = false) {
+  if (!originalStderrWrite) return;
+  if (!useSingleLineMode && !isFinal) {
+    const currentPercent = Math.floor(percent * 100);
+    const currentBucket = Math.floor(currentPercent / 10) * 10;
+    if (currentBucket <= globalLastLoggedPercent) {
+      return;
+    }
+    globalLastLoggedPercent = currentBucket;
+  }
+  const filled = Math.floor(percent * width);
+  const empty = width - filled;
+  const bar = complete.repeat(filled) + incomplete.repeat(empty);
+  const percentStr = (percent * 100).toFixed(0).padStart(3, " ");
+  const elapsed = ((Date.now() - globalStartTime) / 1e3).toFixed(1);
+  const prefix = useSingleLineMode ? "\r\x1B[2K" : "";
+  const ending = isFinal || !useSingleLineMode ? "\n" : "";
+  const line = `${prefix}Building [${bar}] ${percentStr}% | Transforms: ${transforms} | Chunks: ${chunks} | Time: ${elapsed}s${ending}`;
+  originalStderrWrite(line);
+}
+function buildProgressPlugin(options = {}) {
+  const { width = 40, complete = "\u2588", incomplete = "\u2591" } = options;
+  const cache = getCacheData();
+  const hasCache = cache.transformCount > 0;
+  return {
+    name: "tnotes-build-progress",
+    enforce: "pre",
+    apply: "build",
+    config(config, { command }) {
+      if (command === "build") {
+        config.logLevel = "silent";
+        if (!globalIsBuilding) {
+          globalIsBuilding = true;
+          globalStartTime = Date.now();
+          globalTransformCount = 0;
+          globalChunkCount = 0;
+          globalHasError = false;
+          globalLastPercent = 0;
+          globalLastLoggedPercent = -1;
+          globalOutDir = config.build?.outDir || "dist";
+          if (!hasCache) {
+            globalFileCount = countSourceFiles(process.cwd());
+          }
+          interceptOutput();
+        }
+      }
+    },
+    transform(_code, id) {
+      globalTransformCount++;
+      if (hasCache) {
+        const total = cache.transformCount * 2 + cache.chunkCount * 2;
+        globalLastPercent = Math.min(0.9, globalTransformCount / total);
+      } else {
+        if (!id.includes("node_modules") && globalLastPercent < 0.7) {
+          globalLastPercent = Math.min(
+            0.7,
+            globalTransformCount / (globalFileCount * 4)
+          );
+        }
+      }
+      const transformsStr = hasCache ? `${globalTransformCount}/${cache.transformCount * 2}` : `${globalTransformCount}`;
+      const chunksStr = hasCache ? `${globalChunkCount}/${cache.chunkCount * 2}` : `${globalChunkCount}`;
+      renderProgress(
+        globalLastPercent,
+        transformsStr,
+        chunksStr,
+        width,
+        complete,
+        incomplete
+      );
+      return null;
+    },
+    renderChunk() {
+      globalChunkCount++;
+      if (hasCache) {
+        const total = cache.transformCount * 2 + cache.chunkCount * 2;
+        globalLastPercent = Math.min(
+          0.98,
+          (globalTransformCount + globalChunkCount) / total
+        );
+      } else {
+        if (globalLastPercent < 0.98) {
+          globalLastPercent = Math.min(0.98, globalLastPercent + 3e-3);
+        }
+      }
+      const transformsStr = hasCache ? `${globalTransformCount}/${cache.transformCount * 2}` : `${globalTransformCount}`;
+      const chunksStr = hasCache ? `${globalChunkCount}/${cache.chunkCount * 2}` : `${globalChunkCount}`;
+      renderProgress(
+        globalLastPercent,
+        transformsStr,
+        chunksStr,
+        width,
+        complete,
+        incomplete
+      );
+      return null;
+    },
+    buildEnd(err) {
+      if (err) {
+        globalHasError = true;
+      }
+    },
+    closeBundle() {
+      setTimeout(() => {
+        if (!globalIsBuilding) return;
+        const elapsed = ((Date.now() - globalStartTime) / 1e3).toFixed(1);
+        const totalTransforms = hasCache ? cache.transformCount * 2 : globalTransformCount;
+        const totalChunks = hasCache ? cache.chunkCount * 2 : globalChunkCount;
+        const transformsStr = `${totalTransforms}/${totalTransforms}`;
+        const chunksStr = `${totalChunks}/${totalChunks}`;
+        renderProgress(
+          1,
+          transformsStr,
+          chunksStr,
+          width,
+          complete,
+          incomplete,
+          true
+        );
+        restoreOutput();
+        if (!globalHasError) {
+          setCacheData({
+            transformCount: Math.floor(globalTransformCount / 2),
+            chunkCount: Math.floor(globalChunkCount / 2)
+          });
+          console.log(`\u2705 \u6784\u5EFA\u6210\u529F\uFF01`);
+          console.log(`   \u{1F4C1} \u8F93\u51FA\u76EE\u5F55: ${globalOutDir}`);
+          console.log(`   \u23F1\uFE0F  \u8017\u65F6: ${elapsed}s`);
+        } else {
+          console.log(`
+\u274C \u6784\u5EFA\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u9519\u8BEF\u4FE1\u606F`);
+        }
+        globalIsBuilding = false;
+      }, 500);
+    }
+  };
+}
+
+// vitepress/config/index.ts
+function loadTNotesConfig(rootPath) {
+  const configPath = path2.resolve(rootPath, ".tnotes.json");
+  const configContent = fs2.readFileSync(configPath, "utf-8");
+  return JSON.parse(configContent);
+}
+function defineNotesConfig(overrides = {}) {
+  const rootPath = process.cwd();
+  const config = loadTNotesConfig(rootPath);
+  const { repoName } = config;
+  const IGNORE_LIST = getIgnoreList(config);
+  const GITHUB_PAGE_URL = getGithubPageUrl(config);
+  const {
+    transformPageData: overrideTransformPageData,
+    vite: overrideVite,
+    ...restOverrides
+  } = overrides;
+  return defineConfig({
+    appearance: "dark",
+    base: "/" + repoName + "/",
+    cleanUrls: true,
+    description: repoName,
+    head: getHeadConfig(config, GITHUB_PAGE_URL),
+    ignoreDeadLinks: true,
+    lang: "zh-Hans",
+    lastUpdated: false,
+    markdown: getMarkdownConfig(),
+    sitemap: {
+      hostname: GITHUB_PAGE_URL,
+      lastmodDateOnly: false
+    },
+    themeConfig: getThemeConfig(config),
+    title: repoName,
+    srcExclude: IGNORE_LIST,
+    vite: {
+      plugins: [
+        buildProgressPlugin(),
+        updateConfigPlugin(),
+        renameNotePlugin(),
+        getNoteByConfigIdPlugin(),
+        ...overrideVite?.plugins || []
+      ],
+      server: {
+        watch: {
+          ignored: IGNORE_LIST
+        },
+        ...overrideVite?.server
+      },
+      css: {
+        preprocessorOptions: {
+          scss: {
+            silenceDeprecations: ["legacy-js-api"]
+          }
+        },
+        ...overrideVite?.css
+      },
+      build: {
+        chunkSizeWarningLimit: 1e3,
+        ...overrideVite?.build
+      },
+      define: {
+        __TNOTES_REPO_NAME__: JSON.stringify(config.repoName),
+        __TNOTES_AUTHOR__: JSON.stringify(config.author),
+        __TNOTES_IGNORE_DIRS__: JSON.stringify(config.ignore_dirs),
+        __TNOTES_ROOT_ITEM__: JSON.stringify(config.root_item),
+        ...overrideVite?.define
+      }
+    },
+    transformPageData(pageData, ctx) {
+      if (/^notes\/\d{4}/.test(pageData.relativePath)) {
+        const fullPath = path2.resolve(rootPath, pageData.relativePath);
+        try {
+          pageData.frontmatter.rawContent = fs2.readFileSync(fullPath, "utf-8");
+        } catch {
+          pageData.frontmatter.rawContent = null;
+        }
+      }
+      if (typeof overrideTransformPageData === "function") {
+        return overrideTransformPageData(pageData, ctx);
+      }
+    },
+    router: {
+      prefetchLinks: false
+    },
+    ...restOverrides
+  });
+}
+export {
+  defineNotesConfig
+};