@barzhsieh/nuxt-content-mermaid 2.2.3 → 3.0.2

package/dist/module.mjs

@@ -1,152 +1,448 @@
-import { defineNuxtModule, useLogger, createResolver, addVitePlugin, addPlugin, addComponent, addImports, addTypeTemplate } from '@nuxt/kit';
-import { defu } from 'defu';
-import { DEFAULT_MERMAID_CONFIG, DEFAULT_TOOLBAR_OPTIONS, DEFAULT_EXPAND_OPTIONS, DEFAULT_DARK_THEME, DEFAULT_LIGHT_THEME, DEFAULT_FRONTMATTER_CONFIG_KEY } from '../dist/runtime/constants.js';
-import { parseInlineAttrs, parseMermaidFrontmatter, extractMermaidInlineOverrides, applyMermaidFrontmatterOverrides, mergeToolbarProps, extractToolbarProps } from '../dist/runtime/utils/mermaid-transform.js';
-import { isNonEmptyRecord, stringifyInlineValue } from '../dist/runtime/utils/index.js';
+import { defineNuxtModule, createResolver, addVitePlugin, addPlugin, addComponent, addImports, addTypeTemplate } from '@nuxt/kit';
+import { cloneOwnedData, mergeByPresence, assertStrictData, ContentMermaidConfigurationError } from '../dist/runtime/configuration/core.js';
+import { resolveModuleConfiguration } from '../dist/runtime/configuration/module.js';
+import destr from 'destr';
+import { parse, stringify } from 'yaml';
+import { isRecord, isNonEmptyRecord } from '../dist/runtime/utils/is.js';
 
-const MODULE_NAME = "@barzhsieh/nuxt-content-mermaid";
-const MERMAID_OPTIMIZE_DEPS = [
-  "mermaid",
-  "@braintree/sanitize-url",
-  "dayjs",
-  "dayjs/plugin/isoWeek.js",
-  "dayjs/plugin/customParseFormat.js",
-  "dayjs/plugin/advancedFormat.js",
-  "dayjs/plugin/duration.js"
-];
-const MERMAID_FENCE_RE = /^[ \t]*(?:`{3,}|~{3,})[ \t]*mermaid(?:$|[ \t{[])/im;
-const DEFAULTS = {
-  enabled: true,
-  loader: {
-    init: { ...DEFAULT_MERMAID_CONFIG },
-    lazy: true
-  },
-  theme: {
-    light: DEFAULT_LIGHT_THEME,
-    dark: DEFAULT_DARK_THEME
-  },
-  components: {
-    renderer: void 0,
-    spinner: void 0,
-    error: void 0
-  },
-  expand: DEFAULT_EXPAND_OPTIONS,
-  toolbar: DEFAULT_TOOLBAR_OPTIONS
-};
-const module$1 = defineNuxtModule({
-  meta: {
-    name: MODULE_NAME,
-    configKey: "contentMermaid",
-    compatibility: {
-      nuxt: "^3.20.1 || ^4.1.0"
+const UNSAFE_INLINE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function inspectMermaidFrontmatter(rawCode, newline) {
+  const lines = rawCode.split(newline);
+  let startIndex = 0;
+  while (startIndex < lines.length) {
+    const line = lines[startIndex];
+    const trimmed = line.trim();
+    if (!trimmed) {
+      startIndex += 1;
+      continue;
     }
-  },
-  defaults: {
-    ...DEFAULTS
-  },
-  setup(options, nuxt) {
-    const logger = useLogger("nuxt-content-mermaid");
-    const warn = (message) => logger.warn(message);
-    const deprecatedOptions = nuxt.options.mermaidContent;
-    const hasDeprecatedOptions = deprecatedOptions && typeof deprecatedOptions === "object" && Object.keys(deprecatedOptions).length > 0;
-    if (hasDeprecatedOptions)
-      warn("[nuxt-content-mermaid] `mermaidContent` is deprecated, please switch to `contentMermaid`. The old key is still read for now but will be removed in a future release.");
-    const resolvedOptions = defu(
-      {},
-      options,
-      deprecatedOptions,
-      DEFAULTS
-    );
-    const resolver = createResolver(import.meta.url);
-    const runtimeDir = resolver.resolve("./runtime");
-    nuxt.options.css ||= [];
-    nuxt.options.css.push(resolver.resolve("./runtime/styles.css"));
-    const publicRuntimeConfig = nuxt.options.runtimeConfig.public;
-    const runtimeOverrides = publicRuntimeConfig.contentMermaid || publicRuntimeConfig.mermaidContent || {};
-    if (!publicRuntimeConfig.contentMermaid && publicRuntimeConfig.mermaidContent)
-      warn("[nuxt-content-mermaid] `runtimeConfig.public.mermaidContent` is deprecated, please use `runtimeConfig.public.contentMermaid` instead.");
-    const runtimeMermaidConfig = defu(
-      {},
-      runtimeOverrides,
-      resolvedOptions
-    );
-    publicRuntimeConfig.contentMermaid = runtimeMermaidConfig;
-    publicRuntimeConfig.mermaidContent = runtimeMermaidConfig;
-    const baseMermaidComponentName = "Mermaid";
-    const isEnabled = runtimeMermaidConfig.enabled !== false;
-    if (!isEnabled) return;
-    addVitePlugin(() => ({
-      name: "nuxt-content-mermaid:optimize-deps",
-      configEnvironment(name, config) {
-        if (name === "client") {
-          config.optimizeDeps ||= {};
-          config.optimizeDeps.include ||= [];
-          config.optimizeDeps.include.push(
-            ...MERMAID_OPTIMIZE_DEPS.map((dep) => `${MODULE_NAME} > ${dep}`)
-          );
-        }
+    if (isMermaidDirectiveStart(line)) {
+      startIndex = skipMermaidDirective(lines, startIndex);
+      continue;
+    }
+    if (isMermaidCommentLine(line)) {
+      startIndex += 1;
+      continue;
+    }
+    break;
+  }
+  if (startIndex >= lines.length)
+    return { kind: "absent" };
+  const startLine = lines[startIndex];
+  if (startLine.trim() !== "---")
+    return { kind: "absent" };
+  const indentMatch = startLine.match(/^\s*/);
+  const indent = indentMatch ? indentMatch[0] : "";
+  let endIndex = -1;
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1)
+    return { kind: "invalid" };
+  const yamlLines = lines.slice(startIndex + 1, endIndex).map((line) => line.startsWith(indent) ? line.slice(indent.length) : line);
+  const yamlRaw = yamlLines.join("\n").trim();
+  try {
+    const data = yamlRaw ? parse(yamlRaw) : {};
+    if (!isRecord(data))
+      return { kind: "invalid" };
+    return {
+      kind: "valid",
+      info: {
+        data,
+        startIndex,
+        endIndex,
+        indent
       }
-    }));
-    addPlugin({
-      src: resolver.resolve(runtimeDir, "plugins/mermaid.client"),
-      mode: "client"
-    });
-    addComponent({
-      name: baseMermaidComponentName,
-      filePath: resolver.resolve(runtimeDir, "components/Mermaid.vue")
-    });
-    addImports([
-      {
-        name: "useMermaidTheme",
-        as: "useMermaidTheme",
-        from: resolver.resolve(runtimeDir, "composables/useMermaidTheme")
+    };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+function isMermaidDirectiveStart(line) {
+  return line.trim().startsWith("%%{");
+}
+function isMermaidCommentLine(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("%%") && !trimmed.startsWith("%%{");
+}
+function skipMermaidDirective(lines, startIndex) {
+  let index = startIndex;
+  while (index < lines.length) {
+    if (lines[index].includes("}%%"))
+      return index + 1;
+    index += 1;
+  }
+  return lines.length;
+}
+function parseInlineAttrs(info) {
+  const attrsBlock = extractInlineAttrsBlock(info);
+  if (attrsBlock === null)
+    return null;
+  return parseInlineAttrsBlock(attrsBlock);
+}
+function extractInlineAttrsBlock(info) {
+  const startIndex = info.indexOf("{");
+  if (startIndex === -1)
+    return null;
+  let depth = 0;
+  let quote = null;
+  for (let i = startIndex; i < info.length; i++) {
+    const char = info[i];
+    if (quote) {
+      if (char === quote && info[i - 1] !== "\\")
+        quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0)
+        return info.slice(startIndex + 1, i);
+    }
+  }
+  return null;
+}
+function parseInlineAttrsBlock(raw) {
+  const result = {};
+  let index = 0;
+  while (index < raw.length) {
+    index = skipSeparators(raw, index);
+    if (index >= raw.length)
+      break;
+    const keyStart = index;
+    while (index < raw.length && isAttrKeyChar(raw[index]))
+      index += 1;
+    const key = raw.slice(keyStart, index).trim();
+    if (!key)
+      break;
+    index = skipWhitespace(raw, index);
+    let value = true;
+    if (index < raw.length && (raw[index] === "=" || raw[index] === ":")) {
+      index += 1;
+      index = skipWhitespace(raw, index);
+      const { value: rawValue, nextIndex, quoted } = readAttributeValue(raw, index);
+      index = nextIndex;
+      value = parseAttributeValue(rawValue, quoted);
+    }
+    if (!setNestedValue(result, key, value))
+      return null;
+  }
+  return result;
+}
+function skipWhitespace(input, index) {
+  let cursor = index;
+  while (cursor < input.length) {
+    const char = input[cursor];
+    if (char !== " " && char !== "	" && char !== "\n" && char !== "\r")
+      break;
+    cursor += 1;
+  }
+  return cursor;
+}
+function skipSeparators(input, index) {
+  let cursor = index;
+  while (cursor < input.length) {
+    const char = input[cursor];
+    if (char !== " " && char !== "	" && char !== "\n" && char !== "\r" && char !== ";")
+      break;
+    cursor += 1;
+  }
+  return cursor;
+}
+function isAttrKeyChar(char) {
+  return /[\w.-]/.test(char);
+}
+function readAttributeValue(input, start) {
+  const char = input[start];
+  if (char === '"' || char === "'")
+    return readQuotedValue(input, start);
+  if (char === "{" || char === "[")
+    return readBalancedValue(input, start);
+  let end = start;
+  while (end < input.length) {
+    const current = input[end];
+    if (current === ";" || current === " " || current === "	" || current === "\n" || current === "\r")
+      break;
+    end += 1;
+  }
+  return { value: input.slice(start, end), nextIndex: end, quoted: false };
+}
+function readQuotedValue(input, start) {
+  const quote = input[start];
+  let cursor = start + 1;
+  let result = "";
+  while (cursor < input.length) {
+    const char = input[cursor];
+    if (char === "\\" && cursor + 1 < input.length) {
+      result += input[cursor + 1];
+      cursor += 2;
+      continue;
+    }
+    if (char === quote) {
+      return { value: result, nextIndex: cursor + 1, quoted: true };
+    }
+    result += char;
+    cursor += 1;
+  }
+  return { value: result, nextIndex: cursor, quoted: true };
+}
+function readBalancedValue(input, start) {
+  const open = input[start];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let quote = null;
+  for (let i = start; i < input.length; i++) {
+    const char = input[i];
+    if (quote) {
+      if (char === quote && input[i - 1] !== "\\")
+        quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === open) {
+      depth += 1;
+      continue;
+    }
+    if (char === close) {
+      depth -= 1;
+      if (depth === 0) {
+        return { value: input.slice(start, i + 1), nextIndex: i + 1, quoted: false };
       }
-    ]);
-    addTypeTemplate({
-      filename: "types/mermaid-content.d.ts",
-      getContents: () => `
-import type { Mermaid } from 'mermaid'
+    }
+  }
+  return { value: input.slice(start), nextIndex: input.length, quoted: false };
+}
+function parseAttributeValue(raw, quoted) {
+  const value = raw.trim();
+  if (!value)
+    return "";
+  const isStructured = value.startsWith("{") || value.startsWith("[");
+  if (quoted) {
+    if (!isStructured)
+      return value;
+    return parseStructuredValue(value);
+  }
+  if (isStructured)
+    return parseStructuredValue(value);
+  return destr(value);
+}
+function parseStructuredValue(value) {
+  const parsed = destr(value);
+  if (parsed !== value)
+    return parsed;
+  try {
+    const yamlParsed = parse(value);
+    if (isRecord(yamlParsed) || Array.isArray(yamlParsed))
+      return yamlParsed;
+  } catch {
+  }
+  return value;
+}
+function setNestedValue(target, path, value) {
+  const keys = path.split(".").filter(Boolean);
+  if (!keys.length)
+    return false;
+  let current = target;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (UNSAFE_INLINE_KEYS.has(key))
+      return false;
+    if (i === keys.length - 1) {
+      current[key] = value;
+      return true;
+    }
+    const existing = current[key];
+    if (!isRecord(existing)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  return true;
+}
+function applyResolvedMermaidFrontmatter(rawCode, newline, frontmatterInfo, frontmatter, fallbackIndent) {
+  const frontmatterLines = serializeMermaidFrontmatter(
+    frontmatter,
+    frontmatterInfo?.indent ?? fallbackIndent
+  );
+  const lines = rawCode.split(newline);
+  if (frontmatterInfo) {
+    const before = lines.slice(0, frontmatterInfo.startIndex);
+    const after = lines.slice(frontmatterInfo.endIndex + 1);
+    return [...frontmatterLines, ...before, ...after].join(newline);
+  }
+  return [
+    ...frontmatterLines,
+    ...lines
+  ].join(newline);
+}
+function serializeMermaidFrontmatter(frontmatter, indent) {
+  const yaml = stringify(frontmatter).trim();
+  const yamlLines = yaml ? yaml.split("\n").map((line) => `${indent}${line}`) : [];
+  const delimiter = `${indent}---`;
+  return [
+    delimiter,
+    ...yamlLines,
+    delimiter
+  ];
+}
 
-declare module '#app' {
-  interface NuxtApp {
-    $mermaid: () => Promise<Mermaid>
+const MARKDOWN_METADATA_PHASE = {
+  name: "Markdown Mermaid Metadata",
+  root: "mermaid"
+};
+const UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const INLINE_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set(["title", "config", "toolbar"]);
+const TOOLBAR_KEYS = /* @__PURE__ */ new Set(["title", "fontSize", "fullscreenToolbarScale", "buttons"]);
+const TOOLBAR_BUTTON_KEYS = /* @__PURE__ */ new Set(["copy", "fullscreen", "expand"]);
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function valueAt(value, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function hasUnsafeKeys(value) {
+  if (value === null || typeof value !== "object") return false;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Object.keys(descriptors)) {
+    if (UNSAFE_KEYS.has(key)) return true;
+    const descriptor = descriptors[key];
+    if (descriptor && "value" in descriptor && hasUnsafeKeys(descriptor.value))
+      return true;
   }
+  return false;
 }
-declare module 'vue' {
-  interface ComponentCustomProperties {
-    $mermaid: () => Promise<Mermaid>
+function normalizeRecord(value) {
+  try {
+    assertStrictData(value, MARKDOWN_METADATA_PHASE);
+  } catch (error) {
+    if (error instanceof ContentMermaidConfigurationError) return null;
+    throw error;
   }
+  if (!isPlainRecord(value) || hasUnsafeKeys(value)) return null;
+  return cloneOwnedData(value);
 }
-export {}
-`
-    });
-    nuxt.hook("content:file:beforeParse", (ctx) => {
-      const { file } = ctx;
-      if (!file.id?.endsWith(".md")) return;
-      if (!MERMAID_FENCE_RE.test(file.body)) return;
-      file.body = transformMermaidCodeBlocks(
-        file.body,
-        baseMermaidComponentName
-      );
-    });
+function hasOnlyKeys(value, allowedKeys) {
+  return Object.keys(Object.getOwnPropertyDescriptors(value)).every((key) => allowedKeys.has(key));
+}
+function isStringifiableScalar(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function normalizeToolbar(value) {
+  const toolbar = normalizeRecord(value);
+  if (!toolbar || !hasOnlyKeys(toolbar, TOOLBAR_KEYS)) return null;
+  const title = valueAt(toolbar, "title");
+  if (title !== void 0 && typeof title !== "string") return null;
+  const fontSize = valueAt(toolbar, "fontSize");
+  if (fontSize !== void 0 && typeof fontSize !== "string" && typeof fontSize !== "number") return null;
+  const fullscreenToolbarScale = valueAt(toolbar, "fullscreenToolbarScale");
+  if (fullscreenToolbarScale !== void 0 && typeof fullscreenToolbarScale !== "number") return null;
+  const buttons = valueAt(toolbar, "buttons");
+  if (buttons !== void 0) {
+    if (!isPlainRecord(buttons) || !hasOnlyKeys(buttons, TOOLBAR_BUTTON_KEYS)) return null;
+    for (const key of TOOLBAR_BUTTON_KEYS) {
+      const button = valueAt(buttons, key);
+      if (button !== void 0 && typeof button !== "boolean") return null;
+    }
   }
-});
-function transformMermaidCodeBlocks(body, componentName, frontmatterConfigKey = DEFAULT_FRONTMATTER_CONFIG_KEY) {
+  return toolbar;
+}
+function resolveDiagramMermaidConfig(value) {
+  return normalizeRecord(value);
+}
+function resolveFenceInlineAttributes(value) {
+  if (value === null) return null;
+  const attrs = normalizeRecord(value);
+  if (!attrs || !hasOnlyKeys(attrs, INLINE_ATTRIBUTE_KEYS)) return null;
+  const normalized = cloneOwnedData(attrs);
+  for (const key of ["title"]) {
+    if (!hasOwn(attrs, key)) continue;
+    const attribute = valueAt(attrs, key);
+    if (attribute === void 0 || !isStringifiableScalar(attribute)) return null;
+    normalized[key] = String(attribute);
+  }
+  if (hasOwn(attrs, "config")) {
+    const config = resolveDiagramMermaidConfig(valueAt(attrs, "config"));
+    if (!config) return null;
+    normalized.config = config;
+  }
+  if (hasOwn(attrs, "toolbar")) {
+    const toolbar = resolveMarkdownToolbar([valueAt(attrs, "toolbar")]);
+    if (toolbar === null || toolbar === void 0) return null;
+    normalized.toolbar = toolbar;
+  }
+  return normalized;
+}
+function resolveMarkdownFrontmatter(layers) {
+  const normalizedLayers = [];
+  for (const layer of layers) {
+    if (layer === void 0) continue;
+    const normalized = normalizeRecord(layer);
+    if (!normalized) return null;
+    if (hasOwn(normalized, "config")) {
+      const config = resolveDiagramMermaidConfig(valueAt(normalized, "config"));
+      if (!config) return null;
+      normalized.config = config;
+    }
+    if (hasOwn(normalized, "toolbar")) {
+      const toolbar = resolveMarkdownToolbar([valueAt(normalized, "toolbar")]);
+      if (toolbar === null || toolbar === void 0) return null;
+      normalized.toolbar = toolbar;
+    }
+    normalizedLayers.push(normalized);
+  }
+  return mergeByPresence(normalizedLayers);
+}
+function resolveMarkdownToolbar(layers) {
+  const normalizedLayers = [];
+  for (const layer of layers) {
+    if (layer === void 0) continue;
+    const toolbar = normalizeToolbar(layer);
+    if (!toolbar) return null;
+    normalizedLayers.push(toolbar);
+  }
+  if (!normalizedLayers.length) return void 0;
+  return mergeByPresence(normalizedLayers);
+}
+
+const MERMAID_COMPONENT_NAME = "ContentMermaidTransport";
+const PAGE_MERMAID_CONFIG_EXPRESSION = "config";
+function serializeInlineAttributeRecord(value) {
+  return JSON.stringify(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&#39;");
+}
+function isClosingFence(line, markerChar, markerLength) {
+  const trimmed = line.trim();
+  if (trimmed.length < markerLength) return false;
+  for (const char of trimmed) {
+    if (char !== markerChar) return false;
+  }
+  return true;
+}
+function transformMarkdownDiagrams(body) {
   const newline = body.includes("\r\n") ? "\r\n" : "\n";
   const lines = body.split(newline);
   const output = [];
   let inFence = false;
   let fenceChar = null;
   let fenceLength = 0;
-  const isClosingFence = (line) => {
-    if (!fenceChar) return false;
-    const trimmed = line.trim();
-    if (trimmed.length < fenceLength) return false;
-    for (const char of trimmed) {
-      if (char !== fenceChar) return false;
-    }
-    return true;
-  };
   const isFenceMarkerChar = (char) => char === "`" || char === "~";
   const parseFence = (line) => {
     let index = 0;
@@ -178,19 +474,19 @@ function transformMermaidCodeBlocks(body, componentName, frontmatterConfigKey =
   };
   const buildComponentTag = (encoded, toolbar) => {
     const attrs = [
-      `:config="${frontmatterConfigKey}"`
+      `:page-config="${PAGE_MERMAID_CONFIG_EXPRESSION}"`
     ];
     if (toolbar && isNonEmptyRecord(toolbar)) {
-      attrs.push(`:toolbar='${stringifyInlineValue(toolbar)}'`);
+      attrs.push(`:toolbar='${serializeInlineAttributeRecord(toolbar)}'`);
     }
     attrs.push(`code="${encoded}"`);
-    return `<${componentName} ${attrs.join(" ")}></${componentName}>`;
+    return `<${MERMAID_COMPONENT_NAME} ${attrs.join(" ")}></${MERMAID_COMPONENT_NAME}>`;
   };
   for (let index = 0; index < lines.length; index++) {
     const line = lines[index];
     if (inFence) {
       output.push(line);
-      if (isClosingFence(line)) {
+      if (fenceChar && isClosingFence(line, fenceChar, fenceLength)) {
         inFence = false;
         fenceChar = null;
         fenceLength = 0;
@@ -211,16 +507,7 @@ function transformMermaidCodeBlocks(body, componentName, frontmatterConfigKey =
     }
     let closingIndex = -1;
     for (let j = index + 1; j < lines.length; j++) {
-      const trimmed = lines[j].trim();
-      if (trimmed.length < fence.markerLength) continue;
-      let isFence = true;
-      for (const char of trimmed) {
-        if (char !== fence.markerChar) {
-          isFence = false;
-          break;
-        }
-      }
-      if (isFence) {
+      if (isClosingFence(lines[j], fence.markerChar, fence.markerLength)) {
         closingIndex = j;
         break;
       }
@@ -237,13 +524,39 @@ function transformMermaidCodeBlocks(body, componentName, frontmatterConfigKey =
       continue;
     }
     const inlineAttrs = parseInlineAttrs(fence.info);
-    const frontmatterInfo = parseMermaidFrontmatter(rawCode, newline);
-    const inlineOverrides = extractMermaidInlineOverrides(inlineAttrs);
-    const mergedCode = inlineOverrides ? applyMermaidFrontmatterOverrides(rawCode, newline, frontmatterInfo, inlineOverrides, fence.indent) : rawCode;
-    const toolbarProps = mergeToolbarProps(
-      extractToolbarProps(frontmatterInfo?.data),
-      extractToolbarProps(inlineAttrs)
-    );
+    if (fence.info.includes("{") && !inlineAttrs) {
+      output.push(...lines.slice(index, closingIndex + 1));
+      index = closingIndex;
+      continue;
+    }
+    const frontmatterResult = inspectMermaidFrontmatter(rawCode, newline);
+    if (frontmatterResult.kind === "invalid") {
+      output.push(...lines.slice(index, closingIndex + 1));
+      index = closingIndex;
+      continue;
+    }
+    const frontmatterInfo = frontmatterResult.kind === "valid" ? frontmatterResult.info : null;
+    const inlineOverrides = resolveFenceInlineAttributes(inlineAttrs);
+    if (inlineAttrs && !inlineOverrides) {
+      output.push(...lines.slice(index, closingIndex + 1));
+      index = closingIndex;
+      continue;
+    }
+    const resolvedFrontmatter = resolveMarkdownFrontmatter([
+      frontmatterInfo?.data,
+      inlineOverrides ?? void 0
+    ]);
+    const toolbarProps = resolveMarkdownToolbar([
+      frontmatterInfo?.data.toolbar,
+      inlineOverrides?.toolbar
+    ]);
+    if (resolvedFrontmatter === null || toolbarProps === null) {
+      output.push(...lines.slice(index, closingIndex + 1));
+      index = closingIndex;
+      continue;
+    }
+    const hasInlineOverrides = inlineOverrides && Object.keys(inlineOverrides).length > 0;
+    const mergedCode = frontmatterInfo || hasInlineOverrides ? applyResolvedMermaidFrontmatter(rawCode, newline, frontmatterInfo, resolvedFrontmatter, fence.indent) : rawCode;
     const encoded = encodeURIComponent(mergedCode.trim());
     output.push(`${fence.indent}${buildComponentTag(encoded, toolbarProps)}`);
     index = closingIndex;
@@ -251,4 +564,136 @@ function transformMermaidCodeBlocks(body, componentName, frontmatterConfigKey =
   return output.join(newline);
 }
 
-export { module$1 as default, transformMermaidCodeBlocks };
+const MODULE_NAME = "@barzhsieh/nuxt-content-mermaid";
+const MERMAID_OPTIMIZE_DEPS = [
+  "mermaid",
+  "@braintree/sanitize-url",
+  "dayjs",
+  "dayjs/plugin/isoWeek.js",
+  "dayjs/plugin/customParseFormat.js",
+  "dayjs/plugin/advancedFormat.js",
+  "dayjs/plugin/duration.js"
+];
+const LEGACY_ALIAS_PHASE = {
+  name: "Nuxt Module Configuration",
+  root: "nuxt.options"
+};
+function throwMigrationError(path, expected, received) {
+  throw new ContentMermaidConfigurationError(LEGACY_ALIAS_PHASE, [{
+    path,
+    code: "UNEXPECTED_PROPERTY",
+    expected,
+    received
+  }], false);
+}
+function assertNoLegacyModuleAlias(nuxtOptions) {
+  if (Object.getOwnPropertyDescriptor(nuxtOptions, "mermaidContent")) {
+    throwMigrationError(["mermaidContent"], "the supported contentMermaid key", "removed legacy alias");
+  }
+}
+function readRuntimeOverrides(publicRuntimeConfig) {
+  const descriptor = Object.getOwnPropertyDescriptor(publicRuntimeConfig, "contentMermaid");
+  if (!descriptor) return void 0;
+  if (!("value" in descriptor)) {
+    throwMigrationError(
+      ["runtimeConfig", "public", "contentMermaid"],
+      "an enumerable data property",
+      "accessor"
+    );
+  }
+  if (!descriptor.enumerable) {
+    throwMigrationError(
+      ["runtimeConfig", "public", "contentMermaid"],
+      "an enumerable data property",
+      "non-enumerable-property"
+    );
+  }
+  return descriptor.value;
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: MODULE_NAME,
+    configKey: "contentMermaid",
+    compatibility: {
+      nuxt: "^4.1.0"
+    }
+  },
+  moduleDependencies: {
+    "@nuxt/content": {
+      version: ">=3.5.0 <4.0.0"
+    }
+  },
+  setup(options, nuxt) {
+    assertNoLegacyModuleAlias(nuxt.options);
+    const publicRuntimeConfig = nuxt.options.runtimeConfig.public;
+    const resolved = resolveModuleConfiguration({
+      nuxtResolvedOptions: options,
+      runtimeOverrides: readRuntimeOverrides(publicRuntimeConfig)
+    });
+    if (!resolved.enabled) return;
+    publicRuntimeConfig.contentMermaid = resolved.runtimeOptions;
+    const resolver = createResolver(import.meta.url);
+    const runtimeDir = resolver.resolve("./runtime");
+    const baseMermaidComponentName = "Mermaid";
+    nuxt.options.css ||= [];
+    nuxt.options.css.push(resolver.resolve("./runtime/styles.css"));
+    addVitePlugin(() => ({
+      name: "nuxt-content-mermaid:optimize-deps",
+      configEnvironment(name, config) {
+        if (name === "client") {
+          config.optimizeDeps ||= {};
+          config.optimizeDeps.include ||= [];
+          config.optimizeDeps.include.push(
+            ...MERMAID_OPTIMIZE_DEPS.map((dep) => `${MODULE_NAME} > ${dep}`)
+          );
+        }
+      }
+    }));
+    addPlugin({
+      src: resolver.resolve(runtimeDir, "plugins/mermaid.client"),
+      mode: "client"
+    });
+    addPlugin({
+      src: resolver.resolve(runtimeDir, "plugins/content-mermaid-transport")
+    });
+    addPlugin({
+      src: resolver.resolve(runtimeDir, "plugins/runtime-config")
+    });
+    addComponent({
+      name: baseMermaidComponentName,
+      filePath: resolver.resolve(runtimeDir, "components/Mermaid.vue")
+    });
+    addImports([
+      {
+        name: "useMermaidTheme",
+        as: "useMermaidTheme",
+        from: resolver.resolve(runtimeDir, "composables/useMermaidTheme")
+      }
+    ]);
+    addTypeTemplate({
+      filename: "types/mermaid-content.d.ts",
+      getContents: () => `
+import type { Mermaid } from 'mermaid'
+
+declare module '#app' {
+  interface NuxtApp {
+    $mermaid: () => Promise<Mermaid>
+  }
+}
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $mermaid: () => Promise<Mermaid>
+  }
+}
+export {}
+`
+    });
+    nuxt.hook("content:file:beforeParse", ((ctx) => {
+      const { file } = ctx;
+      if (!file.id?.endsWith(".md")) return;
+      file.body = transformMarkdownDiagrams(file.body);
+    }));
+  }
+});
+
+export { module$1 as default };