{"version":3,"sources":["../src/index.tsx","../src/MantineAIMarkdown.tsx","../src/components/typography/MantineTypography.tsx","../src/components/extra-styles/DefaultExtraStyles/index.tsx","../src/components/customized/PreCode.tsx","../src/hooks/useMantineCodeBlockOptions.ts","../src/defs.tsx","../src/components/customized/MermaidCode/renderQueue.ts","../src/components/customized/MermaidCode/index.tsx","../src/components/customized/formatJson.ts","../src/components/customized/jsonCompleteness.ts","../src/components/customized/useCodeFrame.ts","../src/components/customized/codeFrame.ts","../src/define.ts","../src/hooks/useMantineAIMarkdownMetadata.ts"],"sourcesContent":["/**\n * Public API surface for `@ai-react-markdown/mantine`.\n *\n * Re-exports the Mantine-integrated AI markdown component, its supporting\n * sub-components, extended types, default configuration, and typed hooks.\n *\n * @packageDocumentation\n */\n\n// --- Components ---\n\n/** Props for the main {@link MantineAIMarkdown} component. */\nexport type { MantineAIMarkdownProps } from './MantineAIMarkdown';\n\n/** Main component -- Mantine-integrated AI markdown renderer (default export). */\nexport { default } from './MantineAIMarkdown';\n\n/** Mantine-themed typography wrapper used by default inside {@link MantineAIMarkdown}. */\nexport { default as MantineAIMarkdownTypography } from './components/typography/MantineTypography';\n\n/** Default extra styles wrapper providing Mantine-compatible CSS scoping and overrides. */\nexport { default as MantineAIMDefaultExtraStyles } from './components/extra-styles/DefaultExtraStyles';\n\n// --- Types, config, and hooks ---\n\n/** Extended render configuration and metadata types for the Mantine integration. */\nexport type { MantineAIMarkdownMetadata, MantineCodeBlockOptions } from './defs';\n\n// ── v2 surface (props-api v2) ───────────────────────────────────────────────\n\n/** Shipped defaults of the `codeBlock` behavior group. */\nexport { defaultMantineCodeBlockOptions } from './defs';\n\n/** Narrow hook for the `codeBlock` behavior group — the single assertion site. */\nexport { useMantineCodeBlockOptions } from './hooks/useMantineCodeBlockOptions';\n\n/** Optional eager loading of the on-demand code-block assets (mermaid, highlight.js). */\nexport { preloadMantineCodeAssets } from './components/customized/PreCode';\n\n/** Widened behaviors factory (core fields + mantine's `codeBlock` group). */\nexport { defineMantineBehaviors } from './define';\nexport type { MantineBehaviorProps } from './define';\n\n/** Typed hook for accessing metadata within the Mantine AI markdown tree. */\nexport { useMantineAIMarkdownMetadata } from './hooks/useMantineAIMarkdownMetadata';\n","/**\n * Main Mantine integration component for AI markdown rendering.\n *\n * Wraps the core {@link AIMarkdown} component with Mantine-specific defaults:\n * - {@link MantineAIMarkdownTypography} as the typography wrapper\n * - {@link MantineAIMDefaultExtraStyles} as the extra styles wrapper\n * - {@link MantineAIMPreCode} as the default `
` component (with syntax\n *   highlighting via Mantine's CodeHighlight and mermaid diagram support)\n * - Automatic color scheme detection via Mantine's `useComputedColorScheme`\n *\n * @module MantineAIMarkdown\n */\n\nimport { memo, useMemo } from 'react';\nimport AIMarkdown from '@ai-react-markdown/core';\nimport {\n  type AIMarkdownProps,\n  type AIMarkdownCustomComponents,\n  type AIMarkdownBehaviorGroups,\n  type AIMarkdownStabilityTable,\n  AIMarkdownBehaviorsProvider,\n  AIMarkdownStabilityPolicy,\n  useStableRecord,\n  useStableValue,\n} from '@ai-react-markdown/core';\nimport MantineAIMarkdownTypography from './components/typography/MantineTypography';\nimport MantineAIMDefaultExtraStyles from './components/extra-styles/DefaultExtraStyles';\nimport { MantineAIMarkdownMetadata, MantineCodeBlockOptions } from './defs';\nimport MantineAIMPreCode from './components/customized/PreCode';\nimport { useComputedColorScheme } from '@mantine/core';\n\n/**\n * Props for the {@link MantineAIMarkdown} component.\n *\n * Extends {@link AIMarkdownProps} with the mantine behavior groups.\n * All core props (`content`, `streaming`, `fontSize`, `enginePlugins`, etc.)\n * are inherited.\n *\n * @typeParam TMetadata - Metadata type, defaults to {@link MantineAIMarkdownMetadata}.\n */\nexport interface MantineAIMarkdownProps<\n  TMetadata extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata,\n> extends AIMarkdownProps {\n  /**\n   * Code-block behavior group (Behaviors system). The group value replaces\n   * atomically; omitted fields resolve to the shipped defaults inside\n   * `useMantineCodeBlockOptions()`. `null` counts as absent. When absent,\n   * this wrapper contributes NO `codeBlock` group, so a group provided by\n   * an outer app-level `AIMarkdownBehaviorsProvider` passes through; when\n   * present, this prop wins over any outer group (inner-wins merge).\n   */\n  codeBlock?: Partial;\n}\n\n/**\n * Stable empty CONTRIBUTION for the absent-prop case. Deliberately carries\n * no `codeBlock` key at all: contributing `codeBlock: {}` would shadow a\n * group provided by an outer app-level `AIMarkdownBehaviorsProvider`\n * (inner-wins merge) even though this wrapper has nothing to say — the\n * documented app-level extension path would silently go dead.\n */\nconst NO_GROUPS: AIMarkdownBehaviorGroups = Object.freeze({});\n\n/**\n * Mantine's stability-firewall table — one row today: `codeBlock` is the\n * only object prop this wrapper TERMINATES (consumes in its own machinery).\n * Forwarded object props ride core's firewall untouched; the merged\n * `customComponents` derived below is caught by core's wall.\n */\nconst MANTINE_STABILITY_TABLE: AIMarkdownStabilityTable<{\n  codeBlock: Partial | undefined;\n}> = {\n  codeBlock: AIMarkdownStabilityPolicy.DEEP_EQUAL,\n};\n\n/**\n * Default custom component overrides applied by the Mantine integration.\n *\n * Overrides the `
` element to extract code blocks and render them via\n * {@link MantineAIMPreCode}, which provides syntax highlighting, expand/collapse,\n * and mermaid diagram support. Falls back to a plain `
` when the child\n * is not a recognized code element.\n */\nconst DefaultCustomComponents: AIMarkdownCustomComponents = {\n  pre: ({ node, ...usefulProps }) => {\n    const code = node?.children[0] as\n      | {\n          type: string;\n          tagName?: string;\n          position?: { start?: { offset?: number } };\n          properties?: Record;\n          children: { value?: string }[];\n        }\n      | undefined;\n    if (\n      !code ||\n      code.type !== 'element' ||\n      code.tagName !== 'code' ||\n      !code.position ||\n      node?.children.length !== 1 ||\n      code.children.some((child) => !('value' in child) || typeof child.value !== 'string') ||\n      Object.keys(code.properties ?? {}).some((key) => key !== 'className') ||\n      Object.keys(node.properties ?? {}).length > 0\n    ) {\n      return 
;\n    }\n    const key = `pre-code-${node?.position?.start?.offset || 0}`;\n    // hast allows `className` as a string as well as an array (a consumer's\n    // rehype plugin may write either); `.find` on a string threw and took\n    // the whole tree down (2026-08-19 review).\n    const classNames = code.properties?.className;\n    const classList = Array.isArray(classNames)\n      ? (classNames as unknown[]).filter((c): c is string => typeof c === 'string')\n      : typeof classNames === 'string'\n        ? classNames.split(/\\s+/)\n        : [];\n    const detectedLanguage = classList\n      .find((className) => className.startsWith('language-'))\n      ?.substring('language-'.length);\n    if (classList.some((className) => !className.startsWith('language-'))) return 
;\n    // A `` inside `
` normally carries ONE text child; if an\n    // upstream plugin splits it, the pieces are contiguous source — join\n    // with '' (a '\\n' joiner would invent line breaks the source lacks).\n    const codeText = code.children.map((child: { value?: string }) => child.value ?? '').join('');\n    return ;\n  },\n};\n\n/**\n * Inner (non-memoized) implementation of the Mantine AI markdown component.\n *\n * Merges caller-provided `customComponents` with the Mantine defaults (the caller's\n * overrides take precedence). Automatically resolves the color scheme from Mantine's\n * `useComputedColorScheme` when no explicit `colorScheme` prop is provided.\n *\n * @typeParam TMetadata - Metadata type.\n */\nconst MantineAIMarkdownComponent = ({\n  Typography = MantineAIMarkdownTypography,\n  ExtraStyles = MantineAIMDefaultExtraStyles,\n  customComponents,\n  colorScheme,\n  codeBlock,\n  ...props\n}: MantineAIMarkdownProps) => {\n  const stableCustomComponents = useStableValue(customComponents);\n\n  const usedComponents = useMemo(() => {\n    return stableCustomComponents ? { ...DefaultCustomComponents, ...stableCustomComponents } : DefaultCustomComponents;\n  }, [stableCustomComponents]);\n\n  const computedColorScheme = useComputedColorScheme('light');\n\n  // Mantine's stability firewall: `codeBlock` is terminated here (it feeds\n  // the behaviors Provider below, not the core prop surface).\n  const stable = useStableRecord({ codeBlock }, MANTINE_STABILITY_TABLE);\n\n  // Contribute the group through the additive behaviors Provider — firewall\n  // output used directly, record identity memoized so the context value\n  // stays stable across unrelated re-renders. `null`/absent prop ≡ no\n  // contribution (NOT an empty group): an outer app-level Provider's\n  // `codeBlock` group then stays visible; when the prop IS present the\n  // inner-wins merge gives this wrapper's value precedence. The narrow hook\n  // fills the defaults for the no-group-anywhere case.\n  const behaviorGroups = useMemo(\n    () => (stable.codeBlock != null ? { codeBlock: stable.codeBlock } : NO_GROUPS),\n    [stable.codeBlock]\n  );\n\n  return (\n    \n      \n        Typography={Typography}\n        ExtraStyles={ExtraStyles}\n        customComponents={usedComponents}\n        colorScheme={colorScheme ?? computedColorScheme}\n        {...props}\n      />\n    \n  );\n};\n\n/**\n * Mantine-integrated AI markdown renderer.\n *\n * A memoized wrapper around the core `` component that provides\n * Mantine-themed typography, code highlighting (via `@mantine/code-highlight`),\n * mermaid diagram rendering, and automatic color scheme detection.\n *\n * This is the default export of `@ai-react-markdown/mantine`.\n *\n * @example\n * ```tsx\n * import MantineAIMarkdown from '@ai-react-markdown/mantine';\n *\n * function Chat({ content }: { content: string }) {\n *   return ;\n * }\n * ```\n */\nexport const MantineAIMarkdown = memo(MantineAIMarkdownComponent);\n\nMantineAIMarkdown.displayName = 'MantineAIMarkdown';\n\nexport default MantineAIMarkdown as typeof MantineAIMarkdownComponent;\n","import { memo } from 'react';\nimport { Typography } from '@mantine/core';\nimport type { AIMarkdownTypographyProps } from '@ai-react-markdown/core';\n\n/**\n * Mantine-themed typography wrapper for AI markdown content.\n *\n * Replaces the core default typography component with Mantine's ``\n * element, applying the configured `fontSize` at full width. This ensures all\n * rendered markdown inherits Mantine's font family, line height, and theming.\n *\n * Used as the default `Typography` prop in {@link MantineAIMarkdown}.\n * Can be replaced by passing a custom `Typography` component.\n *\n * @param props - Standard {@link AIMarkdownTypographyProps} from the core package.\n */\nconst MantineAIMarkdownTypography = memo(({ children, fontSize, style }: AIMarkdownTypographyProps) => (\n  \n    {children}\n  \n));\n\nMantineAIMarkdownTypography.displayName = 'MantineAIMarkdownTypography';\n\nexport default MantineAIMarkdownTypography;\n","import React from 'react';\nimport { AIMarkdownExtraStylesComponent } from '@ai-react-markdown/core';\nimport './styles.scss';\n\n/**\n * Default extra styles wrapper for the Mantine integration.\n *\n * Wraps markdown content in a `
` with the `aim-mantine-extra-styles` CSS class,\n * which provides Mantine-compatible typography overrides including:\n * - Relative `em`-based Mantine spacing and font-size CSS custom properties\n * - Heading, list, paragraph, blockquote, and code styling\n * - Definition list layout\n *\n * Used as the default `ExtraStyles` prop in {@link MantineAIMarkdown}.\n */\nconst MantineAIMDefaultExtraStyles: AIMarkdownExtraStylesComponent = ({ children }) => {\n  return 
{children}
;\n};\n\nexport default MantineAIMDefaultExtraStyles;\n","'use client';\n\nimport { createContext, HTMLAttributes, memo, useContext, useEffect, useMemo, useRef, useState } from 'react';\nimport {\n  CodeHighlight,\n  CodeHighlightTabs,\n  CodeHighlightControl,\n  CodeHighlightAdapterProvider,\n  useHighlight,\n} from '@mantine/code-highlight';\nimport { useAIMarkdownState, useAIMarkdownTheme } from '@ai-react-markdown/core';\nimport { useMantineCodeBlockOptions } from '../../hooks/useMantineCodeBlockOptions';\nimport MantineAIMMermaidCode from './MermaidCode';\nimport { CopyButton } from '@mantine/core';\nimport { prettyPrintJson } from './formatJson';\nimport { createJsonCompletenessScanner } from './jsonCompleteness';\nimport { useCodeFrame } from './useCodeFrame';\nexport { jsonLooksComplete } from './jsonCompleteness';\nexport { prettyPrintJson } from './formatJson';\n\n/**\n * highlight.js is NOT imported statically any more: the root entry carries\n * every language definition (~130 KB gzip) and the only always-on use was a\n * `getLanguage()` existence check that Mantine's own adapter already\n * performs (unknown language → plaintext). Auto-detection is the one real\n * consumer, and it loads the module on demand — only when\n * `autoDetectUnknownLanguage` is on and an unlabelled block shows up\n * (2026-08 project review, pkg-small-02: the static import defeated\n * consumers' `highlight.js/lib/core` slimming). Consumers who want it (and\n * mermaid) in the main bundle up front call `preloadMantineCodeAssets()`\n * at app start, or simply import the modules themselves.\n */\nlet hljsAutoPromise: Promise<{ highlightAuto: (code: string) => { language?: string } }> | null = null;\nexport const loadHljsForAutoDetect = () => {\n  // A rejected load (transient network failure) is NOT cached: the next\n  // attempt retries instead of leaving autodetection dead for the page.\n  hljsAutoPromise ??= import('highlight.js').then(\n    (m) => m.default,\n    (err: unknown) => {\n      hljsAutoPromise = null;\n      throw err;\n    }\n  );\n  return hljsAutoPromise;\n};\n\n/** Below this many characters a guess is noise; the block stays \"unknown\". */\nconst AUTODETECT_MIN_CHARS = 32;\n/** Bounded automatic retries of a failed highlight.js module download. */\nconst HLJS_LOAD_RETRIES = 3;\nconst HLJS_LOAD_RETRY_MS = 1500;\n\n/**\n * The language highlight.js guesses for an unlabelled block.\n *\n * `highlightAuto` scores every registered language against the whole text,\n * so re-running it on every streamed chunk was O(languages × n) per chunk —\n * O(n²) over a long block (pkg-small-06). Schedule instead:\n *   - first guess as soon as the block has AUTODETECT_MIN_CHARS (an early\n *     label rather than \"unknown\" for the whole stream);\n *   - a corrective re-run each time the block has DOUBLED in length since\n *     the last guess (32 → 64 → 128 → …): a wrong early guess on a long\n *     block is fixed within its next doubling, and the total work stays\n *     O(n) — at most log₂(n) runs;\n *   - a final verdict when streaming ends (the last run always sees the\n *     complete block).\n * Returns '' while disabled, still loading, or below the minimum, so the\n * block renders as plaintext/\"unknown\" and upgrades in place.\n */\nfunction useAutoDetectedLanguage(codeText: string, enabled: boolean, streaming: boolean): string {\n  const [detected, setDetected] = useState<{ language: string; atLength: number; finalFor: string | null } | null>(\n    null\n  );\n  // Bumped after a failed `import('highlight.js')` so the effect re-runs on\n  // otherwise unchanged inputs and retries the download — the mermaid\n  // renderer's counterpart. Without it a static document whose only load\n  // attempt failed stayed \"unknown\" for good (v2.4.2 review P2-2). Bounded.\n  const [loadAttempt, setLoadAttempt] = useState(0);\n  const loadFailuresRef = useRef(0);\n  const previousTextRef = useRef(codeText);\n  useEffect(() => {\n    const appended = codeText.startsWith(previousTextRef.current);\n    previousTextRef.current = codeText;\n    if (!enabled) {\n      if (detected) setDetected(null);\n      return;\n    }\n    // The block was REPLACED, not appended to (a regenerate reuses this\n    // instance — the key is the block's source offset — or a same-offset\n    // swap): a guess made for the old text is worthless for the new one.\n    // Drop it so the schedule restarts (v2.4.0 review: the old label stuck\n    // for the whole new stream until its end).\n    // Do NOT return here: `detected` is not a dep, so a state reset alone\n    // would never re-run the effect and a non-streaming replacement stayed\n    // \"unknown\" for good (v2.4.1 review) — evaluate the schedule against\n    // the cleared prior in this same pass.\n    const prior = !appended || (detected !== null && codeText.length < detected.atLength) ? null : detected;\n    if (prior !== detected) setDetected(null);\n    if (codeText.length < AUTODETECT_MIN_CHARS) return;\n    const due =\n      prior === null ||\n      // Not streaming: the verdict must be for THIS text (end-of-stream, or a\n      // static content update).\n      (!streaming && prior.finalFor !== codeText) ||\n      // Streaming: doubled since the last guess.\n      (streaming && codeText.length >= prior.atLength * 2);\n    if (!due) return;\n    let cancelled = false;\n    let retryTimer: ReturnType | undefined;\n    loadHljsForAutoDetect().then(\n      (hljs) => {\n        if (cancelled) return;\n        loadFailuresRef.current = 0;\n        setDetected({\n          language: hljs.highlightAuto(codeText).language ?? '',\n          atLength: codeText.length,\n          finalFor: streaming ? null : codeText,\n        });\n      },\n      () => {\n        // Load failed — stay \"unknown\" and retry the download a bounded\n        // number of times (the loader does not cache rejections).\n        if (cancelled || loadFailuresRef.current >= HLJS_LOAD_RETRIES) return;\n        loadFailuresRef.current += 1;\n        retryTimer = setTimeout(() => setLoadAttempt((n) => n + 1), HLJS_LOAD_RETRY_MS);\n      }\n    );\n    return () => {\n      cancelled = true;\n      if (retryTimer !== undefined) clearTimeout(retryTimer);\n    };\n    // `detected` is deliberately not a dep: a completed guess must not\n    // re-trigger the effect (it re-runs on the next content/streaming\n    // change, which is when the schedule is re-evaluated). `loadAttempt`\n    // re-runs it after a failed module download.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [codeText, enabled, streaming, loadAttempt]);\n  return enabled ? (detected?.language ?? '') : '';\n}\n\n/**\n * Loads mermaid and highlight.js ahead of time. Both are imported on demand\n * by the code-block renderers (the first diagram / the first auto-detected\n * block pays the download); an app that would rather take that cost at\n * startup — a documentation page whose first screen shows a diagram, say —\n * calls this once at boot. Safe to call repeatedly; failures are swallowed\n * (the renderers will simply load lazily later).\n */\nexport function preloadMantineCodeAssets(): Promise {\n  return Promise.all([import('mermaid'), loadHljsForAutoDetect()]).then(\n    () => undefined,\n    () => undefined\n  );\n}\n\nconst RawCodeContext = createContext('');\n\n/** Context updates the copy control without re-running the highlighter. */\nfunction RawCodeCopy() {\n  const code = useContext(RawCodeContext);\n  return (\n    \n      {({ copied, copy }) => (\n        \n          {copied ? (\n            '✓'\n          ) : (\n            \n              \n              \n            \n          )}\n        \n      )}\n    \n  );\n}\n\n/** Single-entry adapter cache. Lives outside render; each request is keyed\n * by every input consumed by the highlighter, and a new function gets a new cache. */\nfunction createCachedHighlightAdapter(highlight: ReturnType) {\n  let previous: Parameters[0] | undefined;\n  let result: ReturnType;\n  return {\n    getHighlighter: () => (input: Parameters[0]) => {\n      if (\n        !previous ||\n        input.code !== previous.code ||\n        input.language !== previous.language ||\n        input.colorScheme !== previous.colorScheme\n      ) {\n        result = highlight(input);\n        previous = input;\n      }\n      return result;\n    },\n  };\n}\n\n/** Stable props keep Mantine's synchronous adapter out of intermediate renders. */\nconst OrdinaryCodeHighlight = memo(function OrdinaryCodeHighlight({\n  code,\n  language,\n  fileName,\n  fontSize,\n  defaultExpanded,\n}: {\n  code: string;\n  language: string;\n  fileName: string;\n  fontSize: number | string;\n  defaultExpanded: boolean;\n}) {\n  const highlight = useHighlight();\n  const adapter = useMemo(() => createCachedHighlightAdapter(highlight), [highlight]);\n  return (\n    \n      {fileName === 'unknown' ? (\n        ]}\n        />\n      ) : (\n        ]}\n        />\n      )}\n    \n  );\n});\n\n/**\n * Code languages that receive specialized rendering instead of standard\n * syntax-highlighted code blocks. Adding a new member here automatically\n * marks that language as \"special\" — you only need to add the corresponding\n * rendering branch in the component's return.\n */\nenum SpecialCodeLanguage {\n  /** Rendered as interactive diagrams via {@link MantineAIMMermaidCode} */\n  Mermaid = 'mermaid',\n}\n\n/** O(1) lookup set, derived from {@link SpecialCodeLanguage}. */\nconst SPECIAL_LANGUAGES = new Set(Object.values(SpecialCodeLanguage));\n\n/**\n * Mantine code block renderer for `
` elements.\n *\n * Replaces the default `
` rendering with Mantine's {@link CodeHighlight} or\n * {@link CodeHighlightTabs} components, providing syntax highlighting, expand/collapse\n * behavior, and file-name tabs.\n *\n * Behavior:\n * - If the code block has an explicit language annotation, uses that language.\n * - If no language is specified and the `codeBlock` group's\n *   `autoDetectUnknownLanguage` option is enabled, uses `highlight.js`\n *   auto-detection.\n * - Mermaid code blocks (`language-mermaid`) are rendered as interactive diagrams\n *   via {@link MantineAIMMermaidCode}.\n * - JSON code blocks are formatted without rounding numeric tokens; nested expansion is optional.\n * - Unrecognized languages render as plaintext with an \"unknown\" label using\n *   {@link CodeHighlight} (no tabs).\n * - Recognized languages render with {@link CodeHighlightTabs} showing the\n *   language name as the tab label.\n *\n * @param props.codeText - The raw text content of the code block.\n * @param props.existLanguage - Language identifier extracted from the `language-*` CSS class, if present.\n */\nconst MantineAIMPreCode = memo(\n  (\n    props: HTMLAttributes & {\n      codeText: string;\n      existLanguage?: string;\n    }\n  ) => {\n    const { fontSize } = useAIMarkdownTheme();\n    const { streaming } = useAIMarkdownState();\n    const { autoDetectUnknownLanguage, defaultExpanded, formatJson, expandNestedJson, highlightIntervalMs } =\n      useMantineCodeBlockOptions();\n\n    const detectedLanguage = useAutoDetectedLanguage(\n      props.codeText,\n      autoDetectUnknownLanguage && !props.existLanguage,\n      streaming\n    );\n    // Lower-cased once for every decision below: fence languages arrive in\n    // whatever case the model wrote (` ```Mermaid `, ` ```JSON `), and both\n    // the special-language switch and the JSON branch must agree\n    // (2026-08 project review, pkg-small-08 — the mermaid check was\n    // case-sensitive while the JSON check was not).\n    const codeLanguage = (props.existLanguage || detectedLanguage).toLowerCase();\n\n    // The language is passed straight to Mantine's highlighter, whose\n    // adapter already degrades unknown languages to plaintext; the label\n    // is \"unknown\" only when there is no language at all.\n    const [usedCodeLanguage, usedFileName] = useMemo(\n      () => (codeLanguage ? [codeLanguage, codeLanguage] : ['plaintext', 'unknown']),\n      [codeLanguage]\n    );\n\n    const isSpecialCodeBlock = SPECIAL_LANGUAGES.has(codeLanguage);\n\n    const [scanJson] = useState(createJsonCompletenessScanner);\n    const jsonComplete = useMemo(\n      () => (usedCodeLanguage === 'json' && formatJson && streaming ? scanJson(props.codeText) : false),\n      [usedCodeLanguage, formatJson, streaming, scanJson, props.codeText]\n    );\n\n    const normalCodeBlockContent = useMemo(() => {\n      if (isSpecialCodeBlock) return null;\n      let usedCodeStr = props.codeText;\n      // JSON pretty-print as soon as the block LOOKS complete: a streamed\n      // prefix never parses, so trying to pretty-print every chunk of a\n      // growing block was O(n²) work for nothing (pkg-small-06) — but a\n      // block that finished mid-document must not wait for the whole\n      // message to end. \"Ends with a closing bracket\" alone was not enough\n      // of a tell: pretty-printed JSON (the common LLM shape) ends a chunk\n      // on `}` / `]` at almost every nesting level, so the parse still ran\n      // on nearly every chunk (v2.4.1 review). Only a BALANCED bracket\n      // scan (strings skipped, one linear pass) admits the parse.\n      if (formatJson && usedCodeStr && usedCodeLanguage === 'json' && (!streaming || jsonComplete)) {\n        usedCodeStr = prettyPrintJson(usedCodeStr, expandNestedJson);\n      }\n      return usedCodeStr;\n    }, [isSpecialCodeBlock, props.codeText, usedCodeLanguage, streaming, formatJson, expandNestedJson, jsonComplete]);\n    const displayedCode = useCodeFrame(\n      normalCodeBlockContent ?? '',\n      usedCodeLanguage,\n      streaming && !isSpecialCodeBlock,\n      highlightIntervalMs\n    );\n\n    const specialCodeBlockContent = useMemo(() => {\n      switch (codeLanguage) {\n        case SpecialCodeLanguage.Mermaid:\n          return ;\n        default:\n          return null;\n      }\n    }, [codeLanguage, props.codeText]);\n\n    return isSpecialCodeBlock ? (\n      specialCodeBlockContent\n    ) : (\n      \n        \n      \n    );\n  }\n);\n\nMantineAIMPreCode.displayName = 'MantineAIMPreCode';\n\nexport default MantineAIMPreCode;\n","/**\n * Narrow hook for the mantine `codeBlock` behavior group.\n *\n * This is THE single type-assertion site for the group (the pattern that\n * retires the public caller-asserted `TConfig` generic): the opaque\n * extension record from `useAIMarkdownBehaviors()` is narrowed here, and\n * group defaults are applied here — read sites must consume this hook and\n * never re-apply defaults with bare `??` (multiple read sites duplicating\n * defaults will drift).\n *\n * @module hooks/useMantineCodeBlockOptions\n */\n\nimport { useMemo } from 'react';\nimport { useAIMarkdownBehaviors } from '@ai-react-markdown/core';\nimport { defaultMantineCodeBlockOptions, type MantineCodeBlockOptions } from '../defs';\n\n/**\n * Read the resolved code-block options from the behaviors context.\n *\n * Group values replace atomically at the transport layer; defaults are\n * filled in here, so a partial group (e.g. `codeBlock={{ defaultExpanded:\n * false }}`) resolves the omitted fields to the shipped defaults.\n *\n * Must be called inside a `` (or any ``\n * wrapped in the mantine Provider stack) — throws outside, same contract\n * as the core narrow hooks.\n */\nexport function useMantineCodeBlockOptions(): Required {\n  const behaviors = useAIMarkdownBehaviors();\n  // The single assertion: the `codeBlock` group key is owned by this\n  // package, contributed by `MantineAIMarkdown` via its behaviors Provider.\n  const group = behaviors.codeBlock as Partial | undefined;\n  return useMemo(() => {\n    // Field-wise `??` rather than a spread: `codeBlock={{ defaultExpanded:\n    // undefined }}` type-checks, and a spread would let that explicit\n    // undefined punch through the default while the signature promises\n    // `Required<…>` (2026-08 project review, pkg-small-12).\n    const resolved = { ...defaultMantineCodeBlockOptions } as Required;\n    for (const key of Object.keys(defaultMantineCodeBlockOptions) as Array) {\n      const value = group?.[key];\n      if (value !== undefined) (resolved as Record)[key] = value;\n    }\n    if (!Number.isFinite(resolved.highlightIntervalMs) || resolved.highlightIntervalMs < 0) {\n      resolved.highlightIntervalMs = defaultMantineCodeBlockOptions.highlightIntervalMs!;\n    }\n    return resolved;\n  }, [group]);\n}\n","/**\n * Mantine-specific type definitions and defaults: the `codeBlock` behavior\n * group and the metadata extension point.\n *\n * @module defs\n */\n\nimport { AIMarkdownMetadata } from '@ai-react-markdown/core';\n\n/**\n * Code block rendering options (the mantine `codeBlock` behavior group).\n *\n * v2 transport: passed as the flat `codeBlock` prop on `MantineAIMarkdown`\n * (group value replaces atomically) and read through\n * `useMantineCodeBlockOptions()`, which applies the defaults below inside\n * the hook — the single place defaults live at read time.\n */\nexport interface MantineCodeBlockOptions {\n  /**\n   * Whether code blocks start in their expanded state.\n   * When `false`, long code blocks are collapsed with an expand button.\n   *\n   * @default true\n   */\n  defaultExpanded: boolean;\n\n  /**\n   * When `true`, uses `highlight.js` auto-detection to determine the language\n   * of code blocks that lack an explicit language annotation.\n   *\n   * @default false\n   */\n  autoDetectUnknownLanguage: boolean;\n  /** Format JSON for display without changing numeric literals. @default true */\n  formatJson?: boolean;\n  /** Expand string values containing JSON objects/arrays for display. @default true */\n  expandNestedJson?: boolean;\n  /** Coalesce appended code display updates while streaming. Completion,\n   * replacement and language changes update immediately; copy uses latest\n   * source. Set 0 for every update. @default 50 */\n  highlightIntervalMs?: number;\n}\n\n/** Shipped defaults for the `codeBlock` behavior group. */\nexport const defaultMantineCodeBlockOptions: Readonly = Object.freeze({\n  defaultExpanded: true,\n  autoDetectUnknownLanguage: false,\n  formatJson: true,\n  expandNestedJson: true,\n  highlightIntervalMs: 50,\n});\n\n/**\n * Metadata type for the Mantine integration.\n *\n * Currently identical to {@link AIMarkdownMetadata}. Exists as an extension point\n * so that consumers can augment metadata in Mantine-specific wrappers without\n * needing to reference the core type directly.\n */\nexport interface MantineAIMarkdownMetadata extends AIMarkdownMetadata {}\n","/** Mermaid owns global configuration and a global renderer. Keep initialize,\n * parse and render in one serialized task. Each mounted diagram retains at\n * most one pending task; superseded frames never enter Mermaid. */\nexport function createRenderQueue() {\n  type Job = { run: () => Promise; resolve: () => void; reject: (error: unknown) => void };\n  const pending = new Map();\n  let running = false;\n  async function drain() {\n    if (running) return;\n    running = true;\n    try {\n      while (pending.size) {\n        const [owner, job] = pending.entries().next().value!;\n        pending.delete(owner);\n        try {\n          await job.run();\n          job.resolve();\n        } catch (error) {\n          job.reject(error);\n        }\n      }\n    } finally {\n      running = false;\n    }\n  }\n  return {\n    enqueue(owner: object, run: () => Promise): Promise {\n      pending.get(owner)?.resolve();\n      const promise = new Promise((resolve, reject) => pending.set(owner, { run, resolve, reject }));\n      void drain();\n      return promise;\n    },\n    cancel(owner: object) {\n      pending.get(owner)?.resolve();\n      pending.delete(owner);\n    },\n  };\n}\n\nexport const mermaidRenderQueue = createRenderQueue();\n","'use client';\n\nimport { mermaidRenderQueue } from './renderQueue';\n\nimport React, { memo, useEffect, useRef, useState, useCallback } from 'react';\nimport { CodeHighlightControl, CodeHighlightTabs } from '@mantine/code-highlight';\nimport { ActionIcon, CopyButton, Flex, Tooltip } from '@mantine/core';\nimport type mermaidModule from 'mermaid';\nimport { useAIMarkdownState, useAIMarkdownTheme } from '@ai-react-markdown/core';\nimport { useMantineCodeBlockOptions } from '../../../hooks/useMantineCodeBlockOptions';\nimport './styles.scss';\n\n/** Static `
` style for the mermaid container. */\nconst PRE_STYLE = { cursor: 'pointer', overflow: 'auto', width: '100%', padding: '0.5rem' } as const;\n\n/**\n * What the component currently shows. One value instead of separate\n * `hasRendered`/`renderError`/`chartType` fields whose combinations had to\n * be kept coherent by hand:\n * - `source`: warm-up / SSR fallback — raw code as a plain code block\n *   (nothing rendered yet this generation).\n * - `diagram`: the last successful SVG is up.\n * - `error`: the error tab — only a post-stream corrective failure or a\n *   never-rendered static failure can enter this state.\n *\n * The user's source toggle (`showOriginalCode`) is deliberately NOT a\n * phase: it overlays any view and flipping it back must restore the prior\n * one unchanged.\n */\ntype MermaidView = { kind: 'source' } | { kind: 'diagram'; chartType: string } | { kind: 'error' };\n\n/** Equality used to skip no-op view updates — repeat mid-stream successes\n *  of the same chart type must not re-render the host per chunk. */\nconst sameView = (a: MermaidView, b: MermaidView): boolean =>\n  a.kind === 'diagram' && b.kind === 'diagram' ? a.chartType === b.chartType : a.kind === b.kind;\n\ntype Mermaid = typeof mermaidModule;\n\n/**\n * mermaid is loaded on demand — the FIRST diagram that actually renders\n * pays the import; an app whose content never contains a mermaid fence\n * never downloads the ~1.5 MB module (2026-08 project review,\n * pkg-small-03: the static import sat on the default `pre` component's\n * import chain, so every consumer's main bundle carried it). The promise is\n * cached module-wide; the source-view warm-up covers the loading window.\n */\nlet mermaidPromise: Promise | null = null;\n/** Bounded automatic retries of a failed mermaid module download. */\nconst MERMAID_LOAD_RETRIES = 3;\nconst MERMAID_LOAD_RETRY_MS = 1500;\nconst loadMermaid = (): Promise => {\n  // A rejected load is not cached — the next render attempt retries.\n  mermaidPromise ??= import('mermaid').then(\n    (m) => m.default,\n    (err: unknown) => {\n      mermaidPromise = null;\n      throw err;\n    }\n  );\n  return mermaidPromise;\n};\n\n/** Theme mermaid.initialize was last called with. mermaid's config is a\n *  module-level singleton, so re-asserting an unchanged theme before every\n *  render attempt (each streamed chunk re-runs the effect) is pure waste —\n *  but instances under providers with DIFFERENT schemes must each\n *  re-assert before their own render, so the cache is module-level and\n *  checked per attempt rather than hoisted into a per-instance effect. */\nlet initializedTheme: 'dark' | 'light' | null = null;\n\n/**\n * mermaid's config is a module-level singleton shared with the host\n * application when the bundler dedupes the package, and a host that enables\n * `click` interactions calls `mermaid.initialize({ securityLevel: 'loose' })`\n * — the officially documented way. Under `loose` mermaid skips DOMPurify\n * and its output goes into this component's `innerHTML` verbatim: an\n * LLM-authored diagram string could then run script in the page origin.\n * So the theme cache alone is not enough of a guard: before every render\n * the current `securityLevel` is read back (`mermaidAPI.getConfig()` — a\n * config copy, still far cheaper than `initialize`'s merge + theme\n * variables + diagram registration) and a non-strict value forces a\n * re-initialize\n * (2026-08-19 review r2 P2-11; the v2.4.2 \"documented premise\" made this\n * the host's problem — it is ours, the innerHTML is ours).\n */\nconst ensureMermaidInitialized = (mermaid: Mermaid, isDark: boolean) => {\n  const theme = isDark ? 'dark' : 'light';\n  // `getConfig` lives on `mermaid.mermaidAPI` (deprecated in the types, present\n  // at runtime in mermaid 11) — the default export has none, a cast hid that\n  // and the guard never short-circuited (oracle review of the r2 batch).\n  const api = (mermaid as { mermaidAPI?: { getConfig?: () => { securityLevel?: string } } }).mermaidAPI;\n  const currentLevel = api?.getConfig?.().securityLevel;\n  if (initializedTheme === theme && currentLevel === 'strict') return;\n  mermaid.initialize({\n    startOnLoad: false,\n    securityLevel: 'strict',\n    theme: isDark ? 'dark' : 'base',\n    darkMode: isDark,\n    // Without a svgContainingElement, a draw-phase throw (an error that\n    // got past mermaid.parse) leaves mermaid's temp element orphaned in\n    // document.body — its error path only cleans up when this flag is\n    // set. We render our own error tab anyway, so mermaid's built-in\n    // error diagram is dead weight here regardless.\n    suppressErrorRendering: true,\n  });\n  initializedTheme = theme;\n};\n\n/**\n * Generate a unique ID for mermaid SVG rendering.\n * Combines a timestamp with a random suffix to avoid collisions when\n * multiple mermaid diagrams render concurrently.\n *\n * @returns A unique string in the format `mermaid-{timestamp}-{random}`.\n */\nconst generateMermaidUUID = () => {\n  return `mermaid-${new Date().getTime()}-${Math.random().toString(36).slice(2, 10)}`;\n};\n\n/**\n * Open the rendered mermaid SVG in a new browser window.\n *\n * Clones the SVG element, applies a background color matching the current\n * color scheme, serializes it to an object URL, and opens it in a new tab.\n * The object URL is revoked after a short delay to free memory.\n *\n * @param svgElement - The rendered SVG element to view, or `null`/`undefined` to no-op.\n * @param isDark - Whether the current color scheme is dark (used for background color).\n */\nconst handleViewSVGInNewWindow = (svgElement: SVGElement | null | undefined, isDark: boolean) => {\n  if (!svgElement) return;\n  const targetSvg = svgElement.cloneNode(true) as SVGElement;\n  targetSvg.style.backgroundColor = isDark ? '#242424' : 'white';\n  const text = new XMLSerializer().serializeToString(targetSvg);\n  const blob = new Blob([text], { type: 'image/svg+xml' });\n  const url = URL.createObjectURL(blob);\n  // The blob URL is same-origin — object URLs inherit the origin that made\n  // them — so this opens as a top-level document in the application's own\n  // origin, and reviews keep flagging it. Examined and kept as it is on\n  // 2026-08-20 (do not re-report):\n  //\n  // Loading the SVG as a document does revive `