@docfuse/plugins 0.1.0

package/dist/index.js

@@ -0,0 +1,757 @@
+// src/kroki/index.ts
+import { defineMarkdownPlugin } from "@docfuse/markdown";
+import { strToU8, zlibSync } from "fflate";
+
+// src/shared/diagram.ts
+import { visit } from "unist-util-visit";
+function displayKind(kind) {
+  if (kind === "plantuml") return "PlantUML";
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+var DIAGRAM_LABELS = {
+  en: {
+    copy: "Copy source",
+    source: "Show source",
+    preview: "Show preview",
+    expand: "Expand diagram",
+    close: "Close expanded diagram",
+    controls: "Diagram zoom controls",
+    zoomOut: "Zoom out",
+    zoomReset: "Reset zoom",
+    zoomIn: "Zoom in",
+    imageAlt: (kind) => `${displayKind(kind)} diagram`,
+    loadingPreview: "Diagram preview loads in the browser."
+  },
+  zh: {
+    copy: "\u590D\u5236\u56FE\u8868\u6E90\u7801",
+    source: "\u663E\u793A\u56FE\u8868\u6E90\u7801",
+    preview: "\u663E\u793A\u56FE\u8868\u9884\u89C8",
+    expand: "\u653E\u5927\u56FE\u8868",
+    close: "\u5173\u95ED\u56FE\u8868\u9884\u89C8",
+    controls: "\u56FE\u8868\u7F29\u653E\u63A7\u4EF6",
+    zoomOut: "\u7F29\u5C0F\u56FE\u8868",
+    zoomReset: "\u91CD\u7F6E\u56FE\u8868\u7F29\u653E",
+    zoomIn: "\u653E\u5927\u56FE\u8868",
+    imageAlt: (kind) => `${displayKind(kind)} \u56FE\u8868`,
+    loadingPreview: "\u56FE\u8868\u9884\u89C8\u5C06\u5728\u6D4F\u89C8\u5668\u4E2D\u52A0\u8F7D\u3002"
+  }
+};
+function labelsFromFile(file) {
+  if (!file || typeof file !== "object" || !("data" in file)) return DIAGRAM_LABELS.en;
+  const data = file.data;
+  if (!data || typeof data !== "object" || !("docfuseLocale" in data)) return DIAGRAM_LABELS.en;
+  const locale = typeof data.docfuseLocale === "string" ? data.docfuseLocale.toLowerCase() : "";
+  return locale === "zh" || locale.startsWith("zh-") ? DIAGRAM_LABELS.zh : DIAGRAM_LABELS.en;
+}
+function languageOf(node) {
+  const code = node.children.find(
+    (child) => child.type === "element" && child.tagName === "code"
+  );
+  if (!code) return void 0;
+  const classes = Array.isArray(code.properties.className) ? code.properties.className : [];
+  const language = classes.map(String).find((className) => className.startsWith("language-"))?.slice("language-".length).toLowerCase();
+  const source = code.children.filter((child) => child.type === "text").map((child) => child.value).join("");
+  return language ? { language, source } : void 0;
+}
+function action(name, label, properties = {}) {
+  return {
+    type: "element",
+    tagName: "button",
+    properties: { type: "button", dataDfDiagramAction: name, ariaLabel: label, ...properties },
+    children: [{ type: "text", value: label }]
+  };
+}
+function zoomControl(name, label) {
+  return {
+    type: "element",
+    tagName: "button",
+    properties: { type: "button", dataDfDiagramAction: name, ariaLabel: label, title: label },
+    children: [{ type: "text", value: label }]
+  };
+}
+function diagramFence(options) {
+  return () => (tree, file) => {
+    const labels = labelsFromFile(file);
+    visit(tree, "element", (node, index, parent) => {
+      if (!parent || index === void 0 || node.tagName !== "pre") return;
+      const fence = languageOf(node);
+      if (!fence || !options.languages.has(fence.language)) return;
+      const imageUrl = options.imageUrl?.(fence.source, fence.language);
+      const hasVisualPreview = Boolean(imageUrl || options.kind === "mermaid");
+      const preview = imageUrl ? {
+        type: "element",
+        tagName: "img",
+        properties: {
+          className: ["df-diagram-img"],
+          src: imageUrl,
+          alt: labels.imageAlt(options.kind),
+          loading: "lazy"
+        },
+        children: []
+      } : {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["df-diagram-placeholder"] },
+        children: [{ type: "text", value: labels.loadingPreview }]
+      };
+      parent.children[index] = {
+        type: "element",
+        tagName: "figure",
+        properties: {
+          className: ["df-diagram-window"],
+          dataDfPluginDiagram: options.kind,
+          dataDfSource: fence.source,
+          ...options.moduleUrl ? { dataDfModuleUrl: options.moduleUrl } : {}
+        },
+        children: [
+          {
+            type: "element",
+            tagName: "figcaption",
+            properties: { className: ["df-diagram-toolbar"] },
+            children: [
+              {
+                type: "element",
+                tagName: "span",
+                properties: { className: ["df-diagram-title"] },
+                children: [{ type: "text", value: options.filename(fence.language) }]
+              },
+              {
+                type: "element",
+                tagName: "span",
+                properties: { className: ["df-diagram-actions"] },
+                children: [
+                  action("copy", labels.copy),
+                  action("source", labels.source, { dataDfDiagramPreviewLabel: labels.preview }),
+                  action("expand", labels.expand, { dataDfDiagramCloseLabel: labels.close })
+                ]
+              }
+            ]
+          },
+          {
+            type: "element",
+            tagName: "div",
+            properties: { className: ["df-diagram-stage"] },
+            children: [
+              {
+                type: "element",
+                tagName: "div",
+                properties: { className: ["df-diagram-preview"] },
+                children: [preview]
+              },
+              {
+                type: "element",
+                tagName: "pre",
+                properties: { className: ["df-diagram-source"], hidden: true },
+                children: [
+                  {
+                    type: "element",
+                    tagName: "code",
+                    properties: {},
+                    children: [{ type: "text", value: fence.source }]
+                  }
+                ]
+              },
+              ...hasVisualPreview ? [
+                {
+                  type: "element",
+                  tagName: "div",
+                  properties: {
+                    className: ["df-diagram-zoom-controls"],
+                    role: "group",
+                    ariaLabel: labels.controls
+                  },
+                  children: [
+                    zoomControl("zoom-out", labels.zoomOut),
+                    zoomControl("zoom-reset", labels.zoomReset),
+                    zoomControl("zoom-in", labels.zoomIn)
+                  ]
+                }
+              ] : []
+            ]
+          }
+        ]
+      };
+    });
+  };
+}
+
+// src/shared/markdownSource.ts
+function stripColumns(value, columns) {
+  let index = 0;
+  let consumed = 0;
+  while (index < value.length && consumed < columns) {
+    if (value[index] === " ") consumed += 1;
+    else if (value[index] === "	") consumed += 4 - consumed % 4;
+    else break;
+    index += 1;
+  }
+  return consumed >= columns ? value.slice(index) : void 0;
+}
+function containerContent(line, state) {
+  let value = line;
+  while (true) {
+    const quote = value.match(/^ {0,3}>[ \t]?/);
+    if (!quote) break;
+    value = value.slice(quote[0].length);
+  }
+  const continued = state.listIndent > 0 ? stripColumns(value, state.listIndent) : void 0;
+  const content = continued ?? value;
+  const item = content.match(/^ {0,3}(?:[-+*]|\d{1,9}[.)])([ \t]+)(.*)$/);
+  if (item) {
+    const body = item[2] ?? "";
+    state.listIndent = (continued === void 0 ? 0 : state.listIndent) + content.length - body.length;
+    return body;
+  }
+  if (continued !== void 0 || value.trim() === "") return content;
+  state.listIndent = 0;
+  return value;
+}
+function openingFence(line) {
+  const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+  if (!match?.[1]) return void 0;
+  const marker = match[1][0];
+  const info = match[2]?.trim() ?? "";
+  if (marker === "`" && info.includes("`")) return void 0;
+  return {
+    marker,
+    size: match[1].length,
+    language: info.split(/\s+/, 1)[0]?.toLowerCase() ?? ""
+  };
+}
+function closesFence(line, fence) {
+  const match = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
+  return Boolean(match?.[1]?.[0] === fence.marker && match[1].length >= fence.size);
+}
+function hasMarkdownFenceLanguage(source, languages) {
+  let open;
+  const container = { listIndent: 0 };
+  for (const line of source.split(/\r?\n/)) {
+    const content = containerContent(line, container);
+    if (open) {
+      if (closesFence(content, open)) open = void 0;
+      continue;
+    }
+    const fence = openingFence(content);
+    if (!fence) continue;
+    if (languages.has(fence.language)) return true;
+    open = fence;
+  }
+  return false;
+}
+function removeInlineCode(line) {
+  let result = "";
+  let index = 0;
+  while (index < line.length) {
+    if (line[index] !== "`") {
+      result += line[index];
+      index += 1;
+      continue;
+    }
+    let endOfOpening = index + 1;
+    while (line[endOfOpening] === "`") endOfOpening += 1;
+    const delimiter = line.slice(index, endOfOpening);
+    const closing = line.indexOf(delimiter, endOfOpening);
+    if (closing === -1) {
+      result += delimiter;
+      index = endOfOpening;
+      continue;
+    }
+    result += " ".repeat(closing + delimiter.length - index);
+    index = closing + delimiter.length;
+  }
+  return result;
+}
+function markdownProse(source) {
+  let open;
+  const container = { listIndent: 0 };
+  return source.split(/\r?\n/).map((line) => {
+    const content = containerContent(line, container);
+    if (open) {
+      if (closesFence(content, open)) open = void 0;
+      return "";
+    }
+    const fence = openingFence(content);
+    if (fence) {
+      open = fence;
+      return "";
+    }
+    if (/^(?: {4}|\t)/.test(content)) return "";
+    return removeInlineCode(content);
+  }).join("\n");
+}
+
+// src/kroki/index.ts
+var PLUGIN_VERSION = "3";
+var DEFAULT_SERVER = "https://kroki.io";
+var DEFAULT_LANGUAGES = {
+  graphviz: "graphviz",
+  dot: "graphviz",
+  gv: "graphviz",
+  d2: "d2"
+};
+function encodeKroki(source) {
+  let binary = "";
+  for (const byte of zlibSync(strToU8(source), { level: 9 })) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function krokiUrl(server, type, format, source) {
+  return `${server}/${encodeURIComponent(type)}/${format}/${encodeKroki(source)}`;
+}
+function kroki(options = {}) {
+  const server = options.server?.replace(/\/+$/, "") || DEFAULT_SERVER;
+  const languages = { ...DEFAULT_LANGUAGES, ...options.languages };
+  const format = options.format === "png" ? "png" : "svg";
+  const languageMap = Object.fromEntries(
+    Object.entries(languages).map(([language, type]) => [language.trim().toLowerCase(), type.trim().toLowerCase()]).filter(([language, type]) => language && type)
+  );
+  return defineMarkdownPlugin({
+    name: "kroki",
+    version: PLUGIN_VERSION,
+    cacheKey: { server, languages: languageMap, format },
+    browserCompiler: {
+      module: "@docfuse/plugins/kroki",
+      exportName: "kroki",
+      options: { server, languages: languageMap, format }
+    },
+    fenceLanguages: Object.keys(languageMap),
+    appliesTo: ({ source }) => hasMarkdownFenceLanguage(source, new Set(Object.keys(languageMap))),
+    assets: {
+      clients: [{ id: "kroki", module: "@docfuse/plugins/client/kroki" }],
+      styles: [{ id: "diagrams", module: "@docfuse/plugins/diagram.css" }]
+    },
+    rehypePlugins: [
+      diagramFence({
+        languages: new Set(Object.keys(languageMap)),
+        kind: "kroki",
+        filename: (language) => `diagram.${languageMap[language] ?? language}`,
+        imageUrl: (source, language) => krokiUrl(server, languageMap[language] ?? language, format, source)
+      })
+    ]
+  });
+}
+
+// src/external-links/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin2 } from "@docfuse/markdown";
+import { visit as visit2 } from "unist-util-visit";
+
+// src/shared/urls.ts
+function hostnameOf(href) {
+  try {
+    return new URL(href).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function isInternalHost(host, internalHosts) {
+  return internalHosts.some((internal) => host === internal || host.endsWith(`.${internal}`));
+}
+
+// src/external-links/index.ts
+var PLUGIN_VERSION2 = "1";
+function externalLinks(options = {}) {
+  const newTab = options.newTab !== false;
+  const rel = [...options.rel ?? ["noopener", "noreferrer"]];
+  const internalHosts = (options.internalHosts ?? []).map((host) => host.toLowerCase());
+  return defineMarkdownPlugin2({
+    name: "external-links",
+    version: PLUGIN_VERSION2,
+    cacheKey: { newTab, rel, internalHosts },
+    browserCompiler: {
+      module: "@docfuse/plugins/external-links",
+      exportName: "externalLinks",
+      options: { newTab, rel, internalHosts }
+    },
+    rehypePlugins: [
+      () => (tree) => {
+        visit2(tree, "element", (node) => {
+          if (node.tagName !== "a") return;
+          const href = node.properties.href;
+          if (typeof href !== "string" || !/^https?:\/\//i.test(href)) return;
+          const host = hostnameOf(href);
+          if (!host || isInternalHost(host, internalHosts)) return;
+          if (newTab) node.properties.target = "_blank";
+          if (rel.length > 0) node.properties.rel = [...rel];
+        });
+      }
+    ]
+  });
+}
+
+// src/link-card/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin3 } from "@docfuse/markdown";
+import { SKIP, visit as visit3 } from "unist-util-visit";
+
+// src/shared/hast.ts
+function element(tagName, properties = {}, children = []) {
+  return { type: "element", tagName, properties, children };
+}
+
+// src/link-card/index.ts
+var PLUGIN_VERSION3 = "1";
+function isExternalHttpLink(href, internalHosts, includeRelative) {
+  if (!href) return false;
+  if (href.startsWith("/") || href.startsWith("#") || href.startsWith("mailto:"))
+    return includeRelative && href.startsWith("/");
+  if (!/^https?:\/\//i.test(href)) return false;
+  const host = hostnameOf(href);
+  return Boolean(host && !isInternalHost(host, internalHosts));
+}
+function textOf(node) {
+  if (node.type === "text") return node.value;
+  if ("children" in node) return node.children.map((child) => textOf(child)).join("");
+  return "";
+}
+function displayHost(href) {
+  try {
+    const url = new URL(href);
+    return url.hostname + (url.pathname === "/" ? "" : url.pathname);
+  } catch {
+    return href;
+  }
+}
+function linkCard(options = {}) {
+  const internalHosts = (options.internalHosts ?? []).map((host) => host.toLowerCase());
+  const includeRelative = options.includeRelative === true;
+  return defineMarkdownPlugin3({
+    name: "link-card",
+    version: PLUGIN_VERSION3,
+    cacheKey: { internalHosts, includeRelative },
+    browserCompiler: {
+      module: "@docfuse/plugins/link-card",
+      exportName: "linkCard",
+      options: { internalHosts, includeRelative }
+    },
+    rehypePlugins: [
+      () => (tree) => {
+        visit3(tree, "element", (node, index, parent) => {
+          if (node.tagName !== "p" || !parent || index === void 0) return;
+          const meaningful = node.children.filter(
+            (child) => child.type !== "text" || child.value.trim() !== ""
+          );
+          const onlyChild = meaningful[0];
+          if (meaningful.length !== 1 || onlyChild?.type !== "element" || onlyChild.tagName !== "a") return;
+          const href = String(onlyChild.properties.href ?? "");
+          if (!isExternalHttpLink(href, internalHosts, includeRelative)) return;
+          if (onlyChild.properties.dataDfElement === "file-link") return;
+          const title = textOf(onlyChild).trim() || displayHost(href);
+          const meta = displayHost(href);
+          parent.children[index] = element(
+            "a",
+            { ...onlyChild.properties, className: ["df-link-card"], href, dataDfComponent: "link-card" },
+            [
+              element("strong", {}, [{ type: "text", value: title }]),
+              ...meta && meta !== title ? [element("span", {}, [{ type: "text", value: meta }])] : []
+            ]
+          );
+          return [SKIP, index];
+        });
+      }
+    ]
+  });
+}
+
+// src/math/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin4 } from "@docfuse/markdown";
+import rehypeKatex from "rehype-katex";
+import remarkMath from "remark-math";
+var PLUGIN_VERSION4 = "3";
+function hasMathSyntax(source) {
+  const prose = markdownProse(source);
+  return hasMarkdownFenceLanguage(source, /* @__PURE__ */ new Set(["math"])) || /(^|[^\\])\$\$[\s\S]+?\$\$/.test(prose) || /(^|[^\\$])\$(?!\s)(?:\\.|[^$\n])+?(?<!\s)\$/.test(prose);
+}
+function math(options = {}) {
+  const resolved = {
+    throwOnError: options.throwOnError ?? false,
+    errorColor: options.errorColor ?? "#b42318",
+    trust: options.trust ?? false,
+    strict: options.strict ?? "warn",
+    macros: { ...options.macros ?? {} }
+  };
+  return defineMarkdownPlugin4({
+    name: "math",
+    version: PLUGIN_VERSION4,
+    cacheKey: resolved,
+    browserCompiler: { module: "@docfuse/plugins/math", exportName: "math", options: resolved },
+    appliesTo: ({ source }) => hasMathSyntax(source),
+    fenceLanguages: ["math"],
+    assets: { math: true },
+    remarkPlugins: [remarkMath],
+    rehypePlugins: [[rehypeKatex, resolved]]
+  });
+}
+
+// src/mermaid/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin5 } from "@docfuse/markdown";
+var PLUGIN_VERSION5 = "3";
+function mermaid(options = {}) {
+  const moduleUrl = options.moduleUrl?.trim();
+  return defineMarkdownPlugin5({
+    name: "mermaid",
+    version: PLUGIN_VERSION5,
+    cacheKey: { moduleUrl: moduleUrl ?? null },
+    browserCompiler: {
+      module: "@docfuse/plugins/mermaid",
+      exportName: "mermaid",
+      options: moduleUrl ? { moduleUrl } : {}
+    },
+    fenceLanguages: ["mermaid"],
+    appliesTo: ({ source }) => hasMarkdownFenceLanguage(source, /* @__PURE__ */ new Set(["mermaid"])),
+    assets: {
+      clients: [
+        {
+          id: "mermaid",
+          module: "@docfuse/plugins/client/mermaid",
+          resources: [
+            {
+              module: "mermaid/dist/mermaid.esm.min.mjs",
+              output: "mermaid.esm.min.mjs",
+              directories: [
+                {
+                  source: "chunks/mermaid.esm.min",
+                  output: "chunks/mermaid.esm.min",
+                  extensions: [".mjs"]
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      styles: [{ id: "diagrams", module: "@docfuse/plugins/diagram.css" }]
+    },
+    rehypePlugins: [
+      diagramFence({
+        languages: /* @__PURE__ */ new Set(["mermaid"]),
+        kind: "mermaid",
+        filename: () => "diagram.mmd",
+        ...moduleUrl ? { moduleUrl } : {}
+      })
+    ]
+  });
+}
+
+// src/pagefind/index.ts
+var PLUGIN_VERSION6 = "1";
+var unusedPagefindUiFiles = [
+  "pagefind-ui.js",
+  "pagefind-ui.css",
+  "pagefind-modular-ui.js",
+  "pagefind-component-ui.js",
+  "pagefind-component-ui.css",
+  "pagefind-highlight.js"
+];
+function assertPagefind(errors, action2) {
+  if (errors.length) throw new Error(`Pagefind ${action2} failed:
+${errors.join("\n")}`);
+}
+async function loadPagefindDependencies() {
+  const filesystemModule = "node:fs/promises";
+  const pathModule = "node:path";
+  const pagefindModule = "pagefind";
+  const [filesystem, paths, pagefindApi] = await Promise.all([
+    import(filesystemModule),
+    import(pathModule),
+    import(pagefindModule)
+  ]);
+  return {
+    pagefindApi,
+    readFile: filesystem.readFile,
+    rm: filesystem.rm,
+    join: paths.join
+  };
+}
+async function writePagefindIndex(context, resolved, loadDependencies = loadPagefindDependencies) {
+  let pagefindApi;
+  let index;
+  try {
+    const dependencies = await loadDependencies();
+    pagefindApi = dependencies.pagefindApi;
+    const { join, readFile, rm } = dependencies;
+    const pagefindRoot = join(context.outputRoot, "pagefind");
+    await rm(pagefindRoot, { recursive: true, force: true });
+    await rm(join(context.outputRoot, "search"), { recursive: true, force: true });
+    const created = await pagefindApi.createIndex(resolved);
+    assertPagefind(created.errors, "initialization");
+    if (!created.index) throw new Error("Pagefind did not return an index");
+    index = created.index;
+    for (const page of context.graph.pages.filter((candidate) => candidate.search)) {
+      const htmlPath = context.resolveOutputPath(page.outputPath, `search page ${page.outputPath}`);
+      const result = await index.addHTMLFile({
+        url: context.publicPathFor(page.routePath),
+        content: await readFile(htmlPath, "utf8")
+      });
+      assertPagefind(result.errors, `indexing ${page.sourceRelativePath}`);
+    }
+    const written = await index.writeFiles({ outputPath: pagefindRoot });
+    assertPagefind(written.errors, "write");
+    await Promise.all(unusedPagefindUiFiles.map((file) => rm(join(pagefindRoot, file), { force: true })));
+  } finally {
+    try {
+      await index?.deleteIndex();
+    } finally {
+      await pagefindApi?.close();
+    }
+  }
+}
+function pagefind(options = {}) {
+  const resolved = {
+    includeCharacters: options.includeCharacters ?? "._-",
+    keepIndexUrl: options.keepIndexUrl ?? false,
+    writePlayground: options.writePlayground ?? false
+  };
+  const provider = Object.freeze({
+    id: "pagefind",
+    client: "pagefind",
+    version: PLUGIN_VERSION6,
+    cacheKey: resolved,
+    async write(context) {
+      await writePagefindIndex(context, resolved);
+    }
+  });
+  return provider;
+}
+
+// src/plantuml/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin6 } from "@docfuse/markdown";
+import { deflateSync, strToU8 as strToU82 } from "fflate";
+var PLUGIN_VERSION7 = "3";
+function encode6Bit(value) {
+  const normalized = value & 63;
+  if (normalized < 10) return String.fromCharCode(48 + normalized);
+  if (normalized < 36) return String.fromCharCode(65 + normalized - 10);
+  if (normalized < 62) return String.fromCharCode(97 + normalized - 36);
+  return normalized === 62 ? "-" : "_";
+}
+function encodePlantUml(source) {
+  const normalized = /@start\w+/i.test(source) ? source : `@startuml
+${source}
+@enduml`;
+  const bytes = deflateSync(strToU82(normalized), { level: 9 });
+  let encoded = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index] ?? 0;
+    const second = bytes[index + 1] ?? 0;
+    const third = bytes[index + 2] ?? 0;
+    encoded += encode6Bit(first >> 2);
+    encoded += encode6Bit((first & 3) << 4 | second >> 4);
+    encoded += encode6Bit((second & 15) << 2 | third >> 6);
+    encoded += encode6Bit(third & 63);
+  }
+  return encoded;
+}
+function plantUml(options = {}) {
+  const server = options.server === false ? "" : options.server?.trim().replace(/\/+$/, "") ?? "";
+  return defineMarkdownPlugin6({
+    name: "plantuml",
+    version: PLUGIN_VERSION7,
+    cacheKey: { server },
+    browserCompiler: {
+      module: "@docfuse/plugins/plantuml",
+      exportName: "plantUml",
+      options: { server: server || false }
+    },
+    fenceLanguages: ["plantuml", "puml"],
+    appliesTo: ({ source }) => hasMarkdownFenceLanguage(source, /* @__PURE__ */ new Set(["plantuml", "puml"])),
+    assets: {
+      clients: [{ id: "plantuml", module: "@docfuse/plugins/client/plantuml" }],
+      styles: [{ id: "diagrams", module: "@docfuse/plugins/diagram.css" }]
+    },
+    rehypePlugins: [
+      diagramFence({
+        languages: /* @__PURE__ */ new Set(["plantuml", "puml"]),
+        kind: "plantuml",
+        filename: () => "diagram.puml",
+        ...server ? { imageUrl: (source) => `${server}/${encodePlantUml(source)}` } : {}
+      })
+    ]
+  });
+}
+
+// src/reading-time/index.ts
+import { defineMarkdownPlugin as defineMarkdownPlugin7 } from "@docfuse/markdown";
+import { SKIP as SKIP2, visit as visit4 } from "unist-util-visit";
+var PLUGIN_VERSION8 = "3";
+var CJK = /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u30ff\uac00-\ud7af]/g;
+var SKIP_TAGS = /* @__PURE__ */ new Set(["pre", "code", "script", "style", "svg"]);
+var DEFAULT_LABEL = "{minutes} min read";
+var DEFAULT_LABELS = { zh: "\u7EA6 {minutes} \u5206\u949F\u9605\u8BFB" };
+function positiveRate(value, name) {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeError(`${name} must be a positive finite number`);
+  return value;
+}
+function countReadingTime(text, wordsPerMinute, cjkWordsPerMinute) {
+  positiveRate(wordsPerMinute, "wordsPerMinute");
+  positiveRate(cjkWordsPerMinute, "cjkWordsPerMinute");
+  const cjkCharacters = text.match(CJK)?.length ?? 0;
+  const latinWords = text.replace(CJK, " ").match(/[A-Za-z0-9]+(?:['’][A-Za-z0-9]+)*/g)?.length ?? 0;
+  const minutes = Math.max(1, Math.round(latinWords / wordsPerMinute + cjkCharacters / cjkWordsPerMinute));
+  return { latinWords, cjkCharacters, minutes };
+}
+function collectText(tree, includeCode) {
+  const chunks = [];
+  visit4(tree, (node) => {
+    if (!includeCode && node.type === "element" && SKIP_TAGS.has(node.tagName)) return SKIP2;
+    if (node.type === "text") chunks.push(node.value);
+  });
+  return chunks.join(" ");
+}
+function localeFromFile(file) {
+  if (!file || typeof file !== "object" || !("data" in file)) return void 0;
+  const data = file.data;
+  if (!data || typeof data !== "object" || !("docfuseLocale" in data)) return void 0;
+  const locale = data.docfuseLocale;
+  return typeof locale === "string" ? locale.trim().toLowerCase() || void 0 : void 0;
+}
+function normalizeLabels(labels) {
+  return Object.fromEntries(
+    Object.entries(labels ?? {}).map(([locale, value]) => [locale.trim().toLowerCase(), value]).filter(([locale]) => locale.length > 0)
+  );
+}
+function labelForLocale(fallback, labels, locale) {
+  if (!locale) return fallback;
+  return labels[locale] ?? labels[locale.split("-")[0] ?? ""] ?? fallback;
+}
+function readingTime(options = {}) {
+  const wordsPerMinute = positiveRate(options.wordsPerMinute ?? 220, "wordsPerMinute");
+  const cjkWordsPerMinute = positiveRate(options.cjkWordsPerMinute ?? 300, "cjkWordsPerMinute");
+  const includeCode = options.includeCode === true;
+  const label = options.label ?? DEFAULT_LABEL;
+  const labels = { ...DEFAULT_LABELS, ...normalizeLabels(options.labels) };
+  return defineMarkdownPlugin7({
+    name: "reading-time",
+    version: PLUGIN_VERSION8,
+    cacheKey: { wordsPerMinute, cjkWordsPerMinute, includeCode, label, labels },
+    browserCompiler: {
+      module: "@docfuse/plugins/reading-time",
+      exportName: "readingTime",
+      options: { wordsPerMinute, cjkWordsPerMinute, includeCode, label, labels }
+    },
+    rehypePlugins: [
+      () => (tree, file) => {
+        const counts = countReadingTime(collectText(tree, includeCode), wordsPerMinute, cjkWordsPerMinute);
+        if (counts.latinWords + counts.cjkCharacters === 0) return;
+        const resolvedLabel = labelForLocale(label, labels, localeFromFile(file));
+        const readingTimeNode = element(
+          "p",
+          {
+            className: ["df-reading-time"],
+            dataDfReadingMinutes: String(counts.minutes),
+            dataDfWordCount: String(counts.latinWords + counts.cjkCharacters)
+          },
+          [{ type: "text", value: resolvedLabel.replaceAll("{minutes}", String(counts.minutes)) }]
+        );
+        const titleIndex = tree.children.findIndex((node) => node.type === "element" && node.tagName === "h1");
+        tree.children.splice(titleIndex >= 0 ? titleIndex + 1 : 0, 0, readingTimeNode);
+      }
+    ]
+  });
+}
+export {
+  externalLinks,
+  kroki,
+  linkCard,
+  math,
+  mermaid,
+  pagefind,
+  plantUml,
+  readingTime
+};