dommief 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,2695 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/markdown/errors.ts
+function formatError(err) {
+  if (err instanceof DommiefError) return err.format();
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+var DommiefError;
+var init_errors = __esm({
+  "src/markdown/errors.ts"() {
+    "use strict";
+    DommiefError = class extends Error {
+      file;
+      line;
+      col;
+      code;
+      layout;
+      constructor(message, opts = {}) {
+        super(message);
+        this.name = "DommiefError";
+        this.file = opts.file ?? "";
+        this.line = opts.line;
+        this.col = opts.col;
+        this.code = opts.code;
+        this.layout = opts.layout;
+      }
+      format() {
+        const loc = this.line != null ? `:${this.line}${this.col != null ? ":" + this.col : ""}` : "";
+        const head = this.file ? `${this.file}${loc}` : loc.slice(1) || "";
+        return head ? `${head}: ${this.message}` : this.message;
+      }
+      toString() {
+        return this.format();
+      }
+    };
+  }
+});
+
+// src/plugins.ts
+function assertSync(result, name) {
+  if (result && typeof result.then === "function") {
+    throw new DommiefError(`plugin "${name}": setup ph\u1EA3i \u0111\u1ED3ng b\u1ED9 \u2014 hook tap sau \`await\` s\u1EBD kh\xF4ng bao gi\u1EDD ch\u1EA1y`, { code: "plugin_setup_async" });
+  }
+}
+function registerPlugin(host, plugin) {
+  if (!plugin) return;
+  if (typeof plugin === "function") {
+    assertSync(plugin(host), plugin.name || "plugin");
+    return;
+  }
+  const p = plugin;
+  const name = p.name ?? "plugin";
+  if (typeof p.setup === "function") assertSync(p.setup(host), name);
+  if (typeof p.modifyConfig === "function") host.modifyConfig.tap(name, p.modifyConfig);
+  if (typeof p.modifyRoutes === "function") host.modifyRoutes.tap(name, p.modifyRoutes);
+  if (typeof p.addRemarkPlugins === "function") host.addRemarkPlugins.tap(name, p.addRemarkPlugins);
+  if (typeof p.addRehypePlugins === "function") host.addRehypePlugins.tap(name, p.addRehypePlugins);
+  if (typeof p.addHtmlHeadTags === "function") host.addHtmlHeadTags.tap(name, p.addHtmlHeadTags);
+  if (typeof p.onBuildEnd === "function") host.onBuildEnd.tap(name, p.onBuildEnd);
+}
+function createPluginHost(plugins = []) {
+  const host = new PluginHookHost();
+  for (const p of plugins ?? []) registerPlugin(host, p);
+  return host;
+}
+var Hook, PluginHookHost;
+var init_plugins = __esm({
+  "src/plugins.ts"() {
+    "use strict";
+    init_errors();
+    Hook = class {
+      name;
+      constructor(name = "") {
+        this.name = name;
+      }
+      taps = [];
+      tap(name, fn) {
+        this.taps.push({ name, fn });
+      }
+      call(arg) {
+        let value = arg;
+        for (const t of this.taps) {
+          const r = t.fn(value);
+          if (r !== void 0) value = r;
+        }
+        return value;
+      }
+      async callAsync(arg) {
+        let value = arg;
+        for (const t of this.taps) {
+          const r = await t.fn(value);
+          if (r !== void 0) value = r;
+        }
+        return value;
+      }
+    };
+    PluginHookHost = class {
+      modifyConfig = new Hook("modifyConfig");
+      modifyRoutes = new Hook("modifyRoutes");
+      addRemarkPlugins = new Hook("addRemarkPlugins");
+      addRehypePlugins = new Hook("addRehypePlugins");
+      addHtmlHeadTags = new Hook("addHtmlHeadTags");
+      onBuildEnd = new Hook("onBuildEnd");
+      applyModifyConfig(config) {
+        return this.modifyConfig.call(config);
+      }
+      applyModifyRoutes(routes) {
+        const r = this.modifyRoutes.call(routes);
+        return r ?? routes;
+      }
+      collectRemarkPlugins() {
+        const out = [];
+        for (const t of this.addRemarkPlugins.taps) {
+          const r = t.fn();
+          if (Array.isArray(r)) out.push(...r);
+          else if (r !== void 0 && r !== null) out.push(r);
+        }
+        return out;
+      }
+      collectRehypePlugins() {
+        const out = [];
+        for (const t of this.addRehypePlugins.taps) {
+          const r = t.fn();
+          if (Array.isArray(r)) out.push(...r);
+          else if (r !== void 0 && r !== null) out.push(r);
+        }
+        return out;
+      }
+      collectHtmlHeadTags() {
+        const out = [];
+        for (const t of this.addHtmlHeadTags.taps) {
+          const r = t.fn();
+          if (Array.isArray(r)) out.push(...r.map(String));
+          else if (r !== void 0 && r !== null) out.push(String(r));
+        }
+        return out;
+      }
+      async runBuildEnd(ctx) {
+        for (const t of this.onBuildEnd.taps) {
+          await t.fn(ctx);
+        }
+      }
+    };
+  }
+});
+
+// src/markdown/remark-meta.ts
+import yaml from "yaml";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkFrontmatter from "remark-frontmatter";
+import Slugger from "github-slugger";
+import { visit } from "unist-util-visit";
+function textOf(node) {
+  let out = "";
+  if (node.type === "text") out += node.value || "";
+  if (node.children) for (const c of node.children) out += textOf(c);
+  return out;
+}
+function parseFrontmatterYaml(raw, opts = {}) {
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m || m[1] === void 0) return {};
+  try {
+    return yaml.parse(m[1]) ?? {};
+  } catch (e) {
+    opts.onWarn?.(`frontmatter_invalid_yaml: ${opts.file ?? ""}: ${e.message}`);
+    return {};
+  }
+}
+function remarkMeta(options = {}) {
+  return (tree, file) => {
+    const filename = options.filename ?? file?.path ?? file?.history?.[0] ?? "";
+    file.data = file.data || {};
+    let frontmatter = {};
+    if (tree.children?.[0]?.type === "yaml") {
+      frontmatter = parseFrontmatterYaml("---\n" + tree.children[0].value + "\n---", { file: filename });
+      tree.children.shift();
+    }
+    if (frontmatter.title == null) {
+      let firstH1 = null;
+      visit(tree, "heading", (node) => {
+        if (node.depth === 1 && firstH1 === null) firstH1 = textOf(node).trim();
+      });
+      if (firstH1) frontmatter.title = firstH1;
+    }
+    file.data.frontmatter = frontmatter;
+    file.data.filename = filename;
+  };
+}
+function extractPageSummary(raw, file, onWarn) {
+  const frontmatter = parseFrontmatterYaml(raw, onWarn ? { file, onWarn } : { file });
+  const tree = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).parse(raw);
+  const toc = [];
+  const slugger = new Slugger();
+  let firstH1 = null;
+  visit(tree, "heading", (node) => {
+    const title = textOf(node).trim();
+    if (!title) return;
+    const id = slugger.slug(title);
+    toc.push({ id, depth: node.depth, title });
+    if (node.depth === 1 && firstH1 === null) firstH1 = title;
+  });
+  if (frontmatter.title == null && firstH1) frontmatter.title = firstH1;
+  return { frontmatter, toc };
+}
+var init_remark_meta = __esm({
+  "src/markdown/remark-meta.ts"() {
+    "use strict";
+  }
+});
+
+// src/markdown/rehype-slug.ts
+import { visit as visit2 } from "unist-util-visit";
+import Slugger2 from "github-slugger";
+function textOf2(node) {
+  if (node.type === "text") return node.value || "";
+  if (node.children) return node.children.map(textOf2).join("");
+  return "";
+}
+function rehypeSlug() {
+  return (tree, file) => {
+    file.data = file.data || {};
+    const toc = [];
+    const slugger = new Slugger2();
+    visit2(tree, "element", (node) => {
+      if (/^h[1-6]$/.test(node.tagName)) {
+        const text = textOf2(node).trim();
+        const depth = Number(node.tagName.slice(1));
+        let id = node.properties?.id;
+        if (!id) id = slugger.slug(text);
+        if (!node.properties) node.properties = {};
+        node.properties.id = id;
+        toc.push({ id, depth, title: text });
+      }
+    });
+    file.data.toc = toc;
+  };
+}
+function rehypeAutolinkHeadings() {
+  return (tree) => {
+    visit2(tree, "element", (node) => {
+      if (/^h[1-6]$/.test(node.tagName) && node.properties?.id) {
+        const anchor = { type: "element", tagName: "a", properties: { href: "#" + node.properties.id, className: ["dommief-heading-anchor"], tabIndex: -1 }, children: [] };
+        node.children = [anchor, ...node.children];
+      }
+    });
+  };
+}
+var init_rehype_slug = __esm({
+  "src/markdown/rehype-slug.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/path.ts
+function winPath(p) {
+  if (/^\\\\\?\\/.test(p)) return p;
+  return p.replace(/\\/g, "/");
+}
+var init_path = __esm({
+  "src/utils/path.ts"() {
+    "use strict";
+  }
+});
+
+// src/markdown/rehype-link.ts
+import path2 from "path";
+import { visit as visit3 } from "unist-util-visit";
+function rehypeLink(options = {}) {
+  return (tree, file) => {
+    const from = winPath(String(file?.path ?? ""));
+    const prefix = (options.base ?? "/").replace(/\/$/, "");
+    const warnings = Array.isArray(file?.data?.warnings) ? file.data.warnings : [];
+    visit3(tree, "element", (node) => {
+      if (node.tagName !== "a" || !node.properties?.href) return;
+      const href = String(node.properties.href);
+      if (EXTERNAL.test(href)) return;
+      const m = href.match(/^([^#?]*\.md)([?#].*)?$/);
+      if (!m || m[1] === void 0) return;
+      const tail = m[2] ?? "";
+      if (!options.byFile) {
+        node.properties.href = m[1].replace(/\.md$/, "") + tail;
+        return;
+      }
+      const abs = path2.posix.resolve(path2.posix.dirname(from), m[1]);
+      const route = options.byFile[abs];
+      if (route) node.properties.href = (route.path === "/" ? prefix + "/" : prefix + route.path) + tail;
+      else warnings.push(`link_unresolved: "${href}" trong ${from} kh\xF4ng tr\u1ECF t\u1EDBi file md n\xE0o thu\u1ED9c docDirs`);
+    });
+    visit3(tree, "element", (node) => {
+      if (node.tagName !== "a" || !node.properties?.href || node.properties["data-src-line"]) return;
+      const href = String(node.properties.href);
+      if (EXTERNAL.test(href) && !href.startsWith("/")) return;
+      const line = node.position?.start?.line;
+      if (line) node.properties["data-src-line"] = String(line);
+    });
+    if (file?.data) file.data.warnings = warnings;
+  };
+}
+var EXTERNAL;
+var init_rehype_link = __esm({
+  "src/markdown/rehype-link.ts"() {
+    "use strict";
+    init_path();
+    EXTERNAL = /^([a-z][a-z0-9+.-]*:|\/\/|#|\/)/i;
+  }
+});
+
+// src/markdown/rehype-img.ts
+import path3 from "path";
+import { visit as visit4 } from "unist-util-visit";
+function rehypeImg() {
+  return (tree, file) => {
+    const images = [];
+    visit4(tree, "element", (node) => {
+      if (node.tagName !== "img" || !node.properties?.src) return;
+      const src = String(node.properties.src);
+      if (SKIP.test(src)) return;
+      const clean = src.replace(/[?#].*$/, "");
+      const specifier = clean.startsWith(".") ? clean : "./" + path3.posix.normalize(clean);
+      const name = `${PLACEHOLDER}${images.length}__`;
+      images.push({ name, specifier });
+      node.properties.src = name;
+    });
+    visit4(tree, "element", (node) => {
+      if (node.tagName !== "img" || !node.properties?.src || node.properties["data-src-line"]) return;
+      const line = node.position?.start?.line;
+      if (line) node.properties["data-src-line"] = String(line);
+    });
+    file.data = file.data || {};
+    file.data.images = images;
+  };
+}
+var PLACEHOLDER, SKIP;
+var init_rehype_img = __esm({
+  "src/markdown/rehype-img.ts"() {
+    "use strict";
+    PLACEHOLDER = "__DOMMIEF_IMG_";
+    SKIP = /^([a-z][a-z0-9+.-]*:|\/\/|#|\/)/i;
+  }
+});
+
+// src/markdown/rehype-desc.ts
+import { visit as visit5 } from "unist-util-visit";
+function rehypeDesc() {
+  return (tree, file) => {
+    file.data = file.data || {};
+    let desc;
+    visit5(tree, "element", (node) => {
+      if (!desc && node.tagName === "p") {
+        const text = (node.children || []).map((c) => c.value || "").join("").trim();
+        if (text) desc = text.slice(0, 160);
+      }
+    });
+    if (desc) {
+      if (!file.data.frontmatter) file.data.frontmatter = {};
+      if (file.data.frontmatter.description == null) file.data.frontmatter.description = desc;
+    }
+  };
+}
+function rehypeStrip() {
+  return (tree) => {
+    visit5(tree, "element", (node, index, parent) => {
+      if (node.tagName === "script" && parent && index !== void 0) {
+        parent.children.splice(index, 1);
+        return index;
+      }
+    });
+  };
+}
+var init_rehype_desc = __esm({
+  "src/markdown/rehype-desc.ts"() {
+    "use strict";
+  }
+});
+
+// src/markdown/rehype-text.ts
+function rehypeText() {
+  return (tree, file) => {
+    file.data = file.data || {};
+    const toc = file.data.toc || [];
+    const texts = [];
+    const paraIdOf = /* @__PURE__ */ new WeakMap();
+    let nextParaId = 0;
+    let tocCursor = -1;
+    let currentTocIndex;
+    const isContainer = (node) => {
+      if (!node || node.type !== "element") return false;
+      const tag = node.tagName;
+      if (tag === "p" || tag === "ul" || tag === "ol" || tag === "root") return true;
+      return typeof tag === "string" && /^[A-Z]/.test(tag);
+    };
+    const containerOf = (ancestors) => {
+      for (let i = ancestors.length - 1; i >= 0; i--) {
+        if (isContainer(ancestors[i])) return ancestors[i];
+      }
+      return tree;
+    };
+    const walk = (node, ancestors) => {
+      if (node && node.type === "element" && /^h[1-6]$/.test(node.tagName)) {
+        tocCursor += 1;
+        if (tocCursor < toc.length) currentTocIndex = tocCursor;
+        for (const c of node.children || []) walk(c, [...ancestors, node]);
+        return;
+      }
+      if (node && node.type === "text") {
+        const parent = ancestors[ancestors.length - 1];
+        if (parent && /^h[1-6]$/.test(parent.tagName)) return;
+        const v = node.value || "";
+        if (!v.trim()) return;
+        const container = containerOf(ancestors);
+        if (!paraIdOf.has(container)) paraIdOf.set(container, nextParaId++);
+        const paraId = paraIdOf.get(container);
+        const frag = { type: "content", value: v, paraId };
+        if (currentTocIndex !== void 0) frag.tocIndex = currentTocIndex;
+        texts.push(frag);
+        return;
+      }
+      if (node && Array.isArray(node.children)) {
+        for (const c of node.children) walk(c, [...ancestors, node]);
+      }
+    };
+    walk(tree, []);
+    file.data.texts = texts;
+  };
+}
+var init_rehype_text = __esm({
+  "src/markdown/rehype-text.ts"() {
+    "use strict";
+  }
+});
+
+// src/markdown/rehype-demo.ts
+import { visit as visit6 } from "unist-util-visit";
+import { createHash } from "crypto";
+function remarkDemoMeta() {
+  return (tree) => {
+    visit6(tree, "code", (node) => {
+      if (/\bdemo\b/.test(String(node.meta ?? ""))) {
+        node.data = { ...node.data, hProperties: { ...node.data?.hProperties, "data-demo": "true" } };
+      }
+    });
+  };
+}
+function demoId(source, file) {
+  return createHash("sha256").update(file + "\n" + source).digest("hex").slice(0, 8);
+}
+function codeText(node) {
+  let out = "";
+  visit6(node, "text", (t) => {
+    out += t.value;
+  });
+  return out;
+}
+function rehypeDemo() {
+  return (tree, file) => {
+    const demos = Array.isArray(file.data?.demos) ? file.data.demos : [];
+    const filePath = String(file.path ?? "");
+    visit6(tree, "element", (node, index, parent) => {
+      if (!parent || typeof index !== "number") return;
+      if (node.tagName === "code" && node.properties?.src) {
+        const src = String(node.properties.src);
+        const source2 = codeText(node).trim();
+        const id2 = demoId(source2 || src, filePath);
+        demos.push({ id: id2, source: source2, src });
+        parent.children[index] = {
+          type: "element",
+          tagName: "DomDemo",
+          properties: { id: id2, src, source: source2 },
+          children: []
+        };
+        return;
+      }
+      if (node.tagName !== "pre") return;
+      const codeNode = Array.isArray(node.children) ? node.children.find((c) => c?.tagName === "code") : null;
+      if (!codeNode) return;
+      if (!codeNode.properties?.dataDemo) return;
+      const source = codeText(codeNode).replace(/\n$/, "");
+      const id = demoId(source, filePath);
+      demos.push({ id, source });
+      parent.children[index] = {
+        type: "element",
+        tagName: "DomDemo",
+        properties: { id, source },
+        children: []
+      };
+    });
+    file.data.demos = demos;
+  };
+}
+var init_rehype_demo = __esm({
+  "src/markdown/rehype-demo.ts"() {
+    "use strict";
+  }
+});
+
+// src/markdown/rehype-api.ts
+import { visit as visit7 } from "unist-util-visit";
+import { createHash as createHash2 } from "crypto";
+import fs2 from "fs";
+import path4 from "path";
+import { createRequire } from "module";
+function loadDocgen() {
+  if (docgen) return docgen;
+  try {
+    docgen = createRequire(import.meta.url)("react-docgen-typescript");
+    return docgen;
+  } catch (e) {
+    throw new DommiefError(`<API> c\u1EA7n react-docgen-typescript + typescript 5.x: ${e.message}`, { code: "api_docgen_unavailable" });
+  }
+}
+function hashFileContent(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+function resolveApiSrc(src, filePath) {
+  const base = filePath ? path4.dirname(filePath) : process.cwd();
+  return path4.isAbsolute(src) ? src : path4.resolve(base, src);
+}
+function buildApiTable(src, filePath = "") {
+  const abs = resolveApiSrc(src, filePath);
+  let content;
+  try {
+    content = fs2.readFileSync(abs, "utf8");
+  } catch {
+    return null;
+  }
+  const hash = hashFileContent(content);
+  const cached = apiCache.get(abs);
+  if (cached && cached.hash === hash) return cached.entries;
+  const parser = loadDocgen().withDefaultConfig({});
+  let docs;
+  try {
+    docs = parser.parse(abs) ?? [];
+  } catch {
+    docs = [];
+  }
+  const entries = (docs || []).map((d) => ({
+    displayName: d.displayName,
+    description: d.description || "",
+    src: abs,
+    hash,
+    props: Object.values(d.props || {}).map((p) => ({
+      name: p.name,
+      type: p.type?.name ?? p.type?.raw ?? "",
+      required: !!p.required,
+      description: p.description || "",
+      defaultValue: p.defaultValue?.value
+    }))
+  }));
+  apiCache.set(abs, { hash, entries });
+  return entries;
+}
+function rehypeApi() {
+  return (tree, file) => {
+    const apis = Array.isArray(file?.data?.apis) ? file.data.apis : [];
+    const watched = Array.isArray(file?.data?.apiSrcFiles) ? file.data.apiSrcFiles : [];
+    const filePath = String(file?.path ?? "");
+    visit7(tree, "element", (node, index, parent) => {
+      if (!parent || typeof index !== "number") return;
+      if (String(node.tagName).toLowerCase() !== "api") return;
+      const src = String(node.properties?.src ?? "");
+      if (!src) return;
+      const abs = resolveApiSrc(src, filePath);
+      const data = buildApiTable(src, filePath);
+      watched.push(abs);
+      apis.push({ id: hashFileContent(src + filePath).slice(0, 8), src: abs, data });
+      parent.children[index] = {
+        type: "element",
+        tagName: "DomApi",
+        properties: {
+          src: abs,
+          data: data ? JSON.stringify(data) : void 0
+        },
+        children: []
+      };
+    });
+    if (file?.data) {
+      file.data.apis = apis;
+      file.data.apiSrcFiles = watched;
+    }
+  };
+}
+var docgen, apiCache;
+var init_rehype_api = __esm({
+  "src/markdown/rehype-api.ts"() {
+    "use strict";
+    init_errors();
+    apiCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/markdown/remark-container.ts
+import { visit as visit8 } from "unist-util-visit";
+function restrictToContainerSyntax(extensions) {
+  const isDirective = (e) => {
+    const f = e?.flow?.[58];
+    return !!e?.text?.[58] && (Array.isArray(f) ? f : [f]).some((c) => /Directive/.test(c?.tokenize?.name ?? ""));
+  };
+  const hit = extensions.filter(isDirective);
+  if (hit.length !== 1) throw new Error("remark-directive \u0111\u1ED5i c\u1EA5u tr\xFAc n\u1ED9i b\u1ED9 (kh\xF4ng th\u1EA5y \u0111\xFAng 1 extension directive {text, flow}); c\u1EADp nh\u1EADt remarkContainer");
+  const ext = hit[0];
+  const flow = ext.flow[58];
+  const constructs = Array.isArray(flow) ? flow : [flow];
+  const containers = constructs.filter((c) => /Container/.test(c?.tokenize?.name ?? ""));
+  if (containers.length !== 1) throw new Error("remark-directive \u0111\u1ED5i c\u1EA5u tr\xFAc n\u1ED9i b\u1ED9 (kh\xF4ng th\u1EA5y \u0111\xFAng 1 container construct); c\u1EADp nh\u1EADt remarkContainer");
+  delete ext.text;
+  ext.flow = { 58: containers };
+}
+function remarkContainer() {
+  const data = this.data();
+  restrictToContainerSyntax(data.micromarkExtensions ?? []);
+  return (tree, file) => {
+    visit8(tree, "containerDirective", (node, index, parent) => {
+      if (!parent || typeof index !== "number") return;
+      const name = String(node.name);
+      if (!CONTAINER_TYPES.includes(name)) {
+        const warnings = (file.data ??= {}).warnings ??= [];
+        const pos = node.position?.start;
+        warnings.push(`${file.path ?? ""}${pos ? `:${pos.line}:${pos.column}` : ""} container ":::${name}" kh\xF4ng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3 (ch\u1EC9 ${CONTAINER_TYPES.join("/")}); render th\xE0nh <div> th\u01B0\u1EDDng`);
+        node.data = { hName: "div", hProperties: {} };
+        return;
+      }
+      const type = name;
+      const labelIdx = node.children.findIndex((c) => c.data?.directiveLabel);
+      const labelNode = labelIdx >= 0 ? node.children.splice(labelIdx, 1)[0] : null;
+      const title = node.attributes?.title ?? (labelNode ? textOf3(labelNode) : void 0);
+      const children = [...node.children];
+      if (title) {
+        children.unshift({ type: "paragraph", data: { hName: "p", hProperties: { className: ["dommief-container__title"] } }, children: [{ type: "text", value: title }] });
+      }
+      node.children = children;
+      node.data = {
+        hName: "div",
+        hProperties: {
+          className: ["dommief-container", `dommief-container--${type}`],
+          // warning/error là thông tin cần chú ý ngay → role="alert" không đúng (nó ngắt screen reader);
+          // dùng role="note" cho mọi loại, kiểu nằm ở class.
+          role: "note",
+          ...title ? {} : { "aria-label": type }
+        }
+      };
+    });
+  };
+}
+function textOf3(node) {
+  let out = "";
+  visit8(node, "text", (t) => {
+    out += t.value;
+  });
+  return out.trim();
+}
+var CONTAINER_TYPES;
+var init_remark_container = __esm({
+  "src/markdown/remark-container.ts"() {
+    "use strict";
+    CONTAINER_TYPES = ["info", "warning", "success", "error"];
+  }
+});
+
+// src/markdown/rehype-code.ts
+import { visit as visit9 } from "unist-util-visit";
+import { bundledLanguages, createHighlighter } from "shiki";
+function parseHighlightLines(meta) {
+  const m = meta.match(HIGHLIGHT_RE);
+  if (!m) return { lines: [], rest: meta.trim() };
+  const set = /* @__PURE__ */ new Set();
+  for (const part of m[1].split(",").filter(Boolean)) {
+    const [a, b] = part.split("-").map(Number);
+    const end = b ?? a;
+    for (let n = Math.min(a, end); n <= Math.max(a, end); n++) if (n >= 1) set.add(n);
+  }
+  return { lines: [...set].sort((x, y) => x - y), rest: meta.replace(HIGHLIGHT_RE, "").trim() };
+}
+function remarkCodeMeta() {
+  return (tree) => {
+    visit9(tree, "code", (node) => {
+      const meta = String(node.meta ?? "");
+      if (!meta) return;
+      const { lines, rest } = parseHighlightLines(meta);
+      const title = rest.match(/\[([^\]]+)\]/)?.[1];
+      const props = {};
+      if (lines.length) props["data-highlight-lines"] = lines.join(",");
+      if (title) props["data-title"] = title;
+      if (Object.keys(props).length) node.data = { ...node.data, hProperties: { ...node.data?.hProperties, ...props } };
+      node.meta = rest || null;
+    });
+  };
+}
+function getHighlighter(opts) {
+  const key = `${opts.themes.light}|${opts.themes.dark}`;
+  let h = highlighters.get(key);
+  if (!h) {
+    h = createHighlighter({ themes: [opts.themes.light, opts.themes.dark], langs: [] });
+    highlighters.set(key, h);
+  }
+  return h;
+}
+function textOf4(node) {
+  let out = "";
+  visit9(node, "text", (t) => {
+    out += t.value;
+  });
+  return out;
+}
+function langOf(code) {
+  const cls = code.properties?.className;
+  const list = Array.isArray(cls) ? cls.map(String) : typeof cls === "string" ? cls.split(/\s+/) : [];
+  return list.map((c) => /^language-(.+)$/.exec(c)?.[1]).find(Boolean);
+}
+function markLines(pre, highlight, lineNumbers) {
+  const code = pre.children?.find((c) => c.tagName === "code");
+  let n = 0;
+  for (const child of code?.children ?? []) {
+    if (child.type !== "element" || child.tagName !== "span") continue;
+    const cls = String(child.properties?.class ?? child.properties?.className ?? "");
+    if (!/\bline\b/.test(cls)) continue;
+    n++;
+    const classes = cls.split(/\s+/).filter(Boolean);
+    if (highlight.has(n)) classes.push("highlighted");
+    child.properties = { ...child.properties, class: classes.join(" ") };
+    if (lineNumbers) child.properties["data-line"] = String(n);
+  }
+}
+function rehypeCode(options = {}) {
+  const shiki = options.shiki === void 0 ? DEFAULT_SHIKI : options.shiki;
+  const lineNumbers = !!options.lineNumbers;
+  return async (tree, file) => {
+    const jobs = [];
+    visit9(tree, "element", (node, index, parent) => {
+      if (node.tagName !== "pre" || !parent || typeof index !== "number") return;
+      const kids = (node.children ?? []).filter((c) => !(c.type === "text" && !c.value.trim()));
+      if (kids.length !== 1 || kids[0].tagName !== "code") return;
+      jobs.push({ parent, index, pre: node, code: kids[0] });
+    });
+    if (!jobs.length) return;
+    const highlighter = shiki ? await getHighlighter(shiki) : null;
+    for (const { parent, index, pre, code } of jobs) {
+      const lang = langOf(code);
+      const title = code.properties?.dataTitle;
+      const hl = new Set(String(code.properties?.dataHighlightLines ?? "").split(",").filter(Boolean).map(Number));
+      let inner = pre;
+      if (highlighter && shiki && lang) {
+        if (lang in bundledLanguages) {
+          if (!highlighter.getLoadedLanguages().includes(lang)) await highlighter.loadLanguage(lang);
+          const source = textOf4(code).replace(/\n$/, "");
+          const root = highlighter.codeToHast(source, { lang, themes: { light: shiki.themes.light, dark: shiki.themes.dark }, defaultColor: false });
+          inner = root.children[0];
+          markLines(inner, hl, lineNumbers);
+        } else {
+          const warnings = (file.data ??= {}).warnings ??= [];
+          const pos = pre.position?.start;
+          warnings.push(`${file.path ?? ""}${pos ? `:${pos.line}` : ""} Shiki kh\xF4ng c\xF3 grammar cho "${lang}"; hi\u1EC3n th\u1ECB code th\xF4`);
+        }
+      }
+      if (inner === pre && hl.size) pre.properties = { ...pre.properties, "data-highlight-lines": [...hl].join(",") };
+      delete code.properties?.dataHighlightLines;
+      delete code.properties?.dataTitle;
+      const children = [];
+      if (title) children.push({ type: "element", tagName: "div", properties: { className: ["dommief-code__title"] }, children: [{ type: "text", value: title }] });
+      children.push(inner);
+      parent.children[index] = {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["dommief-code"], ...lang ? { "data-lang": lang } : {} },
+        children
+      };
+    }
+  };
+}
+var DEFAULT_SHIKI, CODE_PIPELINE_VERSION, HIGHLIGHT_RE, highlighters;
+var init_rehype_code = __esm({
+  "src/markdown/rehype-code.ts"() {
+    "use strict";
+    DEFAULT_SHIKI = { themes: { light: "github-light", dark: "github-dark" } };
+    CODE_PIPELINE_VERSION = "shiki4-v1";
+    HIGHLIGHT_RE = /\{((?:\d+(?:-\d+)?,?)+)\}/;
+    highlighters = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/markdown/to-module.ts
+import { toEstree } from "hast-util-to-estree";
+import { toJs, jsx } from "estree-util-to-js";
+function toModule(hast, meta, images = [], demos = []) {
+  const { texts: _texts, ...clientMeta } = meta;
+  const estree = toEstree(hast, { elementAttributeNameCase: "react" });
+  const { value: code } = toJs(estree, { handlers: jsx });
+  let body = code.replace(/;\s*$/, "").trim();
+  const imageImports = images.map((im, i) => {
+    body = body.split(`src="${im.name}"`).join(`src={__dmImg${i}}`);
+    return `import __dmImg${i} from ${JSON.stringify(im.specifier)};
+`;
+  }).join("");
+  const used = ["DomDemo", "DumiDemo", "DomApi", "DumiApi"].filter((n) => new RegExp(`<${n}[\\s/>]`).test(body));
+  const clientNames = [...used];
+  if (demos.length) clientNames.push("registerDemo");
+  const clientImport = clientNames.length ? `import { ${Array.from(new Set(clientNames)).join(", ")} } from '${CLIENT_MODULE}';
+` : "";
+  const demoImports = demos.map((d) => {
+    const specifier = d.src ? d.src : `virtual:dommief-demo/${d.id}`;
+    return `import Demo_${d.id} from ${JSON.stringify(specifier)};
+`;
+  }).join("");
+  const demoRegs = demos.map((d) => `registerDemo(${JSON.stringify(d.id)}, Demo_${d.id});
+`).join("");
+  return `import React from 'react';
+${imageImports}${clientImport}${demoImports}${demoRegs}export default function Content(){ return (
+${body}
+); }
+export const meta = ${JSON.stringify(clientMeta)};
+`;
+}
+var CLIENT_MODULE;
+var init_to_module = __esm({
+  "src/markdown/to-module.ts"() {
+    "use strict";
+    CLIENT_MODULE = "dommief/client";
+  }
+});
+
+// src/markdown/index.ts
+var markdown_exports = {};
+__export(markdown_exports, {
+  transformMarkdown: () => transformMarkdown
+});
+import { unified as unified2 } from "unified";
+import remarkParse2 from "remark-parse";
+import remarkFrontmatter2 from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkDirective from "remark-directive";
+import remarkRehype from "remark-rehype";
+import rehypeRaw from "rehype-raw";
+import "unist-util-visit";
+async function transformMarkdown(source, file, opts = {}) {
+  const host = opts.hooks ?? (opts.plugins ? createPluginHost(opts.plugins) : void 0);
+  const remarkPlugins = [...opts.remarkPlugins ?? [], ...host ? host.collectRemarkPlugins() : []];
+  const rehypePlugins = [...opts.rehypePlugins ?? [], ...host ? host.collectRehypePlugins() : []];
+  let processor;
+  try {
+    processor = unified2().use(remarkParse2).use(remarkFrontmatter2, ["yaml"]).use(remarkGfm).use(remarkDirective).use(remarkContainer).use(remarkMeta, { filename: file }).use(remarkCodeMeta).use(remarkDemoMeta);
+    for (const p of remarkPlugins) processor = processor.use(p);
+    processor = processor.use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw);
+    for (const p of rehypePlugins) processor = processor.use(p);
+    processor = processor.use(rehypeSlug).use(rehypeAutolinkHeadings).use(rehypeLink, opts.byFile ? { byFile: opts.byFile, base: opts.base ?? "/" } : {}).use(rehypeImg).use(rehypeDesc).use(rehypeStrip).use(rehypeText).use(rehypeDemo).use(rehypeCode, opts.code ?? {}).use(rehypeApi);
+  } catch (e) {
+    throw new DommiefError("failed to build pipeline", { file });
+  }
+  const vfile = { data: {}, path: file };
+  let hast;
+  try {
+    const tree = processor.parse(source);
+    hast = await processor.run(tree, vfile);
+  } catch (e) {
+    throw new DommiefError("markdown transform failed: " + e.message, { file });
+  }
+  const apiSrcFiles = vfile.data?.apiSrcFiles ?? [];
+  const meta = {
+    frontmatter: vfile.data?.frontmatter ?? {},
+    toc: vfile.data?.toc ?? [],
+    texts: vfile.data?.texts ?? []
+  };
+  const demos = vfile.data?.demos ?? [];
+  const code = toModule(hast, meta, vfile.data?.images ?? [], demos);
+  return { code, meta, warnings: vfile.data?.warnings ?? [], apiSrcFiles, demos };
+}
+var init_markdown = __esm({
+  "src/markdown/index.ts"() {
+    "use strict";
+    init_remark_meta();
+    init_rehype_slug();
+    init_rehype_link();
+    init_rehype_img();
+    init_rehype_desc();
+    init_rehype_text();
+    init_rehype_demo();
+    init_rehype_api();
+    init_remark_container();
+    init_rehype_code();
+    init_to_module();
+    init_errors();
+    init_plugins();
+  }
+});
+
+// src/search-config.ts
+function createMiniSearchConfig() {
+  const stripDiacritics = (s) => s.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  const processTerm = (term) => {
+    const t = stripDiacritics(term).toLowerCase().replace(/đ/g, "d").normalize("NFC").trim();
+    return t.length ? t : null;
+  };
+  const tokenize = (text) => {
+    const out = [];
+    for (const raw of text.split(/[\s\p{P}]+/u)) {
+      if (!raw) continue;
+      let buf = "";
+      for (const ch of raw) {
+        if (CJK_RANGE.test(ch)) {
+          if (buf) {
+            out.push(buf);
+            buf = "";
+          }
+          out.push(ch);
+        } else {
+          buf += ch;
+        }
+      }
+      if (buf) out.push(buf);
+    }
+    return out;
+  };
+  return { tokenize, processTerm };
+}
+var CJK_RANGE, SEARCH_FIELDS, SEARCH_STORE_FIELDS;
+var init_search_config = __esm({
+  "src/search-config.ts"() {
+    "use strict";
+    CJK_RANGE = /[\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/;
+    SEARCH_FIELDS = ["value", "pageTitle", "sectionTitle"];
+    SEARCH_STORE_FIELDS = ["routeId", "path", "pageTitle", "sectionTitle", "paraId", "value", "pageKey", "sectionKey"];
+  }
+});
+
+// src/search.ts
+var search_exports = {};
+__export(search_exports, {
+  INDEX_BUDGET_BYTES_PER_PAGE: () => INDEX_BUDGET_BYTES_PER_PAGE,
+  SEARCH_FIELDS: () => SEARCH_FIELDS,
+  SEARCH_STORE_FIELDS: () => SEARCH_STORE_FIELDS,
+  buildSearchIndex: () => buildSearchIndex,
+  createMiniSearchConfig: () => createMiniSearchConfig
+});
+import MiniSearch from "minisearch";
+async function buildSearchIndex(opts) {
+  const { routes, loadPageMeta, config } = opts;
+  const cfg = createMiniSearchConfig();
+  const defaultLocale = config.locales[0]?.id;
+  const localesOut = {};
+  const stats = {};
+  const manifestLocales = {};
+  for (const loc of config.locales) {
+    const locRoutes = routes.filter((r) => (r.locale ?? defaultLocale) === loc.id);
+    if (locRoutes.length === 0) continue;
+    const ms = new MiniSearch({
+      fields: [...SEARCH_FIELDS],
+      storeFields: [...SEARCH_STORE_FIELDS],
+      ...cfg
+    });
+    const docs = [];
+    for (const route of locRoutes) {
+      const meta = await loadPageMeta(route);
+      const title = meta.frontmatter?.title || route.id;
+      const toc = meta.toc || [];
+      const fragments = meta.texts || [];
+      for (let i = 0; i < fragments.length; i++) {
+        const f = fragments[i];
+        const tocIndex = f.tocIndex;
+        const sectionTitle = tocIndex !== void 0 && toc[tocIndex] ? toc[tocIndex].title : title;
+        const pageKey = route.id;
+        const sectionKey = `${route.id}::${tocIndex ?? "orphan"}`;
+        docs.push({
+          id: `${route.id}#${f.paraId ?? i}#${i}`,
+          routeId: route.id,
+          path: route.path,
+          pageTitle: title,
+          sectionTitle,
+          paraId: f.paraId ?? 0,
+          value: f.value,
+          pageKey,
+          sectionKey
+        });
+      }
+    }
+    ms.addAll(docs);
+    const json = ms.toJSON();
+    localesOut[loc.id] = json;
+    const bytes = Buffer.byteLength(JSON.stringify(json));
+    stats[loc.id] = { docs: docs.length, bytes, pages: locRoutes.length };
+    manifestLocales[loc.id] = `/search-index/${loc.id}.json`;
+  }
+  return { locales: localesOut, stats, manifest: { locales: manifestLocales } };
+}
+var INDEX_BUDGET_BYTES_PER_PAGE;
+var init_search = __esm({
+  "src/search.ts"() {
+    "use strict";
+    init_search_config();
+    INDEX_BUDGET_BYTES_PER_PAGE = 5 * 1024;
+  }
+});
+
+// src/cli.ts
+import path14 from "path";
+import { cac } from "cac";
+import { createServer } from "vite";
+
+// src/vite/plugin.ts
+import fs9 from "fs";
+import path9 from "path";
+
+// src/config.ts
+init_errors();
+init_plugins();
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+import { loadConfigFromFile } from "vite";
+var LocaleInputSchema = z.object({
+  id: z.string().min(1).refine(
+    (s) => {
+      try {
+        Intl.getCanonicalLocales(s);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    'ph\u1EA3i l\xE0 m\xE3 locale BCP 47 (vd "en-US", "vi-VN"; kh\xF4ng d\xF9ng "_")'
+  ),
+  name: z.string().optional(),
+  base: z.string().startsWith("/", 'ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "/"').optional(),
+  suffix: z.string().optional()
+});
+var ConfigSchema = z.object({
+  title: z.string().default("Dommief"),
+  description: z.string().optional(),
+  base: z.string().startsWith("/", 'ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "/" (URL tuy\u1EC7t \u0111\u1ED1i kh\xF4ng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3)').default("/"),
+  outDir: z.string().default("dist"),
+  srcDir: z.string().default("docs"),
+  /** Khi `library`, tự động quét `src/` để hỗ trợ atom routing cho component library. */
+  preset: z.enum(["docs", "library"]).default("docs"),
+  docDirs: z.array(z.union([z.string(), z.object({ dir: z.string() })])).optional(),
+  forceKebabCase: z.boolean().default(true),
+  locales: z.array(LocaleInputSchema).default([{ id: "en-US", name: "English" }]),
+  themeConfig: z.record(z.string(), z.unknown()).default({}),
+  theme: z.string().default("dommief-theme-default"),
+  ssg: z.object({
+    concurrency: z.number().int().positive().default(4),
+    /** Route không prerender nhưng VẪN phát shell (REVIEW §1 #17). Pattern: path chính xác hoặc `/prefix/*`. */
+    exclude: z.array(z.string()).default([]),
+    /** Route không phát file nào. */
+    noEmit: z.array(z.string()).default([])
+  }).default({ concurrency: 4, exclude: [], noEmit: [] }),
+  /** Cache transform md theo content-hash (DM-406). `--no-cache` tắt. */
+  cache: z.boolean().default(true),
+  /** Kiểm link nội bộ chết lúc build (DM-410). `--no-link-check` tắt. */
+  linkCheck: z.boolean().default(true),
+  dev: z.object({ port: z.number().int().positive().default(5173) }).default({ port: 5173 }),
+  /** sitemap.xml + robots.txt (DM-708, CONFIG §1.5). `false` (mặc định) = không phát; khai
+   * object thì `hostname` BẮT BUỘC (không đoán domain). */
+  sitemap: z.union([z.literal(false), z.object({ hostname: z.string().url(), exclude: z.array(z.string()).default([]) })]).default(false),
+  /** Ghi `robots.txt` trỏ tới sitemap. Mặc định: true nếu có sitemap, ngược lại false. */
+  robots: z.boolean().optional(),
+  /** Shiki lúc build + số dòng (CONFIG §1, DM-706). `shiki: false` = code thô. */
+  markdown: z.object({
+    shiki: z.union([z.literal(false), z.object({ themes: z.object({ light: z.string(), dark: z.string() }) })]).default({ themes: { light: "github-light", dark: "github-dark" } }),
+    lineNumbers: z.boolean().default(false)
+  }).default({ shiki: { themes: { light: "github-light", dark: "github-dark" } }, lineNumbers: false }),
+  /** Search index (DM-801). */
+  search: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
+  plugins: z.array(z.any()).default([])
+}).strict();
+var CONFIG_FILES = ["dommief.config.ts", "dommief.config.mts", "dommief.config.js", "dommief.config.mjs"];
+async function loadConfigFile(opts) {
+  let file;
+  if (opts.configPath) {
+    file = path.resolve(opts.cwd, opts.configPath);
+    if (!fs.existsSync(file)) throw new DommiefError(`kh\xF4ng t\xECm th\u1EA5y file config: ${file}`, { code: "config_not_found", file });
+  } else {
+    file = CONFIG_FILES.map((f) => path.join(opts.cwd, f)).find((p) => fs.existsSync(p));
+    if (!file) return null;
+  }
+  const loaded = await loadConfigFromFile({ command: "serve", mode: "development" }, file, opts.cwd, "silent");
+  if (!loaded) return null;
+  return { path: loaded.path, config: loaded.config };
+}
+function normalizeBase(base) {
+  return base.endsWith("/") ? base : base + "/";
+}
+function resolveConfig(userConfig, opts) {
+  const fileLabel = opts.configFile ? path.basename(opts.configFile) : "dommief.config";
+  const sources = {};
+  for (const k of Object.keys(userConfig ?? {})) sources[k] = fileLabel;
+  let merged = { ...userConfig };
+  const layer = (key, value, source) => {
+    if (value === void 0 || value === "") return;
+    merged[key] = value;
+    sources[key] = source;
+  };
+  if (opts.cli?.cache === false) {
+    merged.cache = false;
+    sources.cache = "--no-cache";
+  }
+  if (opts.cli?.linkCheck === false) {
+    merged.linkCheck = false;
+    sources.linkCheck = "--no-link-check";
+  }
+  layer("base", opts.cli?.base, "--base");
+  layer("outDir", opts.cli?.outDir, "--out-dir");
+  layer("base", opts.env?.DOMMIEF_BASE, "DOMMIEF_BASE");
+  layer("outDir", opts.env?.DOMMIEF_OUT_DIR, "DOMMIEF_OUT_DIR");
+  const fail = (keyPath, message) => {
+    const top = String(keyPath[0] ?? "");
+    const value = keyPath.reduce((v, k) => v?.[k], merged);
+    const shown = value === void 0 ? "(thi\u1EBFu)" : JSON.stringify(value);
+    throw new DommiefError(
+      `c\u1EA5u h\xECnh kh\xF4ng h\u1EE3p l\u1EC7
+  ${formatKeyPath(keyPath)}  ${shown}
+    ${message}
+    (ngu\u1ED3n: ${sources[top] ?? "default"})`,
+      { code: "config_invalid" }
+    );
+  };
+  const pluginHost = createPluginHost(Array.isArray(merged.plugins) ? merged.plugins : []);
+  const modified = pluginHost.applyModifyConfig(merged);
+  if (modified && typeof modified === "object") merged = { ...merged, ...modified };
+  const parsed = ConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    if (issue.code === "unrecognized_keys") {
+      const key = issue.keys[0];
+      const hint = suggestKey(key);
+      fail([key], `key kh\xF4ng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3${hint ? `; b\u1EA1n mu\u1ED1n n\xF3i "${hint}"?` : ""}`);
+    }
+    fail(issue.path, issue.message);
+  }
+  const c = parsed.data;
+  const locales = resolveLocales(c.locales, fail);
+  const config = {
+    root: opts.cwd,
+    title: c.title,
+    base: normalizeBase(c.base),
+    outDir: c.outDir,
+    srcDir: c.srcDir,
+    docDirs: (c.docDirs ?? [c.srcDir]).map((d) => typeof d === "string" ? { dir: d } : { dir: d.dir }),
+    forceKebabCase: c.forceKebabCase,
+    locales,
+    themeConfig: c.themeConfig,
+    theme: c.theme,
+    ssg: c.ssg,
+    cache: c.cache,
+    linkCheck: c.linkCheck,
+    dev: c.dev,
+    sitemap: c.sitemap,
+    robots: c.robots ?? c.sitemap !== false,
+    search: c.search,
+    markdown: c.markdown,
+    plugins: c.plugins ?? []
+  };
+  if (c.description !== void 0) config.description = c.description;
+  return config;
+}
+async function loadConfig(root, cli2) {
+  const file = await loadConfigFile({ cwd: root });
+  return resolveConfig(file?.config ?? {}, { cwd: root, env: process.env, configFile: file?.path, ...cli2 ? { cli: cli2 } : {} });
+}
+function resolveLocales(input, fail) {
+  const suffixMode = input[0]?.suffix !== void 0;
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((l, i) => {
+    if (seen.has(l.id)) fail(["locales", i, "id"], `id "${l.id}" b\u1ECB tr\xF9ng`);
+    seen.add(l.id);
+    const name = l.name ?? l.id;
+    if (suffixMode) {
+      if (l.base !== void 0 || l.suffix === void 0) {
+        fail(["locales", i], 'kh\xF4ng tr\u1ED9n "base" v\xE0 "suffix": locales[0] d\xF9ng ch\u1EBF \u0111\u1ED9 suffix n\xEAn m\u1ECDi locale ph\u1EA3i khai "suffix" v\xE0 kh\xF4ng khai "base"');
+      }
+      return { id: l.id, name, base: "/", suffix: l.suffix };
+    }
+    if (l.suffix !== void 0) {
+      fail(["locales", i], 'kh\xF4ng tr\u1ED9n "base" v\xE0 "suffix": locales[0] d\xF9ng ch\u1EBF \u0111\u1ED9 base n\xEAn kh\xF4ng locale n\xE0o \u0111\u01B0\u1EE3c khai "suffix"');
+    }
+    const base = normalizeBase(l.base ?? (i === 0 ? "/" : `/${l.id}/`));
+    if (i > 0 && base === "/") {
+      fail(["locales", i, "base"], `ch\u1EC9 locale \u0111\u1EA7u ti\xEAn \u0111\u01B0\u1EE3c d\xF9ng base "/". \u0110\u01B0a "${l.id}" l\xEAn \u0111\u1EA7u m\u1EA3ng ho\u1EB7c \u0111\u1ED5i base.`);
+    }
+    return { id: l.id, name, base, suffix: "" };
+  });
+}
+function formatKeyPath(keyPath) {
+  return keyPath.map((k, i) => typeof k === "number" ? `[${k}]` : i === 0 ? k : `.${k}`).join("");
+}
+function suggestKey(key) {
+  let best;
+  let bestDist = 3;
+  for (const known of Object.keys(ConfigSchema.shape)) {
+    const d = editDistance(key, known);
+    if (d < bestDist) [best, bestDist] = [known, d];
+  }
+  return best;
+}
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+}
+
+// src/vite/plugin.ts
+init_plugins();
+init_markdown();
+
+// src/paths.ts
+init_errors();
+import fs3 from "fs";
+import { fileURLToPath } from "url";
+function resolveClientFile(name) {
+  const candidates = [`./client/${name}`, `../src/client/${name}`].map((rel) => fileURLToPath(new URL(rel, import.meta.url)));
+  const hit = candidates.find((p) => fs3.existsSync(p));
+  if (!hit) {
+    throw new DommiefError(`kh\xF4ng t\xECm th\u1EA5y client/${name} c\u1EE7a dommief (\u0111\xE3 th\u1EED: ${candidates.join(", ")}). Package c\xE0i thi\u1EBFu th\u01B0 m\u1EE5c "src".`, { code: "client_entry_missing" });
+  }
+  return hit;
+}
+function resolveThemeApiFile() {
+  const candidates = ["./theme-api.tsx", "../src/theme-api.tsx"].map((rel) => fileURLToPath(new URL(rel, import.meta.url)));
+  const hit = candidates.find((p) => fs3.existsSync(p));
+  if (!hit) {
+    throw new DommiefError(`kh\xF4ng t\xECm th\u1EA5y theme-api.tsx c\u1EE7a dommief (\u0111\xE3 th\u1EED: ${candidates.join(", ")})`, { code: "client_entry_missing" });
+  }
+  return hit;
+}
+
+// src/routesModule.ts
+init_path();
+function createRouteModule(lazy, id, path15, load) {
+  let mod;
+  let promise;
+  const preload = () => {
+    if (!promise) promise = load().then((m) => {
+      mod = m;
+      return m;
+    });
+    return promise;
+  };
+  const component = lazy(() => mod ? { then: (res) => res(mod) } : preload());
+  return { id, path: path15, component, preload };
+}
+function createRoutesModule(routes) {
+  const entries = routes.map(
+    (r) => `  createRouteModule(React.lazy, ${JSON.stringify(r.id)}, ${JSON.stringify(r.path)}, () => import(${JSON.stringify(winPath(r.file))})),`
+  );
+  return `import React from "react";
+const createRouteModule = ${createRouteModule.toString()};
+export default [
+${entries.join("\n")}
+];
+`;
+}
+
+// src/vite/routesPlugin.ts
+function dommiefRoutesPlugin(state) {
+  const virtualId = "virtual:dommief/routes";
+  const resolvedId = "\0" + virtualId;
+  let server = null;
+  const invalidate = () => {
+    state.resetTable();
+    const mod = server?.moduleGraph.getModuleById(resolvedId);
+    if (mod) server.moduleGraph.invalidateModule(mod);
+  };
+  return {
+    name: "dommief:routes",
+    enforce: "pre",
+    configureServer(s) {
+      server = s;
+    },
+    resolveId(id) {
+      if (id === virtualId) return resolvedId;
+      return null;
+    },
+    load(id) {
+      if (id !== resolvedId) return null;
+      return { code: createRoutesModule(state.getTable().routes), map: null };
+    },
+    watchChange(id, { event }) {
+      if (!id.endsWith(".md")) return;
+      if (event === "create" || event === "delete") {
+        invalidate();
+        server?.ws.send({ type: "full-reload" });
+      }
+    }
+  };
+}
+
+// src/vite/sitePlugin.ts
+import { createHash as createHash3 } from "crypto";
+import { readFileSync } from "fs";
+
+// src/siteFeatures.ts
+init_remark_meta();
+function fmFor(map, route) {
+  if (!map) return {};
+  return map[route.id] ?? map[route.file] ?? {};
+}
+function localeId(route, locales) {
+  if (route.locale) return route.locale;
+  return locales[0]?.id ?? "default";
+}
+function titleOf(route, fm) {
+  const t = fm.title ?? fm.navTitle ?? fm.sidebarTitle;
+  if (typeof t === "string" && t.trim()) return t;
+  return route.id.split("/").pop() ?? route.id;
+}
+function orderOf(fm) {
+  const v = fm.order ?? fm.navOrder ?? fm.sidebarOrder;
+  return typeof v === "number" ? v : Number(v ?? 0) || 0;
+}
+function buildNav(routes, frontmatter, locales = []) {
+  const out = {};
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const lid = localeId(route, locales);
+    const fm = fmFor(frontmatter, route);
+    const navFlag = fm.nav;
+    if (navFlag === false) continue;
+    const item = {
+      title: titleOf(route, fm),
+      link: route.path,
+      order: orderOf(fm),
+      activePath: route.path
+    };
+    const arr = groups.get(lid) ?? [];
+    arr.push(item);
+    groups.set(lid, arr);
+  }
+  for (const [lid, items] of groups) {
+    out[lid] = items.sort((a, b) => a.order - b.order || String(a.link).localeCompare(String(b.link)));
+  }
+  for (const l of locales) {
+    if (!out[l.id]) out[l.id] = [];
+  }
+  return out;
+}
+function buildSidebar(routes, frontmatter, locales = []) {
+  const out = {};
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const lid = localeId(route, locales);
+    const fm = fmFor(frontmatter, route);
+    const groupTitle = typeof fm.group === "string" && fm.group.trim() ? fm.group : route.id.split("/")[0] ?? "General";
+    const item = {
+      title: titleOf(route, fm),
+      link: route.path,
+      order: orderOf(fm),
+      ...Object.keys(fm).length ? { frontmatter: fm } : {}
+    };
+    let groups = byLocale.get(lid);
+    if (!groups) {
+      groups = /* @__PURE__ */ new Map();
+      byLocale.set(lid, groups);
+    }
+    let g = groups.get(groupTitle);
+    if (!g) {
+      g = { title: groupTitle, order: orderOf(fm), children: [] };
+      groups.set(groupTitle, g);
+    }
+    g.children.push(item);
+    g.order = Math.min(g.order, orderOf(fm));
+  }
+  for (const [lid, groups] of byLocale) {
+    const arr = [...groups.values()].map((g) => ({
+      ...g,
+      children: g.children.sort((a, b) => a.order - b.order || a.link.localeCompare(b.link))
+    }));
+    out[lid] = arr.sort((a, b) => a.order - b.order || String(a.title).localeCompare(String(b.title)));
+  }
+  for (const l of locales) {
+    if (!out[l.id]) out[l.id] = [];
+  }
+  return out;
+}
+
+// src/siteModule.ts
+function createSiteModule({ routes, config, meta }) {
+  const routesById = Object.fromEntries(routes.map((r) => [r.id, r]));
+  const frontmatter = config.frontmatter ?? {};
+  const nav = buildNav(routes, frontmatter, config.locales);
+  const sidebar = buildSidebar(routes, frontmatter, config.locales);
+  const head = {
+    base: config.base,
+    title: config.title,
+    ...config.description === void 0 ? {} : { description: config.description },
+    locales: config.locales,
+    themeConfig: config.themeConfig ?? {},
+    routes: routesById,
+    search: config.search ?? { enabled: true }
+  };
+  const json = JSON.stringify(head);
+  return `export default {
+  ...${json},
+  meta: ${JSON.stringify(meta)},
+  nav: ${JSON.stringify(nav)},
+  sidebar: ${JSON.stringify(sidebar)},
+};
+`;
+}
+
+// src/vite/sitePlugin.ts
+init_remark_meta();
+function frontmatterHash(file) {
+  let raw;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const block = m?.[1] ?? "";
+  const headings = raw.match(/^#{1,6}\s.*$/gm)?.join("\n") ?? "";
+  return createHash3("sha256").update(block + "\n--\n" + headings).digest("hex").slice(0, 16);
+}
+function dommiefSitePlugin(state) {
+  const virtualId = "virtual:dommief/site";
+  const resolvedId = "\0" + virtualId;
+  let frontmatterHashes = /* @__PURE__ */ new Map();
+  let cache2 = null;
+  let server = null;
+  const invalidate = () => {
+    cache2 = null;
+    state.resetTable();
+    const mod = server?.moduleGraph.getModuleById(resolvedId);
+    if (mod) server.moduleGraph.invalidateModule(mod);
+  };
+  return {
+    name: "dommief:site",
+    enforce: "pre",
+    configureServer(s) {
+      server = s;
+    },
+    resolveId(id) {
+      if (id === virtualId) return resolvedId;
+      return null;
+    },
+    load(id) {
+      if (id !== resolvedId) return null;
+      if (cache2) return { code: cache2, map: null };
+      const config = state.config();
+      const t = state.getTable();
+      const summaries = new Map(t.routes.map((r) => {
+        let raw;
+        try {
+          raw = readFileSync(r.file, "utf8");
+        } catch {
+          raw = "";
+        }
+        return [r.id, extractPageSummary(raw, r.file, (m) => this.warn(m))];
+      }));
+      const frontmatter = Object.fromEntries([...summaries].map(([id2, s]) => [id2, s.frontmatter]));
+      const meta = Object.fromEntries([...summaries].map(([id2, s]) => [id2, s]));
+      const code = createSiteModule({
+        routes: t.routes,
+        config: {
+          base: config.base,
+          title: config.title,
+          description: config.description,
+          locales: config.locales,
+          themeConfig: config.themeConfig,
+          frontmatter,
+          search: { enabled: config.search.enabled }
+        },
+        meta
+      });
+      frontmatterHashes = new Map(t.routes.map((r) => [r.file, frontmatterHash(r.file)]));
+      cache2 = code;
+      return { code, map: null };
+    },
+    handleHotUpdate(ctx) {
+      const id = ctx.file;
+      if (!id.endsWith(".md")) return;
+      const oldHash = frontmatterHashes.get(id);
+      const newHash = frontmatterHash(id);
+      if (oldHash !== void 0 && oldHash !== newHash) {
+        frontmatterHashes.set(id, newHash);
+        invalidate();
+      }
+    },
+    watchChange(id, { event }) {
+      if (!id.endsWith(".md")) return;
+      if (event === "create" || event === "delete") {
+        invalidate();
+        server?.ws.send({ type: "full-reload" });
+      }
+    }
+  };
+}
+
+// src/vite/searchIndexPlugin.ts
+import fs4 from "fs";
+var VIRTUAL_ID = "virtual:dommief/search-index";
+var RESOLVED_ID = "\0" + VIRTUAL_ID;
+var PREFIX = "/search-index/";
+function dommiefSearchIndexPlugin(state) {
+  return {
+    name: "dommief:search-index",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return RESOLVED_ID;
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_ID) return null;
+      const config = state.config();
+      if (!config.search.enabled) return { code: "export const manifest = { locales: {} }; export default manifest;\n", map: null };
+      const locales = Object.fromEntries((config.locales ?? []).map((l) => [l.id, `${config.base}search-index/${l.id}.json`]));
+      return { code: `export const manifest = ${JSON.stringify({ locales })}; export default manifest;
+`, map: null };
+    },
+    configureServer(s) {
+      s.middlewares.use(async (req, res, next) => {
+        const url = req.url?.split("?")[0] ?? "";
+        if (!url.endsWith(".json")) return next();
+        const base = (state.config().base || "/").replace(/\/$/, "") || "";
+        const localPath = base && url.startsWith(base + PREFIX) ? url.slice((base + PREFIX).length) : url.startsWith(PREFIX) ? url.slice(PREFIX.length) : null;
+        if (localPath === null) return next();
+        const localeId2 = localPath.replace(/\.json$/, "");
+        if (!state.config().locales?.some((l) => l.id === localeId2)) return next();
+        if (!state.config().search.enabled) {
+          res.statusCode = 404;
+          return res.end();
+        }
+        try {
+          const { buildSearchIndex: buildSearchIndex2 } = await Promise.resolve().then(() => (init_search(), search_exports));
+          const { transformMarkdown: transformMarkdown2 } = await Promise.resolve().then(() => (init_markdown(), markdown_exports));
+          const t = state.getTable();
+          const routes = t.routes.filter((r) => (r.locale ?? state.config().locales[0]?.id) === localeId2);
+          const resIdx = await buildSearchIndex2({
+            routes,
+            loadPageMeta: async (r) => {
+              let raw;
+              try {
+                raw = fs4.readFileSync(r.file, "utf8");
+              } catch {
+                raw = "";
+              }
+              const tr = await transformMarkdown2(raw, r.file, { hooks: state.host(), byFile: t.byFile, base: state.config().base, code: state.config().markdown });
+              return tr.meta;
+            },
+            config: { locales: state.config().locales }
+          });
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(resIdx.locales[localeId2] ?? {}));
+        } catch (e) {
+          res.statusCode = 500;
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "search index build failed" }));
+        }
+      });
+    }
+  };
+}
+
+// src/routes.ts
+init_errors();
+init_path();
+init_plugins();
+import fs5 from "fs";
+import path5 from "path";
+import { createHash as createHash4 } from "crypto";
+var INDEX_NAMES = /* @__PURE__ */ new Set(["index", "README"]);
+var SEGMENT_OK = /^[\p{L}\p{N}_-]+$/u;
+function listMarkdownFiles(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const e of fs5.readdirSync(d, { withFileTypes: true })) {
+      if (e.name.startsWith(".") || e.name.startsWith("_") || e.name === "node_modules") continue;
+      const p = path5.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && e.name.endsWith(".md")) out.push(winPath(p));
+    }
+  };
+  walk(dir);
+  return out.sort();
+}
+function scanRoutes({ cwd, config }) {
+  const routes = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const docDirs = config.preset === "library" && !(config.docDirs || []).some((d) => d.dir === "src") ? [...config.docDirs || [], { dir: "src" }] : config.docDirs || [];
+  for (const { dir } of docDirs) {
+    const absDir = path5.resolve(cwd, dir);
+    if (!fs5.existsSync(absDir)) {
+      warnings.push(`doc_dir_missing: docDirs "${dir}" kh\xF4ng t\u1ED3n t\u1EA1i (${winPath(absDir)})`);
+      continue;
+    }
+    for (const file of listMarkdownFiles(absDir)) {
+      if (seen.has(file)) {
+        warnings.push(`route_duplicate_file: ${file} n\u1EB1m trong nhi\u1EC1u docDirs, gi\u1EEF docDir khai tr\u01B0\u1EDBc`);
+        continue;
+      }
+      seen.add(file);
+      const id = path5.posix.relative(winPath(absDir), file).slice(0, -".md".length);
+      routes.push({ id, path: `/${id}`, file });
+    }
+  }
+  return { routes, warnings };
+}
+function kebab(segment, localeId2) {
+  return segment.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLocaleLowerCase(localeId2);
+}
+function normalizeRoutes(raw, { cwd, config }) {
+  const warnings = [];
+  const errors = [];
+  const show = (file) => path5.posix.relative(winPath(cwd), file) || file;
+  const defaultLocale = config.locales[0];
+  const items = [];
+  for (const r of raw) {
+    const segs = r.id.split("/");
+    let name = segs.pop();
+    const dir = segs.join("/");
+    let locale = defaultLocale;
+    let suffixStripped = false;
+    const hit = config.locales.find((l) => name.endsWith("." + l.id));
+    if (hit) {
+      locale = hit;
+      suffixStripped = true;
+      name = name.slice(0, -(hit.id.length + 1));
+    } else {
+      const last = name.slice(name.lastIndexOf(".") + 1);
+      const typo = name.includes(".") && config.locales.find((l) => l.id.toLowerCase() === last.toLowerCase());
+      if (typo) warnings.push(`locale_unknown_suffix: ${show(r.file)} c\xF3 h\u1EADu t\u1ED1 ".${last}" g\u1EA7n gi\u1ED1ng locale "${typo.id}" nh\u01B0ng kh\xF4ng kh\u1EDBp; x\u1EED l\xFD nh\u01B0 file th\u01B0\u1EDDng`);
+    }
+    const indexName = INDEX_NAMES.has(name) ? name : void 0;
+    const parts = indexName ? segs : [...segs, name];
+    const split = parts.flatMap((s) => s.split("."));
+    const dotted = split.length !== parts.length;
+    const routePath = split.filter(Boolean).map((s) => config.forceKebabCase ? kebab(s, locale.id) : s).join("/").normalize("NFC");
+    const bad = routePath.split("/").find((s) => s && !SEGMENT_OK.test(s));
+    if (bad) {
+      const ch = [...bad].find((c) => !SEGMENT_OK.test(c));
+      errors.push({
+        code: "route_invalid_path",
+        message: `dommief: routes: k\xFD t\u1EF1 kh\xF4ng h\u1EE3p l\u1EC7 "${ch}" trong \u0111\u01B0\u1EDDng d\u1EABn c\u1EE7a file
+  ${show(r.file)}
+  segment ch\u1EC9 \u0111\u01B0\u1EE3c ch\u1EE9a ch\u1EEF, s\u1ED1, "-" v\xE0 "_". \u0110\u1ED5i t\xEAn file.`
+      });
+    } else if (/[^\x00-\x7F]/.test(routePath)) {
+      warnings.push(`route_non_ascii: ${show(r.file)} \u2192 "/${routePath}" c\xF3 k\xFD t\u1EF1 ngo\xE0i ASCII; NFC/NFD v\xE0 hosting t\u0129nh c\xF3 th\u1EC3 l\u1EC7ch, n\xEAn \u0111\u1EB7t t\xEAn file ASCII`);
+    }
+    const joined = locale.suffix ? `/${routePath}${locale.suffix}` : `${locale.base}${routePath}`;
+    const p = joined.replace(/\/{2,}/g, "/").replace(/(.)\/$/, "$1");
+    items.push({
+      // locale mặc định ⇒ không có key (JSON round-trip giữ nguyên object)
+      route: { id: r.id, path: p, file: r.file, ...locale === defaultLocale ? {} : { locale: locale.id } },
+      routePath,
+      locale,
+      suffixStripped,
+      ...indexName === void 0 ? {} : { indexName },
+      dir,
+      dotted
+    });
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const it of items) byId.set(it.route.id, [...byId.get(it.route.id) ?? [], it]);
+  for (const [id, group] of byId) {
+    if (group.length < 2) continue;
+    errors.push({
+      code: "route_duplicate",
+      message: `dommief: routes: tr\xF9ng route id "${id}" (${group.length} file)
+${group.map((g) => `  ${show(g.route.file)}`).join("\n")}
+  id l\xE0 \u0111\u01B0\u1EDDng d\u1EABn t\u01B0\u01A1ng \u0111\u1ED1i trong docDir. \u0110\u1ED5i t\xEAn file ho\u1EB7c t\xE1ch docDir th\xE0nh 2 site.`
+    });
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const it of items) {
+    if ((byId.get(it.route.id)?.length ?? 0) > 1) continue;
+    const key = it.route.path.toLowerCase();
+    byPath.set(key, [...byPath.get(key) ?? [], it]);
+  }
+  for (const group of byPath.values()) {
+    if (group.length < 2) continue;
+    errors.push({
+      code: "route_duplicate",
+      message: `dommief: routes: tr\xF9ng \u0111\u01B0\u1EDDng d\u1EABn "${group[0].route.path}" (${group.length} file)
+${group.map((g) => `  ${show(g.route.file)}`).join("\n")}
+  nguy\xEAn nh\xE2n: ${duplicateCause(group[0], group[1])}`
+    });
+  }
+  if (errors.length) {
+    throw new DommiefError(errors.map((e) => e.message).join("\n\n"), { code: errors[0].code });
+  }
+  return { routes: items.map((it) => it.route), warnings };
+}
+function duplicateCause(a, b) {
+  const base = (n) => path5.posix.basename(n.route.file);
+  const stripped = a.suffixStripped ? a : b.suffixStripped ? b : void 0;
+  if (stripped && a.locale === b.locale) {
+    const other = stripped === a ? b : a;
+    const owner = stripped.route.locale ? `locale "${stripped.locale.id}"` : "locale m\u1EB7c \u0111\u1ECBnh";
+    return `"${base(stripped)}" thu\u1ED9c ${owner} n\xEAn tr\xF9ng "${base(other)}"`;
+  }
+  const dirName = (n) => n.dir || "/";
+  if (a.indexName && b.indexName) return `c\u1EA3 "${a.indexName}.md" v\xE0 "${b.indexName}.md" \u0111\u1EC1u g\u1ED9p v\xE0o "${dirName(a)}"`;
+  const idx = a.indexName ? a : b.indexName ? b : void 0;
+  if (idx) return `"${idx.indexName}.md" g\u1ED9p v\xE0o th\u01B0 m\u1EE5c "${dirName(idx)}"`;
+  if (a.route.id.toLowerCase() === b.route.id.toLowerCase()) return "tr\xF9ng sau khi kebab (macOS/Windows kh\xF4ng ph\xE2n bi\u1EC7t hoa th\u01B0\u1EDDng)";
+  if (a.dotted || b.dotted) return '"." trong t\xEAn file \u0111\u01B0\u1EE3c \u0111\u1ED5i th\xE0nh "/"';
+  return "kebab-case l\xE0m hai file tr\xF9ng nhau";
+}
+function routeConfigHash(config) {
+  const { srcDir, docDirs, locales, forceKebabCase, preset } = config;
+  const json = JSON.stringify({
+    srcDir,
+    docDirs: docDirs.map((d) => d.dir),
+    locales: locales.map(({ id, name, base, suffix }) => ({ id, name, base, suffix })),
+    forceKebabCase,
+    preset: preset ?? "docs"
+  });
+  return createHash4("sha256").update(json).digest("hex").slice(0, 8);
+}
+function buildRouteTable({ cwd, config, hooks, plugins }) {
+  const host = hooks ?? (plugins ? createPluginHost(plugins) : config?.plugins ? createPluginHost(config.plugins) : void 0);
+  const scan = scanRoutes({ cwd, config });
+  const norm = normalizeRoutes(scan.routes, { cwd, config });
+  const cmp = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+  let routes = norm.routes;
+  if (host) routes = host.applyModifyRoutes(routes);
+  routes = routes.sort((a, b) => cmp(a.path, b.path) || cmp(a.id, b.id));
+  const table = {
+    warnings: [...scan.warnings, ...norm.warnings],
+    routes,
+    byId: {},
+    byPath: {},
+    byFile: {},
+    configHash: routeConfigHash(config)
+  };
+  for (const r of routes) {
+    table.byId[r.id] = r;
+    table.byPath[r.path] = r;
+    table.byFile[r.file] = r;
+  }
+  return table;
+}
+
+// src/vite/state.ts
+function createState(cwd, get) {
+  let table = null;
+  return {
+    cwd,
+    config: () => get().config,
+    host: () => get().host,
+    getTable: () => table ??= buildRouteTable({ cwd, config: get().config, hooks: get().host }),
+    resetTable: () => {
+      table = null;
+    }
+  };
+}
+
+// src/vite/plugin.ts
+init_path();
+
+// src/theme/resolver.ts
+init_errors();
+import fs7 from "fs";
+import path7 from "path";
+
+// src/theme/loader.ts
+init_errors();
+import fs6 from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var EXTS = [".tsx", ".ts", ".jsx", ".js"];
+var DEFAULT_THEME = "dommief-theme-default";
+function isComponentName(name) {
+  return /^[A-Z0-9]/.test(name);
+}
+function repoPackagesDir() {
+  let cur = path6.dirname(fileURLToPath2(import.meta.url));
+  while (cur !== path6.parse(cur).root) {
+    if (fs6.existsSync(path6.join(cur, "pnpm-workspace.yaml"))) return path6.join(cur, "packages");
+    cur = path6.dirname(cur);
+  }
+  return null;
+}
+function assertInside(cwd, target, theme) {
+  const rel = path6.relative(cwd, target);
+  const insideCwd = rel === "" || !rel.startsWith("..") && !path6.isAbsolute(rel);
+  const insideNodeModules = target.split(path6.sep).includes("node_modules");
+  if (!insideCwd && !insideNodeModules) {
+    throw new DommiefError(`\u0111\u01B0\u1EDDng d\u1EABn theme "${theme}" tho\xE1t ra ngo\xE0i th\u01B0 m\u1EE5c d\u1EF1 \xE1n: ${target}`, { code: "theme_path_escape", file: target });
+  }
+}
+function resolveThemeRoot(cwd, theme) {
+  const isPathLike = theme.startsWith(".") || theme.startsWith("/");
+  let root = null;
+  if (isPathLike) {
+    const candidate = path6.resolve(cwd, theme);
+    if (fs6.existsSync(candidate) && fs6.statSync(candidate).isDirectory()) root = candidate;
+    if (!root) throw new DommiefError(`kh\xF4ng t\xECm th\u1EA5y theme t\u1EA1i \u0111\u01B0\u1EDDng d\u1EABn "${theme}"`, { code: "theme_package_not_found" });
+    assertInside(cwd, root, theme);
+  } else {
+    const nmCandidate = path6.resolve(cwd, "node_modules", theme);
+    if (fs6.existsSync(nmCandidate)) root = nmCandidate;
+    else {
+      const packages = repoPackagesDir();
+      const pkgDirName = theme === DEFAULT_THEME ? "theme-default" : theme;
+      const srcCandidate = packages ? path6.join(packages, pkgDirName) : null;
+      if (srcCandidate && fs6.existsSync(srcCandidate)) root = srcCandidate;
+    }
+    if (!root) {
+      throw new DommiefError(`kh\xF4ng t\xECm th\u1EA5y theme package "${theme}" (\u0111\xE3 th\u1EED node_modules/${theme})`, { code: "theme_package_not_found" });
+    }
+  }
+  if (fs6.existsSync(path6.join(root, "src", "layouts"))) root = path6.join(root, "src");
+  return root;
+}
+function pickEntry(dir, name) {
+  for (const ext of EXTS) {
+    const f = path6.join(dir, name + ext);
+    if (fs6.existsSync(f) && fs6.statSync(f).isFile()) return f;
+  }
+  const subIndexDir = path6.join(dir, name);
+  if (fs6.existsSync(subIndexDir) && fs6.statSync(subIndexDir).isDirectory()) {
+    for (const ext of EXTS) {
+      const f = path6.join(subIndexDir, "index" + ext);
+      if (fs6.existsSync(f) && fs6.statSync(f).isFile()) return f;
+    }
+  }
+  return null;
+}
+function scanComponents(dir) {
+  const out = {};
+  if (!fs6.existsSync(dir)) return out;
+  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+    const name = entry.name;
+    if (!isComponentName(name)) continue;
+    if (entry.isFile()) {
+      const ext = EXTS.find((e) => name.endsWith(e));
+      if (!ext) continue;
+      const specifier = name.slice(0, -ext.length);
+      if (!isComponentName(specifier)) continue;
+      out[specifier] ??= path6.resolve(dir, name);
+    } else if (entry.isDirectory()) {
+      const found = pickEntry(dir, name);
+      if (found) out[name] = path6.resolve(found);
+    }
+  }
+  return out;
+}
+function scanLocales(dir) {
+  const out = {};
+  if (!fs6.existsSync(dir)) return out;
+  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith(".json")) {
+      out[entry.name.slice(0, -".json".length)] = path6.resolve(dir, entry.name);
+    }
+  }
+  return out;
+}
+function loadThemeManifest(root, name) {
+  const layoutsDir = path6.join(root, "layouts");
+  const layouts = {};
+  const missing = [];
+  for (const layoutName of ["GlobalLayout", "DocLayout", "DemoLayout"]) {
+    const p = pickEntry(layoutsDir, layoutName);
+    if (p) layouts[layoutName] = p;
+    else missing.push(layoutName);
+  }
+  if (missing.length) {
+    throw new DommiefError(`theme "${name}" thi\u1EBFu layout: ${missing.join(", ")}`, { code: "theme_layout_missing", file: layoutsDir, layout: missing.join(",") });
+  }
+  const pluginJs = ["plugin.ts", "plugin.js", path6.join("plugin", "index.ts"), path6.join("plugin", "index.js")].map((f) => path6.join(root, f)).find((f) => fs6.existsSync(f));
+  return {
+    name,
+    root,
+    builtins: scanComponents(path6.join(root, "builtins")),
+    slots: scanComponents(path6.join(root, "slots")),
+    layouts,
+    locales: scanLocales(path6.join(root, "locales")),
+    plugin: pluginJs ?? null
+  };
+}
+function loadTheme(opts) {
+  const cwd = path6.resolve(opts.cwd);
+  const theme = opts.theme ?? DEFAULT_THEME;
+  const root = resolveThemeRoot(cwd, theme);
+  return loadThemeManifest(root, theme);
+}
+
+// src/theme/resolver.ts
+function tryLoadLocal(cwd) {
+  const localRoot = path7.resolve(cwd, ".dommief", "theme");
+  if (!fs7.existsSync(localRoot)) return null;
+  const layoutsDir = path7.join(localRoot, "layouts");
+  const layouts = {};
+  for (const name of ["GlobalLayout", "DocLayout", "DemoLayout"]) {
+    const found = scanComponents(layoutsDir)[name];
+    if (found) layouts[name] = found;
+  }
+  return {
+    name: ".dommief/theme",
+    root: localRoot,
+    builtins: scanComponents(path7.join(localRoot, "builtins")),
+    slots: scanComponents(path7.join(localRoot, "slots")),
+    layouts,
+    locales: {},
+    plugin: null
+  };
+}
+function loadThemeChain(cwd, config) {
+  const themeName = config.theme ?? DEFAULT_THEME;
+  const pkg = loadTheme({ cwd, theme: themeName });
+  const fallback = themeName === DEFAULT_THEME ? pkg : loadTheme({ cwd, theme: DEFAULT_THEME });
+  return { local: tryLoadLocal(cwd), pkg, fallback };
+}
+function manifestsOf(chain) {
+  const list = [chain.local, chain.pkg, chain.pkg === chain.fallback ? null : chain.fallback].filter((m) => m !== null);
+  return list;
+}
+function resolveSlot(name, kind, chain) {
+  for (const m of manifestsOf(chain)) {
+    const hit = kind === "layouts" ? m.layouts[name] : kind === "locales" ? m.locales[name] : m[kind][name];
+    if (hit) return hit;
+  }
+  throw new DommiefError(`kh\xF4ng c\xF3 theme n\xE0o cung c\u1EA5p ${kind}/${name}`, { code: "theme_slot_missing" });
+}
+function allNames(chain, kind) {
+  const names = /* @__PURE__ */ new Set();
+  for (const m of manifestsOf(chain)) {
+    const map = kind === "layouts" ? m.layouts : kind === "locales" ? m.locales : m[kind];
+    for (const k of Object.keys(map)) names.add(k);
+  }
+  return [...names];
+}
+function buildAliasChain(cwd, config) {
+  const chain = loadThemeChain(cwd, config);
+  const aliases = {};
+  for (const kind of ["slots", "builtins", "layouts"]) {
+    for (const name of allNames(chain, kind)) {
+      aliases[`dommief/theme/${kind}/${name}`] = resolveSlot(name, kind, chain);
+    }
+  }
+  aliases["dommief/theme"] = chain.pkg.root;
+  return aliases;
+}
+
+// src/cache.ts
+init_rehype_code();
+import { createHash as createHash5 } from "crypto";
+import fs8 from "fs";
+import path8 from "path";
+var CACHE_VERSION = 3;
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value && typeof value === "object") {
+    const o = value;
+    return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+var sha = (s) => createHash5("sha256").update(s).digest("hex");
+function hashKey(input) {
+  return sha(stableStringify({ ...input, version: input.version ?? CACHE_VERSION }));
+}
+function computeRoutesHash(byFile) {
+  return sha(stableStringify(Object.fromEntries(Object.entries(byFile).map(([f, r]) => [f, r.path]))));
+}
+function computePipelineHash(opts) {
+  const plugins = (opts.plugins ?? []).map((p) => typeof p === "function" ? String(p) : stableStringify(p));
+  return sha(stableStringify({ code: opts.code ?? null, plugins, codeVersion: CODE_PIPELINE_VERSION }));
+}
+var TransformCache = class {
+  constructor(dir, enabled = true) {
+    this.dir = dir;
+    this.enabled = enabled;
+    if (!enabled) return;
+    try {
+      this.manifest = JSON.parse(fs8.readFileSync(path8.join(dir, "manifest.json"), "utf8"));
+    } catch {
+      this.manifest = {};
+    }
+  }
+  dir;
+  enabled;
+  stats = { hit: 0, miss: 0, missReasons: {} };
+  counted = /* @__PURE__ */ new Set();
+  used = /* @__PURE__ */ new Set();
+  manifest = {};
+  nextManifest = {};
+  fileOf(key) {
+    return path8.join(this.dir, key.slice(0, 2), `${key}.json`);
+  }
+  read(key) {
+    if (!this.enabled) return null;
+    try {
+      const v = JSON.parse(fs8.readFileSync(this.fileOf(key), "utf8"));
+      return typeof v?.code === "string" && v.meta ? v : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Ghi nguyên tử: tmp cùng thư mục rồi rename (build bị kill giữa chừng không để lại JSON cụt; cùng ổ nên rename không fail trên Windows). */
+  write(key, payload) {
+    if (!this.enabled) return;
+    const file = this.fileOf(key);
+    fs8.mkdirSync(path8.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs8.writeFileSync(tmp, JSON.stringify(payload));
+    fs8.renameSync(tmp, file);
+  }
+  /** Xoá file cache không còn dùng (trang bị xoá/đổi tên/đổi nội dung). Best-effort, không throw. */
+  gc(keepKeys) {
+    if (!this.enabled) return;
+    try {
+      for (const shard of fs8.readdirSync(this.dir, { withFileTypes: true })) {
+        if (!shard.isDirectory()) continue;
+        for (const f of fs8.readdirSync(path8.join(this.dir, shard.name))) {
+          if (!keepKeys.has(f.replace(/\.json$/, "")) || f.endsWith(".tmp")) fs8.rmSync(path8.join(this.dir, shard.name, f), { force: true });
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Lấy từ cache hoặc tính mới. Mỗi file chỉ tính vào `stats` ở lần tra ĐẦU: build chạy plugin 2 lần
+   * (client + SSR), lần 2 luôn hit vì lần 1 vừa ghi — đếm cả hai sẽ làm số liệu vô nghĩa.
+   */
+  async getOrCompute(file, input, compute, cacheable = true) {
+    const key = hashKey(input);
+    const context = sha(stableStringify({ base: input.base, routesHash: input.routesHash }));
+    const first = !this.counted.has(file);
+    const hit = cacheable ? this.read(key) : null;
+    if (hit) {
+      if (first) this.stats.hit++;
+      this.record(file, key, input, context);
+      return hit;
+    }
+    if (first) {
+      this.stats.miss++;
+      this.stats.missReasons[file] = this.reasonFor(file, input, context);
+    }
+    this.counted.add(file);
+    const payload = await compute();
+    if (cacheable) {
+      this.write(key, payload);
+      this.record(file, key, input, context);
+    }
+    return payload;
+  }
+  record(file, key, input, context) {
+    this.counted.add(file);
+    this.used.add(key);
+    this.nextManifest[file] = { md: sha(input.md), context: `${context}|${input.pipelineHash}`, key };
+  }
+  reasonFor(file, input, context) {
+    const prev = this.manifest[file];
+    if (!prev) return "new";
+    if (prev.md !== sha(input.md)) return "md-changed";
+    const [prevCtx, prevPipe] = [prev.context.split("|")[0], prev.context.split("|")[1]];
+    if (prevPipe !== input.pipelineHash) return "pipeline-changed";
+    return prevCtx !== context ? "config-changed" : "md-changed";
+  }
+  /** Cuối build: ghi manifest + gc theo các key vừa dùng. Chỉ giữ entry của file còn tồn tại. */
+  finish() {
+    if (!this.enabled) return;
+    this.gc(this.used);
+    try {
+      fs8.mkdirSync(this.dir, { recursive: true });
+      fs8.writeFileSync(path8.join(this.dir, "manifest.json"), JSON.stringify(this.nextManifest));
+    } catch {
+    }
+  }
+  summary() {
+    const total = this.stats.hit + this.stats.miss;
+    return `cache ${this.stats.hit}/${total} hit`;
+  }
+};
+
+// src/prefers-color.ts
+var PREFERS_COLOR_ATTR = "data-prefers-color";
+var PREFERS_COLOR_STORAGE_KEY = "dommief:prefers-color";
+var PREFERS_COLOR_BOOT_SCRIPT = `(function(){try{var k=${JSON.stringify(PREFERS_COLOR_STORAGE_KEY)},a=${JSON.stringify(PREFERS_COLOR_ATTR)},v=localStorage.getItem(k);if(v!=='light'&&v!=='dark'&&v!=='auto')return;var c=v==='auto'?(matchMedia('(prefers-color-scheme: dark)').matches?'dark':'light'):v;document.documentElement.setAttribute(a,c)}catch(e){}})();`;
+function resolveConfiguredColor(defaultValue) {
+  if (!defaultValue || defaultValue === "auto") return void 0;
+  return defaultValue;
+}
+
+// src/vite/plugin.ts
+var demoRegistry = /* @__PURE__ */ new Map();
+function dommiefPlugin(opts) {
+  let loaded = opts.config ? { config: opts.config, host: opts.host ?? createPluginHost(opts.config.plugins ?? []) } : void 0;
+  const state = createState(opts.root, () => {
+    if (!loaded) throw new Error("dommief: config ch\u01B0a \u0111\u01B0\u1EE3c n\u1EA1p");
+    return loaded;
+  });
+  const markdownPlugin = {
+    name: "dommief:markdown",
+    enforce: "pre",
+    async config() {
+      if (!loaded) {
+        const config = await loadConfig(opts.root);
+        loaded = { config, host: createPluginHost(config.plugins ?? []) };
+      }
+      const aliases = buildAliasChain(opts.root, loaded.config);
+      aliases["dommief/theme-api"] = resolveThemeApiFile();
+      return {
+        base: loaded.config.base,
+        resolve: { dedupe: ["react", "react-dom", "react-router"], alias: aliases },
+        ssr: { noExternal: ["dommief"] }
+      };
+    },
+    resolveId(id, importer) {
+      if (id === "dommief/client") return resolveClientFile("index.tsx");
+      const bare = id.replace(/^\//, "");
+      if (bare === "virtual:dommief/entry") return "\0virtual:dommief/entry";
+      if (bare.startsWith("virtual:dommief-demo/")) return "\0" + bare;
+      if (bare === "virtual:dommief/routes" || bare === "virtual:dommief/site") return null;
+      if (id.endsWith(".md") || id.endsWith(".md?meta")) {
+        const base = importer ? path9.dirname(importer.replace(/\?meta$/, "")) : process.cwd();
+        const q = id.endsWith("?meta") ? "?meta" : "";
+        const clean = id.replace(/\?meta$/, "");
+        return winPath(path9.isAbsolute(clean) ? clean : path9.resolve(base, clean)) + q;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id.startsWith("\0virtual:dommief-demo/")) {
+        const demoId2 = id.slice("\0virtual:dommief-demo/".length);
+        const source = demoRegistry.get(demoId2) ?? "export default function Demo(){ return null; }";
+        return { code: source, map: null, moduleType: "jsx" };
+      }
+      if (id === "\0virtual:dommief/entry") {
+        return { code: `import ${JSON.stringify(resolveClientFile("entry-client.tsx"))};`, map: null, moduleType: "js" };
+      }
+      if (id.endsWith(".md") || id.endsWith(".md?meta")) {
+        const isMeta = id.endsWith("?meta");
+        const file = isMeta ? id.slice(0, -"?meta".length) : id;
+        const code = await fs9.promises.readFile(file, "utf8");
+        const transformOpts = { hooks: state.host(), byFile: state.getTable().byFile, base: state.config().base, code: state.config().markdown };
+        let out;
+        let meta;
+        let warnings;
+        let apiSrcFiles = [];
+        if (opts.cache) {
+          const host = state.host();
+          const input = {
+            md: code,
+            file,
+            base: transformOpts.base,
+            routesHash: computeRoutesHash(transformOpts.byFile),
+            pipelineHash: computePipelineHash({ code: transformOpts.code, plugins: [...host.collectRemarkPlugins(), ...host.collectRehypePlugins()] })
+          };
+          const cacheable = !/<API[\s/>]/.test(code);
+          const hit = await opts.cache.getOrCompute(file, input, async () => {
+            const r = await transformMarkdown(code, file, transformOpts);
+            return { code: r.code, meta: r.meta, warnings: r.warnings, demos: r.demos };
+          }, cacheable);
+          let hitDemos = [];
+          ({ code: out, meta, warnings } = hit);
+          hitDemos = hit.demos ?? [];
+          for (const d of hitDemos) {
+            demoRegistry.set(d.id, d.source);
+            if (d.src) this.addWatchFile(path9.resolve(path9.dirname(file), d.src));
+          }
+        } else {
+          const r = await transformMarkdown(code, file, transformOpts);
+          ({ code: out, meta, warnings, apiSrcFiles } = r);
+          const nonCacheDemos = r.demos ?? [];
+          for (const d of nonCacheDemos) {
+            demoRegistry.set(d.id, d.source);
+            if (d.src) this.addWatchFile(path9.resolve(path9.dirname(file), d.src));
+          }
+        }
+        for (const w of warnings) this.warn(w);
+        for (const apiFile of apiSrcFiles) this.addWatchFile(apiFile);
+        if (!isMeta) opts.collectTexts?.(file, meta.texts);
+        if (isMeta) {
+          return { code: `export default ${JSON.stringify({ frontmatter: meta.frontmatter, toc: meta.toc })};`, map: null, moduleType: "js" };
+        }
+        return { code: out, map: null, moduleType: "jsx" };
+      }
+      return null;
+    },
+    // order 'pre': script chèn ở đây phải đi qua bước bundle HTML của Vite, nếu không build không có JS.
+    transformIndexHtml: { order: "pre", handler(html) {
+      const title = state.config().title;
+      let out = html;
+      if (!/<title>/.test(out)) out = out.replace("<head>", `<head><title>${title}</title>`);
+      const tags = state.host().collectHtmlHeadTags();
+      if (tags.length) out = out.replace("</head>", tags.join("\n") + "</head>");
+      const themeConfig = state.config().themeConfig;
+      const configuredColor = resolveConfiguredColor(themeConfig?.prefersColor?.default);
+      if (configuredColor && !/data-prefers-color=/.test(out)) {
+        out = out.replace(/<html(\s|>)/, `<html ${PREFERS_COLOR_ATTR}="${configuredColor}"$1`);
+      }
+      if (!out.includes(PREFERS_COLOR_BOOT_SCRIPT)) {
+        out = out.replace("</head>", `<script>${PREFERS_COLOR_BOOT_SCRIPT}</script></head>`);
+      }
+      if (!out.includes("virtual:dommief/entry")) {
+        out = out.replace("</body>", `<script type="module" src="/virtual:dommief/entry"></script></body>`);
+      }
+      return out;
+    } },
+    configureServer(server) {
+      const localThemeDir = winPath(path9.resolve(opts.root, ".dommief", "theme")) + "/";
+      const update = () => {
+        const aliases = buildAliasChain(opts.root, loaded.config);
+        server.config.resolve.alias = { ...server.config.resolve.alias, ...aliases };
+        server.ws.send({ type: "full-reload" });
+      };
+      server.watcher.on("add", (f) => {
+        if (winPath(f).startsWith(localThemeDir)) update();
+      });
+      server.watcher.on("unlink", (f) => {
+        if (winPath(f).startsWith(localThemeDir)) update();
+      });
+    }
+  };
+  return [markdownPlugin, dommiefRoutesPlugin(state), dommiefSitePlugin(state), dommiefSearchIndexPlugin(state)];
+}
+
+// src/log.ts
+function createLogger(verbose = false) {
+  return {
+    verbose,
+    info: (m) => console.log(m),
+    debug: (m) => {
+      if (verbose) console.log("[debug]", m);
+    },
+    warn: (m) => console.warn("[warn]", m),
+    error: (m) => console.error("[error]", m)
+  };
+}
+
+// src/cli.ts
+init_plugins();
+
+// src/build.ts
+import path12 from "path";
+import fs12 from "fs";
+import { pathToFileURL } from "url";
+import { build } from "vite";
+init_errors();
+
+// src/link-check.ts
+import fs10 from "fs";
+import path10 from "path";
+var HREF_RE = /<a\b[^>]*\shref="([^"]*)"[^>]*>/g;
+var ASSET_RE = /<(?:img|link)\b[^>]*\s(?:src|href)="([^"]*)"[^>]*>/g;
+var LINE_RE = /\sdata-src-line="(\d+)"/;
+var EXTERNAL2 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function extractRefs(re, html, routeId, file) {
+  const out = [];
+  let m;
+  re.lastIndex = 0;
+  while (m = re.exec(html)) {
+    const tag = m[0];
+    const href = m[1];
+    if (!href || href.startsWith("#") || EXTERNAL2.test(href)) continue;
+    const line = tag.match(LINE_RE)?.[1] ?? "\u2014";
+    out.push({ href, routeId, file, line });
+  }
+  return out;
+}
+function collect(routeId, html, file) {
+  return [...extractRefs(HREF_RE, html, routeId, file), ...extractRefs(ASSET_RE, html, routeId, file)];
+}
+function stripBase(p, base) {
+  const b = base.replace(/\/$/, "");
+  if (b && p.startsWith(b + "/")) return p.slice(b.length) || "/";
+  if (b && p === b) return "/";
+  return p;
+}
+function check(refs, opts) {
+  const issues = [];
+  for (const ref of refs) {
+    const isAsset = !!ref.href.match(/\.(png|jpe?g|gif|svg|webp|avif|ico|css|woff2?|ttf)(\?.*)?$/i);
+    const [rawPath, hash] = ref.href.split("#");
+    const cleanPath = (rawPath ?? "").split("?")[0];
+    if (isAsset) {
+      const relPath = stripBase(cleanPath, opts.base) || "/";
+      const onDisk = path10.join(opts.outDir, decodeURIComponent(relPath));
+      if (!fs10.existsSync(onDisk)) issues.push({ code: "link_asset_missing", ref });
+      continue;
+    }
+    const routePath = stripBase(cleanPath, opts.base) || "/";
+    const target = opts.byPath[routePath];
+    if (!target) {
+      issues.push({ code: "link_target_missing", ref });
+      continue;
+    }
+    if (hash) {
+      const toc = opts.tocByRoute[target.path] ?? opts.tocByRoute[routePath];
+      if (toc !== void 0 && !toc.some((t) => t.id === hash)) {
+        issues.push({ code: "link_anchor_missing", ref });
+      }
+    }
+  }
+  return issues;
+}
+var MAX_LINES = 20;
+function formatIssues(issues) {
+  const lines = issues.slice(0, MAX_LINES).map((i) => `${i.ref.file}:${i.ref.line}  ${i.ref.href}  (${i.code})`);
+  const rest = issues.length - lines.length;
+  if (rest > 0) lines.push(`\u2026 v\xE0 ${rest} l\u1ED7i n\u1EEFa`);
+  return lines.join("\n");
+}
+
+// src/exclude.ts
+var cache = /* @__PURE__ */ new Map();
+function globToRegExp(pattern) {
+  let src = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern.charAt(i);
+    if (c === "*" && pattern.charAt(i + 1) === "*") {
+      const slash = pattern.charAt(i + 2) === "/";
+      src += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (c === "*") {
+      src += "[^/]*";
+    } else if (c === "?") {
+      src += "[^/]";
+    } else {
+      src += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${src}$`);
+}
+function matcher(pattern) {
+  const hit = cache.get(pattern);
+  if (hit) return hit;
+  const re = globToRegExp(pattern);
+  cache.set(pattern, re);
+  return re;
+}
+function matchExclude(path15, patterns) {
+  return patterns.some((p) => matcher(p).test(path15));
+}
+
+// src/sitemap.ts
+import fs11 from "fs";
+import path11 from "path";
+function canonicalUrl(hostname, base, routePath) {
+  const host = hostname.replace(/\/$/, "");
+  const b = base.replace(/\/$/, "");
+  const p = routePath === "/" ? "/" : routePath;
+  return host + (b + p).replace(/\/{2,}/g, "/").replace(/^(https?:\/)([^/])/, "$1/$2");
+}
+function buildSitemap(routes, config, base) {
+  const urls = routes.filter((r) => r.path !== "/404" && !/[:*]/.test(r.path) && !matchExclude(r.path, config.exclude)).map((r) => `  <url><loc>${escapeXml(canonicalUrl(config.hostname, base, r.path))}</loc></url>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+}
+function buildRobots(sitemapUrl) {
+  return `User-agent: *
+Allow: /
+
+Sitemap: ${sitemapUrl}
+`;
+}
+function escapeXml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[c]);
+}
+function writeSitemapAndRobots(opts) {
+  if (opts.sitemap === false) return;
+  if (!opts.sitemap.hostname) {
+    opts.log.warn("sitemap.hostname thi\u1EBFu \u2014 b\u1ECF qua sitemap.xml/robots.txt");
+    return;
+  }
+  const xml = buildSitemap(opts.routes, opts.sitemap, opts.base);
+  fs11.writeFileSync(path11.join(opts.outDir, "sitemap.xml"), xml);
+  if (opts.robots) {
+    const sitemapUrl = canonicalUrl(opts.sitemap.hostname, opts.base, "/").replace(/\/$/, "") + "/sitemap.xml";
+    fs11.writeFileSync(path11.join(opts.outDir, "robots.txt"), buildRobots(sitemapUrl));
+  }
+}
+
+// src/build.ts
+var ROOT_PLACEHOLDER = /<div id="root"><\/div>/;
+async function mapLimit(items, limit, fn) {
+  let i = 0;
+  const worker = async () => {
+    while (i < items.length) await fn(items[i++]);
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+var LinkCheckFailedError = class extends Error {
+  constructor(report) {
+    super("link n\u1ED9i b\u1ED9 ch\u1EBFt; ch\u1EA1y v\u1EDBi --no-link-check \u0111\u1EC3 b\u1ECF qua");
+    this.report = report;
+  }
+  report;
+};
+var emitters = [];
+emitters.push({
+  name: "sitemap",
+  run: ({ config, outDir, routes, log }) => {
+    writeSitemapAndRobots({ outDir, routes, sitemap: config.sitemap, robots: config.robots, base: config.base, log });
+  }
+});
+function formatTimings(timings) {
+  const total = timings.reduce((s, t) => s + t.ms, 0);
+  const w = Math.max(...timings.map((t) => t.stage.length), 5);
+  const pct = (ms) => (total > 0 ? `${Math.round(ms / total * 100)}%` : "\u2014").padStart(4);
+  const sec = (ms) => ((ms / 1e3).toFixed(2) + "s").padStart(8);
+  const rows = timings.map((t) => `  ${t.stage.padEnd(w)}  ${sec(t.ms)}  ${pct(t.ms)}`);
+  return ["build timings:", ...rows, `  ${"total".padEnd(w)}  ${sec(total)}  ${pct(total)}`].join("\n");
+}
+function planRoutes(routes, ssg, log) {
+  const prerender = [];
+  const shell = [];
+  for (const r of routes) {
+    if (matchesAny(r.path, ssg.noEmit)) continue;
+    if (matchesAny(r.path, ssg.exclude)) {
+      shell.push(r);
+      if (log && routes.some((other) => other !== r && other.path.startsWith(r.path === "/" ? "/" : r.path + "/"))) {
+        log.warn(`ssg.exclude \u0111ang lo\u1EA1i route "${r.path}" NH\u01AFNG n\xF3 c\xF3 route con \u2014 \u0111i\u1EC1u h\u01B0\u1EDBng th\u1EB3ng v\xE0o "${r.path}" tr\xEAn host kh\xF4ng SPA fallback s\u1EBD 404`);
+      }
+      continue;
+    }
+    prerender.push(r);
+  }
+  return { prerender, shell };
+}
+function matchesAny(p, patterns) {
+  return patterns.some((pat) => pat.endsWith("/*") && p === pat.slice(0, -2) || matchExclude(p, [pat]));
+}
+function routesByPath(routes) {
+  return Object.fromEntries(routes.map((r) => [r.path, { path: r.path }]));
+}
+async function runBuild({ root, config, host, log }) {
+  const linkCheckEnabled = config.linkCheck !== false;
+  const timings = [];
+  const timed = async (stage, fn) => {
+    const t0 = performance.now();
+    try {
+      return await fn();
+    } finally {
+      timings.push({ stage, ms: performance.now() - t0 });
+    }
+  };
+  const cache2 = new TransformCache(path12.join(root, ".dommief", "cache"), config.cache);
+  const textsByFile = /* @__PURE__ */ new Map();
+  const plugins = () => [dommiefPlugin({ root, config, host, cache: cache2, collectTexts: (file, texts) => textsByFile.set(file, texts) })];
+  const distDir = path12.resolve(root, config.outDir);
+  await timed("client", () => build({ root, plugins: plugins(), base: config.base, build: { outDir: distDir, emptyOutDir: true } }));
+  const ssrDir = path12.join(root, ".dommief", "server");
+  fs12.mkdirSync(ssrDir, { recursive: true });
+  await timed("ssr", () => build({
+    root,
+    plugins: plugins(),
+    base: config.base,
+    build: {
+      outDir: ssrDir,
+      emptyOutDir: true,
+      ssr: resolveClientFile("entry-server.tsx"),
+      rollupOptions: { output: { entryFileNames: "server.mjs", format: "esm" } }
+    }
+  }));
+  const templatePath = path12.join(distDir, "index.html");
+  const rawTemplate = fs12.readFileSync(templatePath, "utf8");
+  const template = /<meta[^>]+name=["']viewport["']/i.test(rawTemplate) ? rawTemplate : rawTemplate.replace(/<\/head>/i, '  <meta name="viewport" content="width=device-width, initial-scale=1">\n</head>');
+  if (!ROOT_PLACEHOLDER.test(template)) {
+    throw new DommiefError('index.html kh\xF4ng c\xF3 <div id="root"></div> \u0111\u1EC3 ch\xE8n n\u1ED9i dung prerender', { file: templatePath, code: "ssg_no_root" });
+  }
+  const serverMod = await import(pathToFileURL(path12.join(ssrDir, "server.mjs")).href);
+  const routes = serverMod.routes ?? serverMod.default?.routes ?? [];
+  const render = serverMod.render ?? serverMod.default?.render;
+  const site = serverMod.site ?? serverMod.default?.site;
+  const fileOf = (routeId) => site?.routes?.[routeId]?.file ?? routeId;
+  const canonicalHostname = config.sitemap === false ? void 0 : config.sitemap.hostname;
+  const escapeAttr = (s) => s.replace(/"/g, "&quot;");
+  const wrap = (html, routePath) => {
+    let out = template.replace(ROOT_PLACEHOLDER, () => `<div id="root">${html}</div>`);
+    if (canonicalHostname && routePath !== "/404") {
+      const href = canonicalUrl(canonicalHostname, config.base, routePath);
+      if (!/<link[^>]+rel=["']canonical["']/i.test(out)) {
+        out = out.replace(/<\/head>/i, `  <link rel="canonical" href="${escapeAttr(href)}">
+</head>`);
+      }
+    }
+    return out;
+  };
+  const plan = planRoutes(routes, config.ssg, log);
+  const writePage = (r, html) => {
+    const targetDir = r.path === "/" ? distDir : path12.join(distDir, r.path.replace(/^\//, ""));
+    fs12.mkdirSync(targetDir, { recursive: true });
+    fs12.writeFileSync(path12.join(targetDir, "index.html"), html);
+  };
+  const linkRefs = [];
+  await timed("prerender", async () => {
+    await mapLimit(plan.prerender, config.ssg.concurrency, async (r) => {
+      const html = await render(r.path);
+      if (linkCheckEnabled) linkRefs.push(...collect(r.id, html, fileOf(r.id)));
+      writePage(r, wrap(html, r.path));
+    });
+    for (const r of plan.shell) writePage(r, wrap(template, r.path));
+    try {
+      fs12.writeFileSync(path12.join(distDir, "404.html"), wrap(await render("/404"), "/404"));
+    } catch (e) {
+      log.warn("kh\xF4ng render \u0111\u01B0\u1EE3c 404.html: " + formatError(e));
+    }
+  });
+  if (linkCheckEnabled) {
+    await timed("link-check", async () => {
+      const tocByRoute = {};
+      for (const r of plan.prerender) {
+        const meta = site?.meta?.[r.id];
+        if (meta?.toc) tocByRoute[r.path] = meta.toc;
+      }
+      const issues = check(linkRefs, { byPath: routesByPath(routes), tocByRoute, base: config.base, outDir: distDir });
+      if (issues.length) throw new LinkCheckFailedError(formatIssues(issues));
+    });
+  }
+  if (config.search.enabled) {
+    await timed("search-index", async () => {
+      const { buildSearchIndex: buildSearchIndex2, INDEX_BUDGET_BYTES_PER_PAGE: INDEX_BUDGET_BYTES_PER_PAGE2 } = await Promise.resolve().then(() => (init_search(), search_exports));
+      const res = await buildSearchIndex2({
+        routes: plan.prerender,
+        loadPageMeta: (r) => ({
+          frontmatter: site?.meta?.[r.id]?.frontmatter ?? {},
+          toc: site?.meta?.[r.id]?.toc ?? [],
+          texts: textsByFile.get(fileOf(r.id)) ?? []
+        }),
+        config: { locales: config.locales }
+      });
+      const searchDir = path12.join(distDir, "search-index");
+      fs12.mkdirSync(searchDir, { recursive: true });
+      for (const [localeId2, json] of Object.entries(res.locales)) {
+        fs12.writeFileSync(path12.join(searchDir, `${localeId2}.json`), JSON.stringify(json));
+      }
+      for (const [localeId2, s] of Object.entries(res.stats)) {
+        const kbPerPage = s.pages ? (s.bytes / 1024 / s.pages).toFixed(1) : "0";
+        log.info(`search index [${localeId2}]: ${s.docs} docs, ${(s.bytes / 1024).toFixed(1)} KB, ${kbPerPage} KB/trang`);
+        if (s.bytes > INDEX_BUDGET_BYTES_PER_PAGE2 * s.pages) {
+          log.warn(`search index [${localeId2}] v\u01B0\u1EE3t ng\xE2n s\xE1ch ${(INDEX_BUDGET_BYTES_PER_PAGE2 / 1024).toFixed(0)} KB/trang (\u0111ang \u1EDF ${kbPerPage} KB/trang)`);
+        }
+      }
+    });
+  }
+  for (const e of emitters) await timed(e.name, async () => {
+    await e.run({ root, config, outDir: distDir, routes: plan.prerender, log });
+  });
+  await timed("plugins", () => host.runBuildEnd({ config, outDir: distDir, routes }));
+  cache2.finish();
+  if (config.cache) {
+    log.info(cache2.summary());
+    if (log.verbose) for (const [f, why] of Object.entries(cache2.stats.missReasons)) log.info(`  miss ${path12.relative(root, f)} (${why})`);
+  }
+  log.info(formatTimings(timings));
+  log.info("build done");
+  return {
+    timings: Object.fromEntries(timings.map((t) => [t.stage, t.ms])),
+    cacheStats: cache2.stats
+  };
+}
+
+// src/preview.ts
+init_errors();
+import fs13 from "fs";
+import path13 from "path";
+import { preview as vitePreview } from "vite";
+function assertBuildOutput(outDir) {
+  const indexHtml = path13.join(outDir, "index.html");
+  if (!fs13.existsSync(outDir) || !fs13.existsSync(indexHtml)) {
+    throw new DommiefError(`kh\xF4ng c\xF3 build output \u1EDF "${outDir}". Ch\u1EA1y \`dommief build\` tr\u01B0\u1EDBc.`, { code: "no_build_output", file: outDir });
+  }
+}
+async function startPreview(opts) {
+  assertBuildOutput(opts.outDir);
+  const server = await vitePreview({
+    root: opts.root,
+    base: opts.base,
+    preview: {
+      ...opts.port !== void 0 ? { port: opts.port } : {},
+      ...opts.host !== void 0 ? { host: opts.host } : {},
+      ...opts.open !== void 0 ? { open: opts.open } : {}
+    },
+    build: { outDir: opts.outDir },
+    plugins: [spaFallbackPlugin(opts)]
+  });
+  return server;
+}
+function spaFallbackPlugin(opts) {
+  const shellPath = path13.join(opts.outDir, "index.html");
+  const base = opts.base.replace(/\/$/, "");
+  const serveHtml = (res, file, status = 200) => {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    fs13.createReadStream(file).pipe(res);
+  };
+  return {
+    name: "dommief:preview-spa-fallback",
+    configurePreviewServer(s) {
+      s.middlewares.use((req, res, next) => {
+        const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0] ?? "/");
+        if (req.method !== "GET") return next();
+        if (base && urlPath !== base && !urlPath.startsWith(base + "/")) {
+          res.statusCode = 404;
+          res.end("Not Found");
+          return;
+        }
+        const rel = base ? urlPath.slice(base.length) || "/" : urlPath;
+        const outDirResolved = path13.resolve(opts.outDir);
+        const safe = (p) => {
+          const r = path13.resolve(p);
+          return r === outDirResolved || r.startsWith(outDirResolved + path13.sep);
+        };
+        const candidates = [
+          path13.join(opts.outDir, rel, "index.html"),
+          path13.join(opts.outDir, rel.endsWith(".html") ? rel : rel.replace(/\/$/, "") + ".html")
+        ];
+        const hit = candidates.find((p) => safe(p) && fs13.existsSync(p) && fs13.statSync(p).isFile());
+        if (hit) return serveHtml(res, hit);
+        if (/\.[a-z0-9]+$/i.test(rel.replace(/\.html$/i, ""))) return next();
+        const notFound = path13.join(opts.outDir, "404.html");
+        if (fs13.existsSync(notFound)) {
+          serveHtml(res, notFound, 404);
+          return;
+        }
+        serveHtml(res, shellPath);
+      });
+    }
+  };
+}
+
+// src/cli.ts
+init_errors();
+var cli = cac("dommief");
+cli.command("dev", "start dev server").option("--verbose", "verbose logging").option("--base <base>", "public base path (vd /docs/)").option("--port <port>", "dev server port").action(async (opts) => {
+  const log = createLogger(!!opts.verbose);
+  const root = process.cwd();
+  log.debug("root=" + root);
+  const config = await loadConfig(root, { base: opts.base });
+  const host = createPluginHost(config.plugins ?? []);
+  const server = await createServer({
+    root,
+    plugins: [dommiefPlugin({ root, config, host })],
+    server: { port: Number(opts.port ?? config.dev.port) }
+  });
+  await server.listen();
+  server.printUrls();
+});
+cli.command("build", "build site").option("--verbose", "verbose logging").option("--base <base>", "public base path (vd /docs/)").option("--out-dir <dir>", "output directory").option("--no-cache", "b\u1ECF qua cache transform").option("--no-link-check", "kh\xF4ng ki\u1EC3m link n\u1ED9i b\u1ED9 ch\u1EBFt").action(async (opts) => {
+  const log = createLogger(!!opts.verbose);
+  const root = process.cwd();
+  log.debug("root=" + root);
+  const config = await loadConfig(root, { base: opts.base, outDir: opts.outDir, cache: opts.cache, linkCheck: opts.linkCheck });
+  const host = createPluginHost(config.plugins ?? []);
+  try {
+    await runBuild({ root, config, host, log });
+  } catch (e) {
+    if (e instanceof LinkCheckFailedError) {
+      log.error("link n\u1ED9i b\u1ED9 ch\u1EBFt:\n" + e.report);
+      process.exitCode = 1;
+      return;
+    }
+    throw e;
+  }
+});
+cli.command("preview", "preview built site").option("--base <base>", "public base path (vd /docs/)").option("--out-dir <dir>", "output directory").option("--port <port>", "preview server port").option("--host [host]", "expose ra network").option("--open", "m\u1EDF tr\xECnh duy\u1EC7t").action(async (opts) => {
+  const root = process.cwd();
+  const config = await loadConfig(root, { base: opts.base, outDir: opts.outDir });
+  try {
+    const server = await startPreview({
+      root,
+      base: config.base,
+      outDir: path14.resolve(root, config.outDir),
+      ...opts.port !== void 0 ? { port: Number(opts.port) } : {},
+      ...opts.host !== void 0 ? { host: opts.host } : {},
+      ...opts.open !== void 0 ? { open: opts.open } : {}
+    });
+    server.printUrls();
+  } catch (e) {
+    if (e instanceof DommiefError) {
+      console.error("[error] " + formatError(e));
+      process.exitCode = 1;
+      return;
+    }
+    throw e;
+  }
+});
+cli.help();
+cli.parse();