@docfuse/markdown 0.1.0

package/dist/client/chunks/table-DBiKAEbC.js

@@ -0,0 +1,30 @@
+import { c as l, j as d } from "./react-runtime-ByABE9MG.js";
+import { a as t, b as s } from "./serialized-BvfsNeRQ.js";
+import { w as b } from "./provider-DL6V8F7z.js";
+function n(a, e) {
+  return l.hydrateRoot(
+    a,
+    b(
+      /* @__PURE__ */ d.jsx(
+        t,
+        {
+          className: a.className,
+          tableTitle: a.dataset.dfTableTitle,
+          copyLabel: a.dataset.dfCopyLabel,
+          copyFailureLabel: a.dataset.dfCopyFailureLabel,
+          downloadLabel: a.dataset.dfDownloadLabel,
+          zoomLabel: a.dataset.dfZoomLabel,
+          closeLabel: a.dataset.dfCloseLabel,
+          sortLabel: a.dataset.dfSortLabel,
+          serializedTable: a.dataset.dfTable,
+          inner: !0,
+          children: s(a.dataset.dfTable, e)
+        }
+      ),
+      e
+    )
+  );
+}
+export {
+  n as hydrate
+};

package/dist/client/index.js

@@ -0,0 +1,4 @@
+import { e as n } from "./chunks/client-DIoaSmq2.js";
+export {
+  n as enhanceMarkdown
+};

package/dist/client/nativeBehaviors.d.ts

@@ -0,0 +1,4 @@
+import type { MarkdownBehaviorName } from '../compiler/assets';
+/** Behaviors implemented through reversible delegated DOM enhancement. */
+export declare const NATIVE_MARKDOWN_BEHAVIOR_NAMES: readonly ["code-toolbar", "copy-snippet", "terminal-toolbar", "heading", "tabs", "details", "file-tree"];
+export declare function enhanceNativeMarkdown(root: ParentNode, behaviors: readonly MarkdownBehaviorName[]): () => void;

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import { type MarkdownAssets } from './compiler/assets';
+export interface MarkdownEnhancement {
+    /** Resolves when all requested rich behaviors have loaded. */
+    ready: Promise<void>;
+    /** Removes native listeners and unmounts rich behavior roots. */
+    dispose(): void;
+}
+/**
+ * Enhance the semantic Markdown DOM produced by the server renderer.
+ *
+ * The implementation chooses native DOM behavior or a lazy rich runtime for
+ * each resource fact; hosts do not need to know how an interaction is built.
+ */
+export declare function enhanceMarkdown(root?: ParentNode, assets?: Pick<MarkdownAssets, 'behaviors'>): MarkdownEnhancement;
+export type { MarkdownAssets, MarkdownBehaviorName } from './compiler/assets';

package/dist/compiler/analyze.d.ts

@@ -0,0 +1,27 @@
+import { type MarkdownDirectiveIssue } from './directiveValidation';
+import type { MarkdownPlugin } from './types';
+export interface MarkdownHeading {
+    level: number;
+    text: string;
+    slug: string;
+}
+export interface MarkdownCodeExample {
+    language: string;
+    meta?: string;
+    code: string;
+}
+export interface MarkdownAnalysis {
+    text: string;
+    headings: MarkdownHeading[];
+    codeExamples: MarkdownCodeExample[];
+    links: string[];
+    images: string[];
+    missingCodeBlockLanguages: number;
+    directiveIssues: MarkdownDirectiveIssue[];
+}
+export interface AnalyzeMarkdownOptions {
+    /** Plugins whose declared directives should be accepted for this source. */
+    plugins?: readonly MarkdownPlugin[];
+}
+/** Parse navigation/search metadata using syntax that is always part of the Markdown core. */
+export declare function analyzeMarkdown(source: string, options?: AnalyzeMarkdownOptions): MarkdownAnalysis;

package/dist/compiler/assets.d.ts

@@ -0,0 +1,29 @@
+import type { MarkdownPlugin, MarkdownPluginClientAsset, MarkdownPluginStyleAsset } from './types';
+export interface MarkdownAssets {
+    /** Browser behaviors required by the rendered document. */
+    behaviors: MarkdownBehaviorName[];
+    /** Whether the document needs KaTeX CSS and font resources. */
+    math: boolean;
+    /** Browser entries contributed by active compiler plugins. */
+    pluginClients: MarkdownPluginClientAsset[];
+    /** Published CSS entries contributed by active compiler plugins. */
+    pluginStyles: MarkdownPluginStyleAsset[];
+}
+/** Canonical browser behavior facts shared by the compiler and client runtime. */
+export declare const MARKDOWN_BEHAVIOR_NAMES: readonly ["gallery", "code-toolbar", "copy-snippet", "terminal-toolbar", "table", "image", "heading", "tabs", "details", "file-tree"];
+export type MarkdownBehaviorName = (typeof MARKDOWN_BEHAVIOR_NAMES)[number];
+export interface MarkdownAssetCollector {
+    markBehavior(name: MarkdownBehaviorName): void;
+    markMath(): void;
+    markPluginAssets(plugin: MarkdownPlugin): void;
+    snapshot(): MarkdownAssets;
+}
+export declare function createMarkdownAssetCollector(): MarkdownAssetCollector;
+/**
+ * Conservative source-level detection for MDX pages.
+ *
+ * MDX is evaluated by its own compiler, so it cannot reuse the Markdown HAST
+ * visitor without first executing trusted JSX. This detector intentionally
+ * prefers a false positive over omitting an interaction script.
+ */
+export declare function detectMarkdownAssets(source: string, plugins?: readonly MarkdownPlugin[], mode?: 'markdown' | 'mdx'): MarkdownAssets;

package/dist/compiler/ast.d.ts

@@ -0,0 +1,68 @@
+import type { BlockContent, Data, RootContent } from 'mdast';
+import type { Properties } from 'hast';
+import type { Parent } from 'unist';
+interface TabItemData extends Data {
+    tabLabel: string;
+    tabLanguage?: string;
+    tabValue: string;
+    tabIndex: number;
+}
+export interface TabItem extends Parent {
+    type: 'tabItem';
+    data: TabItemData;
+    children: BlockContent[];
+}
+interface TabGroupData extends Data {
+    tabGroupLabel: string;
+    tabGroupKind: 'tabs' | 'code-group';
+}
+export interface TabGroup extends Parent {
+    type: 'tabGroup';
+    data: TabGroupData;
+    children: TabItem[];
+}
+interface StepItemData extends Data {
+    stepTitle: string;
+    stepIndex: number;
+}
+export interface StepItem extends Parent {
+    type: 'stepItem';
+    data: StepItemData;
+    children: BlockContent[];
+}
+interface StepGroupData extends Data {
+    stepLabel: string;
+}
+export interface StepGroup extends Parent {
+    type: 'stepGroup';
+    data: StepGroupData;
+    children: StepItem[];
+}
+export interface CalloutPart extends Parent {
+    type: 'calloutBody' | 'calloutTitle';
+    children: RootContent[];
+}
+declare module 'unist' {
+    interface Data {
+        directiveLabel?: boolean | null;
+        hName?: string;
+        hProperties?: Properties;
+    }
+}
+declare module 'mdast' {
+    interface BlockContentMap {
+        tabGroup: TabGroup;
+        tabItem: TabItem;
+        stepGroup: StepGroup;
+        stepItem: StepItem;
+        calloutPart: CalloutPart;
+    }
+    interface RootContentMap {
+        tabGroup: TabGroup;
+        tabItem: TabItem;
+        stepGroup: StepGroup;
+        stepItem: StepItem;
+        calloutPart: CalloutPart;
+    }
+}
+export {};

package/dist/compiler/createPipeline.d.ts

@@ -0,0 +1,18 @@
+import { type Pluggable, type Plugin, type Transformer } from 'unified';
+import type { Root as HastRoot } from 'hast';
+import type { MarkdownAssetCollector } from './assets';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+import type { MarkdownSyntaxFeatures } from './syntaxFeatures';
+import type { Options as SanitizeOptions } from 'rehype-sanitize';
+interface CreateMarkdownProcessorOptions {
+    assets: MarkdownAssetCollector;
+    options: NormalizedMarkdownOptions;
+    rehypeRaw?: () => Transformer<HastRoot, HastRoot>;
+    rehypeSanitize?: Plugin<[SanitizeOptions?], HastRoot, HastRoot>;
+    sanitizeSchema?: SanitizeOptions;
+    syntax: MarkdownSyntaxFeatures;
+    syntaxHighlighter?: Pluggable;
+}
+/** Assemble Markdown and MDX from the same ordered plugin plan. */
+export declare function createMarkdownProcessor({ assets, options, rehypeRaw, rehypeSanitize, sanitizeSchema, syntax, syntaxHighlighter }: CreateMarkdownProcessorOptions): import("unified").Processor<import("mdast").Root, import("mdast").Root, HastRoot, undefined, undefined>;
+export {};

package/dist/compiler/defaultLabels.d.ts

@@ -0,0 +1,28 @@
+export declare const DEFAULT_MARKDOWN_LABELS: {
+    copyCode: string;
+    copyFailed: string;
+    copySnippet: string;
+    copyTerminal: string;
+    terminalTitle: string;
+    tabsTitle: string;
+    tabItem: string;
+    codeGroupTitle: string;
+    codeGroupItem: string;
+    taskCompleted: string;
+    taskIncomplete: string;
+    copySectionLink: string;
+    tableTitle: string;
+    copyTableCsv: string;
+    downloadTableCsv: string;
+    zoomTable: string;
+    closeTablePreview: string;
+    sortTableColumn: string;
+    zoomImage: string;
+    closeImagePreview: string;
+    imageGallery: string;
+    closeImageGallery: string;
+    previousGalleryImage: string;
+    nextGalleryImage: string;
+    galleryThumbnails: string;
+    galleryImage: string;
+};

package/dist/compiler/directiveValidation.d.ts

@@ -0,0 +1,17 @@
+import type { Root } from 'mdast';
+import type { Node } from 'unist';
+export interface MarkdownDirectiveIssue {
+    message: string;
+    line?: number;
+    column?: number;
+}
+interface LocatedDirectiveIssue extends MarkdownDirectiveIssue {
+    node: Node;
+}
+/** Validate the public Docfuse directive grammar and explicitly declared plugin directives. */
+export declare function collectRichDirectiveIssues(tree: Root, pluginDirectiveNames?: ReadonlySet<string>): LocatedDirectiveIssue[];
+/** Stop rendering malformed core directives before a transform can discard content. */
+export declare const remarkValidateRichDirectives: (pluginDirectiveNames?: ReadonlySet<string>) => (tree: Root, file: {
+    fail(message: string, node?: Node): never;
+}) => void;
+export {};

package/dist/compiler/highlighter.d.ts

@@ -0,0 +1,3 @@
+import type { Pluggable } from 'unified';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+export declare function createSyntaxHighlighterPlugin(codeLanguages: readonly string[], options: NormalizedMarkdownOptions, warnedLanguages?: Set<string>, excludedLanguages?: ReadonlySet<string>): Promise<Pluggable>;

package/dist/compiler/mdxModules.d.ts

@@ -0,0 +1,19 @@
+export interface MdxImportBinding {
+    imported: string;
+    local: string;
+    namespace?: boolean;
+}
+export interface MdxImportDeclaration {
+    specifier: string;
+    bindings: MdxImportBinding[];
+}
+export interface MdxModuleBoundary {
+    imports: MdxImportDeclaration[];
+    sourceWithoutImports: string;
+    unsupportedReferences: Array<{
+        kind: 'dynamic-import' | 'export-from';
+        specifier?: string;
+    }>;
+}
+/** Parse only real top-level MDX module syntax, leaving fenced examples intact. */
+export declare function analyzeMdxModuleBoundary(source: string): MdxModuleBoundary;

package/dist/compiler/mdxPlugins.d.ts

@@ -0,0 +1,16 @@
+import { type MarkdownAssets } from './assets';
+import type { RenderMarkdownOptions } from './types';
+import type { PluggableList } from 'unified';
+import type { MarkdownHandlers } from './pluginPlan';
+import type { MarkdownCompilerContext } from './prepareMarkdown';
+interface MarkdownMdxPlugins {
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    remarkRehypeOptions: {
+        handlers: MarkdownHandlers;
+    };
+    getAssets: () => MarkdownAssets;
+}
+/** MDX owns JSX evaluation while sharing Markdown's ordered plugin plan. */
+export declare function createMarkdownMdxPlugins(options?: RenderMarkdownOptions, source?: string, context?: MarkdownCompilerContext): Promise<MarkdownMdxPlugins>;
+export {};

package/dist/compiler/normalizeOptions.d.ts

@@ -0,0 +1,16 @@
+import type { LanguageInput, ThemeRegistration } from '@shikijs/types';
+import type { MarkdownFeatureOptions, MarkdownHtmlPolicy, MarkdownLabels, MarkdownPlugin, MarkdownUnknownLanguagePolicy, RenderMarkdownOptions } from './types';
+export interface NormalizedMarkdownOptions {
+    htmlPolicy: MarkdownHtmlPolicy;
+    codeThemes: {
+        light: string | ThemeRegistration;
+        dark: string | ThemeRegistration;
+    };
+    fallbackLanguage: string;
+    codeLanguages: Readonly<Record<string, LanguageInput>>;
+    unknownLanguage: MarkdownUnknownLanguagePolicy;
+    features: Required<MarkdownFeatureOptions>;
+    labels: MarkdownLabels;
+    plugins: readonly MarkdownPlugin[];
+}
+export declare function normalizeOptions(options?: RenderMarkdownOptions): NormalizedMarkdownOptions;

package/dist/compiler/pluginPlan.d.ts

@@ -0,0 +1,18 @@
+import type { Options as RemarkRehypeOptions } from 'remark-rehype';
+import type { Pluggable, PluggableList } from 'unified';
+import type { MarkdownAssetCollector } from './assets';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+import { rehypeStepGroup, rehypeStepItem, rehypeTabGroup, rehypeTabItem } from './plugins/directives';
+import type { MarkdownSyntaxFeatures } from './syntaxFeatures';
+export interface MarkdownPluginPlan {
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    handlers: MarkdownHandlers;
+}
+export type MarkdownHandlers = NonNullable<RemarkRehypeOptions['handlers']> & {
+    tabGroup: typeof rehypeTabGroup;
+    tabItem: typeof rehypeTabItem;
+    stepGroup: typeof rehypeStepGroup;
+    stepItem: typeof rehypeStepItem;
+};
+export declare function createMarkdownPluginPlan(mode: 'markdown' | 'mdx', assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions, syntax: MarkdownSyntaxFeatures, syntaxHighlighter?: Pluggable): MarkdownPluginPlan;

package/dist/compiler/plugins/code.d.ts

@@ -0,0 +1,16 @@
+import type { Root as HastRoot } from 'hast';
+import type { Root as MdastRoot } from 'mdast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Track explicit React components embedded in trusted MDX. */
+export declare const remarkMdxIslandTracker: (assets: MarkdownAssetCollector) => (tree: MdastRoot) => void;
+/** Preserve fenced block metadata through raw HTML sanitization. */
+export declare const remarkFenceMetadata: (options: NormalizedMarkdownOptions) => (tree: MdastRoot) => void;
+/** Copy authored code titles onto the pre element before Shiki replaces code children. */
+export declare const rehypeFenceMetadata: () => (tree: HastRoot) => void;
+/** Convert special fenced code into serializable inputs for React blocks. */
+export declare const rehypeRichFences: (assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions) => (tree: HastRoot) => void;
+/** Convert rich fences into React components for the MDX recma pipeline. */
+export declare const remarkMdxRichBlocks: (assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions) => (tree: MdastRoot) => void;
+/** Wrap each highlighted code block with a file/language label and copy action. */
+export declare const rehypeCodeBlocks: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"], excludedLanguages?: ReadonlySet<string>) => (tree: HastRoot) => void;

package/dist/compiler/plugins/directives.d.ts

@@ -0,0 +1,24 @@
+import type { Element, Root as HastRoot } from 'hast';
+import type { Root } from 'mdast';
+import type { State } from 'mdast-util-to-hast';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+import type { StepGroup, StepItem, TabGroup, TabItem } from '../ast';
+/**
+ * Keep the authoring interface small: directives describe intent and the
+ * compiler owns every `df-*` class, data attribute, slot, and ARIA detail.
+ */
+export declare const remarkRichDirectives: () => (tree: Root) => void;
+/** Finish rich directive structure after Markdown has become semantic HTML. */
+export declare const rehypeRichDirectives: () => (tree: HastRoot) => void;
+/** Allow the friendly `:::tip 标题` authoring syntax. */
+export declare function normalizeCallouts(markdown: string): string;
+/** Convert stable Tabs and Code Group directives into the shared tab model. */
+export declare const remarkTabGroups: (options: NormalizedMarkdownOptions) => (tree: Root) => void;
+/** Convert Steps directives into the shared ordered-list visual contract. */
+export declare const remarkSteps: (options: NormalizedMarkdownOptions) => (tree: Root) => void;
+export declare function rehypeStepItem(state: State, node: StepItem): Element;
+export declare function rehypeStepGroup(state: State, node: StepGroup): Element;
+export declare function rehypeTabItem(state: State, node: TabItem): Element;
+export declare function rehypeTabGroup(state: State, node: TabGroup): Element;
+/** Map `:::tip` containers onto the shared callout markup. */
+export declare const remarkCallouts: () => (tree: Root) => void;

package/dist/compiler/plugins/documentBlocks.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'hast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Add document-level semantics shared by the static and React renderers. */
+export declare const rehypeDocumentBlocks: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"]) => (tree: Root) => void;

package/dist/compiler/plugins/tables.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'hast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Turn GFM tables into a serializable data block; React owns table UI/state. */
+export declare const rehypeTables: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"]) => (tree: Root) => void;

package/dist/compiler/plugins.d.ts

@@ -0,0 +1,24 @@
+import type { MarkdownPlugin, MarkdownPluginContext } from './types';
+/** Validate plugin names and reject duplicates before the plan consumes them. */
+export declare function normalizeMarkdownPlugins(plugins?: readonly MarkdownPlugin[]): readonly MarkdownPlugin[];
+/**
+ * Serializable identity used by render caches and build fingerprints. Plugin
+ * functions cannot be fingerprinted, so `name`, `version` and `cacheKey` form
+ * the invalidation contract: bump `version` when the transform changes and
+ * derive `cacheKey` from resolved options.
+ */
+export declare function markdownPluginsIdentity(plugins?: readonly MarkdownPlugin[]): {
+    name: string;
+    version: string;
+    cacheKey: string | number | boolean | import("./types").MarkdownPluginCacheValue[] | {
+        [key: string]: import("./types").MarkdownPluginCacheValue;
+    } | null;
+}[];
+/** Typed identity helper that validates the plugin shape eagerly. */
+export declare function defineMarkdownPlugin(plugin: MarkdownPlugin): MarkdownPlugin;
+/** Resolve the plugins that apply to one source document. */
+export declare function activeMarkdownPlugins(plugins: readonly MarkdownPlugin[], context: MarkdownPluginContext): readonly MarkdownPlugin[];
+/** Collect normalized fenced-code labels owned by the active plugins. */
+export declare function markdownPluginFenceLanguages(plugins: readonly MarkdownPlugin[]): ReadonlySet<string>;
+/** Collect normalized directive names owned by the active plugins. */
+export declare function markdownPluginDirectiveNames(plugins: readonly MarkdownPlugin[]): ReadonlySet<string>;

package/dist/compiler/prepareMarkdown.d.ts

@@ -0,0 +1,11 @@
+import type { PreparedMarkdown, RenderMarkdownOptions } from './types';
+export type { MarkdownAssets } from './assets';
+export type { MarkdownCodeOptions, MarkdownFeatureOptions, MarkdownHtmlPolicy, MarkdownLabels, MarkdownPlugin, MarkdownPluginBrowserCompiler, MarkdownPluginCacheValue, MarkdownPluginClientAsset, MarkdownPluginClientResource, MarkdownPluginClientResourceDirectory, MarkdownPluginContext, MarkdownPluginStyleAsset, MarkdownUnknownLanguagePolicy, RenderMarkdownOptions } from './types';
+export interface MarkdownCompilerContext {
+    warnedLanguages: Set<string>;
+}
+/**
+ * Prepare Markdown as a transformed HAST document for the package's React
+ * renderers. This compiler boundary remains internal to the package.
+ */
+export declare function prepareMarkdown(source: string, options?: RenderMarkdownOptions, context?: MarkdownCompilerContext): Promise<PreparedMarkdown>;

package/dist/compiler/sanitizeBoundary.d.ts

@@ -0,0 +1,18 @@
+import type { Root } from 'hast';
+import type { Options as SanitizeOptions } from 'rehype-sanitize';
+import type { Plugin } from 'unified';
+export interface CompilerSanitizeBoundary {
+    mark: Plugin<[], Root, Root>;
+    protect: Plugin<[], Root, Root>;
+    restore: Plugin<[], Root, Root>;
+    schema: SanitizeOptions;
+}
+/**
+ * Preserve trusted compiler contracts while the default rehype schema cleans
+ * author HTML. This includes ids generated by remark-rehype: sanitizing those
+ * ids a second time would break footnote references. Raw author HTML is not an
+ * element until after `mark`, so its ids still receive the sanitizer's clobber
+ * prefix. A per-render nonce prevents authored markup from forging the
+ * temporary bridge, and only the exact compiler snapshots are restored.
+ */
+export declare function createCompilerSanitizeBoundary(defaultSchema: SanitizeOptions): CompilerSanitizeBoundary;

package/dist/compiler/stableJson.d.ts

@@ -0,0 +1,2 @@
+/** Deterministic JSON used only for optional cache identities. */
+export declare function stableJson(value: unknown): string | undefined;

package/dist/compiler/syntaxFeatures.d.ts

@@ -0,0 +1,10 @@
+export interface MarkdownSyntaxFeatures {
+    highlightedCode: boolean;
+    codeLanguages: readonly string[];
+}
+/**
+ * Cheap line scan used to skip transforms that cannot match. Tracking the
+ * opening marker prevents fenced examples inside longer fences from being
+ * mistaken for real code blocks.
+ */
+export declare function detectMarkdownSyntax(source?: string, pluginFenceLanguages?: ReadonlySet<string>): MarkdownSyntaxFeatures;

package/dist/compiler/types.d.ts

@@ -0,0 +1,177 @@
+import type { MarkdownAssets } from './assets';
+import type { Root } from 'hast';
+import type { LanguageInput } from '@shikijs/types';
+import type { PluggableList } from 'unified';
+export type MarkdownHtmlPolicy = 'trusted' | 'sanitize' | 'strip';
+export type MarkdownUnknownLanguagePolicy = 'warn' | 'error' | 'plain-text';
+export type MarkdownPluginCacheValue = string | number | boolean | null | MarkdownPluginCacheValue[] | {
+    [key: string]: MarkdownPluginCacheValue;
+};
+export interface MarkdownPluginBrowserCompiler {
+    /** Browser-safe package export that contains the plugin factory. */
+    module: string;
+    /** Named factory export, for example `mermaid` or `plantUml`. */
+    exportName: string;
+    /** JSON-serializable factory options used by browser-side Markdown compilers. */
+    options?: MarkdownPluginCacheValue;
+}
+export interface MarkdownCodeOptions {
+    themes?: {
+        light?: string;
+        dark?: string;
+    };
+    fallbackLanguage?: string;
+    /**
+     * Additional fence-language loaders keyed by the label authors use after
+     * the opening fence. Built-in technical-document languages remain enabled.
+     */
+    languages?: Readonly<Record<string, LanguageInput>>;
+    /** Behavior when neither a built-in nor custom language matches a fence. */
+    unknownLanguage?: MarkdownUnknownLanguagePolicy;
+}
+export interface MarkdownFeatureOptions {
+    callouts?: boolean;
+    tabs?: boolean;
+    codeGroups?: boolean;
+    steps?: boolean;
+    terminals?: boolean;
+    documentBlocks?: boolean;
+    /** Enhance GFM tables independently from other rich document blocks. */
+    tables?: boolean;
+    codeBlocks?: boolean;
+}
+export interface MarkdownLabels {
+    copyCode: string;
+    copyFailed: string;
+    copySnippet: string;
+    copyTerminal: string;
+    terminalTitle: string;
+    tabsTitle: string;
+    tabItem: string;
+    codeGroupTitle: string;
+    codeGroupItem: string;
+    taskCompleted: string;
+    taskIncomplete: string;
+    copySectionLink: string;
+    tableTitle: string;
+    copyTableCsv: string;
+    downloadTableCsv: string;
+    zoomTable: string;
+    closeTablePreview: string;
+    sortTableColumn: string;
+    zoomImage: string;
+    closeImagePreview: string;
+    imageGallery: string;
+    closeImageGallery: string;
+    previousGalleryImage: string;
+    nextGalleryImage: string;
+    galleryThumbnails: string;
+    galleryImage: string;
+}
+/**
+ * A build-time trusted compiler plugin. Plugins extend the shared Markdown and
+ * MDX pipeline with additional remark (mdast) and rehype (hast) transforms.
+ *
+ * Plugin functions cannot participate in cache fingerprints, so `name`,
+ * `version` and `cacheKey` carry the cache identity instead: bump `version`
+ * whenever the transform behavior changes and derive `cacheKey` from the
+ * plugin's resolved options.
+ */
+export interface MarkdownPlugin {
+    /** Unique lowercase kebab-case slug, e.g. "external-links". */
+    name: string;
+    /** Implementation revision; part of the cache identity. */
+    version?: string;
+    /** JSON-serializable configuration identity, typically resolved options. */
+    cacheKey?: MarkdownPluginCacheValue;
+    /**
+     * Optional browser compiler entry. Static sites use this only for explicit
+     * authoring surfaces such as the Playground; ordinary pages do not load it.
+     */
+    browserCompiler?: MarkdownPluginBrowserCompiler;
+    /** Applied before the core rich-block conversion, before remark-rehype. */
+    remarkPlugins?: PluggableList;
+    /** Appended after the built-in rehype plugins, at the end of the pipeline. */
+    rehypePlugins?: PluggableList;
+    /**
+     * Fenced-code language labels consumed by this plugin's remark transforms.
+     * Declaring them prevents the core Shiki loader from treating plugin-owned
+     * fences as ordinary code or reporting them as unsupported languages.
+     */
+    fenceLanguages?: readonly string[];
+    /**
+     * Directive names owned by this plugin. Undeclared directive names are
+     * rejected so author typos cannot silently degrade to generic HTML.
+     */
+    directiveNames?: readonly string[];
+    /**
+     * Optional source-level activation gate. Use this for expensive opt-in
+     * syntax so ordinary documents do not load or run the plugin.
+     */
+    appliesTo?: (context: MarkdownPluginContext) => boolean;
+    /** Static assets required whenever this plugin is active for a document. */
+    assets?: {
+        math?: boolean;
+        /** Browser entry points loaded only for pages that activate this plugin. */
+        clients?: readonly MarkdownPluginClientAsset[];
+        /** Published CSS entry points appended only for pages that activate this plugin. */
+        styles?: readonly MarkdownPluginStyleAsset[];
+    };
+}
+export interface MarkdownPluginClientAsset {
+    /** Stable identifier used for output naming and de-duplication. */
+    id: string;
+    /** Public package export, for example `@scope/plugin/client`. */
+    module: string;
+    /** Extra package files copied beside this client under a directory named after `id`. */
+    resources?: readonly MarkdownPluginClientResource[];
+}
+export interface MarkdownPluginClientResourceDirectory {
+    /** Directory relative to the resource entry point. Parent traversal is rejected. */
+    source: string;
+    /** Output directory relative to this client's resource directory. */
+    output: string;
+    /** Optional file suffix allowlist, for example `[".mjs"]`. */
+    extensions?: readonly string[];
+}
+export interface MarkdownPluginClientResource {
+    /** Package export resolved from the client asset's owning package. */
+    module: string;
+    /** Output file relative to this client's resource directory. */
+    output: string;
+    /** Chunk directories located beside the resolved resource entry. */
+    directories?: readonly MarkdownPluginClientResourceDirectory[];
+}
+export interface MarkdownPluginStyleAsset {
+    /** Stable identifier used for output naming and de-duplication. */
+    id: string;
+    /** Public package export, for example `@docfuse/plugins/diagram.css`. */
+    module: string;
+}
+export interface MarkdownPluginContext {
+    source: string;
+    mode: 'markdown' | 'mdx';
+}
+export interface RenderMarkdownOptions {
+    /**
+     * Raw HTML policy for markdown input.
+     *
+     * `trusted` preserves inline HTML and is intended for build-time docs content.
+     * `sanitize` parses HTML and removes unsafe elements, attributes and URLs.
+     * `strip` disables raw HTML parsing entirely.
+     * MDX remains executable trusted code and does not support safe HTML modes.
+     */
+    html?: MarkdownHtmlPolicy;
+    code?: MarkdownCodeOptions;
+    features?: MarkdownFeatureOptions;
+    labels?: Partial<MarkdownLabels>;
+    /** BCP 47 locale exposed to compiler plugins for locale-aware output. */
+    locale?: string;
+    /** Compiler plugins applied to both the Markdown and MDX pipelines. */
+    plugins?: readonly MarkdownPlugin[];
+}
+/** Serializable HAST output before HTML stringification. */
+export interface PreparedMarkdown {
+    document: Root;
+    assets: MarkdownAssets;
+}

package/dist/components/blocks/MarkdownCodeBlock.d.ts

@@ -0,0 +1,10 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+export interface MarkdownCodeBlockProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children?: ReactNode;
+    language?: string;
+    filename?: string;
+    source?: string;
+    copyLabel?: string;
+    copyFailureLabel?: string;
+}
+export declare function MarkdownCodeBlock({ children, source: directSource, language: directLanguage, filename: directFilename, copyLabel: directCopyLabel, copyFailureLabel: directCopyFailureLabel, ...inputProps }: MarkdownCodeBlockProps): import("react").JSX.Element;