@docfuse/markdown 0.1.0

package/dist/protocol/serializedNode.d.ts

@@ -0,0 +1,3 @@
+import type { Nodes } from 'hast';
+export declare function serializeMarkdownNode(node: unknown): string | undefined;
+export declare function deserializeMarkdownNode(value?: string): Nodes | undefined;

package/dist/react/Markdown.d.ts

@@ -0,0 +1,54 @@
+import { type ElementType, type HTMLAttributes, type ReactNode } from 'react';
+import { type MarkdownClassNames, type MarkdownComponents } from './componentMap';
+import type { PreparedMarkdown, RenderMarkdownOptions } from '../compiler/types';
+import { type MarkdownSlots } from './slots';
+import { type MarkdownUrlTransform } from './urlTransform';
+export interface MarkdownRootProps extends Omit<HTMLAttributes<HTMLElement>, 'children' | 'dangerouslySetInnerHTML'> {
+    /** Render element. Defaults to `div`. */
+    as?: ElementType;
+    /** Stable root marker used by Docfuse Islands and host automation. */
+    'data-df-root'?: string;
+    classNames?: MarkdownClassNames;
+    /** Local visual slots used by the React component map. */
+    slots?: MarkdownSlots;
+    /** Transform authored URL properties without scanning rendered HTML. */
+    urlTransform?: MarkdownUrlTransform;
+}
+export interface MarkdownProps extends MarkdownRootProps {
+    /** Markdown source. The compiler is intentionally hidden from callers. */
+    source: string;
+    /** Compiler options; visual tokens and interaction labels remain configurable. */
+    options?: RenderMarkdownOptions;
+    /** Optional callback invoked when browser-side preparation fails. */
+    onError?: (error: unknown) => void;
+    /** Optional callback invoked after prepared output has committed to the DOM. */
+    onReady?: () => void;
+    /** Optional content shown while preparing or after preparation fails. */
+    fallback?: ReactNode;
+    /** Keep the last prepared document visible while a newer source is compiling. */
+    retainPrevious?: boolean;
+    /** Intrinsic element overrides for structured Markdown output. */
+    components?: MarkdownComponents;
+}
+interface MarkdownDocumentProps extends MarkdownRootProps {
+    /** Prepared HAST document produced by the package's internal compiler. */
+    document: PreparedMarkdown['document'];
+    /** Optional intrinsic tag replacements for host-level customization. */
+    components?: MarkdownComponents;
+}
+interface MarkdownRootContentProps extends MarkdownRootProps {
+    children: ReactNode;
+}
+/** Shared root contract for Markdown and MDX React output. */
+export declare function MarkdownRoot({ as: Tag, className, classNames, slots, urlTransform, children, 'data-df-root': rootMarker, ...props }: MarkdownRootContentProps): import("react").FunctionComponentElement<{
+    transform?: MarkdownUrlTransform;
+    children: ReactNode;
+}>;
+/** Render a prepared HAST tree as React elements. */
+export declare function MarkdownDocument({ document, classNames, components, slots, urlTransform, ...props }: MarkdownDocumentProps): import("react").JSX.Element;
+/**
+ * Render Markdown directly from source. Preparation remains an internal
+ * implementation detail of the package's React entry point.
+ */
+export declare function Markdown({ source, options, onError, onReady, fallback, retainPrevious, ...props }: MarkdownProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null;
+export {};

package/dist/react/componentMap.d.ts

@@ -0,0 +1,172 @@
+import { type ComponentType, type ElementType, type JSX, type ReactNode } from 'react';
+import type { MarkdownCodeBlockProps } from '../components/blocks/MarkdownCodeBlock';
+import type { MarkdownCopySnippetProps } from '../components/blocks/MarkdownCopySnippet';
+import type { MarkdownImageProps } from '../components/blocks/MarkdownImage';
+import type { MarkdownTableProps } from '../components/blocks/MarkdownTable';
+import type { MarkdownTerminalProps } from '../components/blocks/MarkdownTerminal';
+import type { MarkdownCompositeProps, MarkdownDetailsProps } from '../components/composite/MarkdownComposite';
+import type { MarkdownFileTreeProps } from '../components/composite/MarkdownFileTree';
+import type { MarkdownTabsProps } from '../components/composite/MarkdownTabs';
+import type { ImageGalleryProps } from '../components/gallery/ImageGallery';
+import { type MarkdownSlots } from './slots';
+import { type MarkdownUrlTransform } from './urlTransform';
+export type MarkdownComponentMap = Record<string, ElementType>;
+/**
+ * Host overrides for intrinsic tags and named Markdown composites.
+ * Composite names are semantic so callers do not depend on wrapper classes.
+ */
+export interface MarkdownNamedComponentProps {
+    Callout: MarkdownCompositeProps;
+    Tabs: MarkdownTabsProps;
+    CodeGroup: MarkdownTabsProps;
+    Steps: MarkdownCompositeProps;
+    CodeBlock: MarkdownCodeBlockProps;
+    CopySnippet: MarkdownCopySnippetProps;
+    Table: MarkdownTableProps;
+    Image: MarkdownImageProps;
+    Terminal: MarkdownTerminalProps;
+    Details: MarkdownDetailsProps;
+    FileTree: MarkdownFileTreeProps;
+    Gallery: ImageGalleryProps;
+    CardGrid: MarkdownCompositeProps;
+    Api: MarkdownCompositeProps;
+    Aside: MarkdownCompositeProps;
+    Badge: MarkdownCompositeProps;
+}
+export type MarkdownIntrinsicComponents = {
+    [Tag in keyof JSX.IntrinsicElements]?: ComponentType<JSX.IntrinsicElements[Tag]>;
+};
+export type MarkdownComponents = MarkdownIntrinsicComponents & {
+    [Name in keyof MarkdownNamedComponentProps]?: ComponentType<MarkdownNamedComponentProps[Name]>;
+};
+/** Additional classes for stable Markdown element/component slots. */
+export interface MarkdownClassNames {
+    root?: string;
+    heading?: string;
+    paragraph?: string;
+    link?: string;
+    list?: string;
+    listItem?: string;
+    blockquote?: string;
+    horizontalRule?: string;
+    strong?: string;
+    emphasis?: string;
+    strikethrough?: string;
+    highlight?: string;
+    keyboard?: string;
+    superscript?: string;
+    subscript?: string;
+    inlineCode?: string;
+    code?: string;
+    codeBlock?: string;
+    copySnippet?: string;
+    table?: string;
+    tableHead?: string;
+    tableBody?: string;
+    tableRow?: string;
+    tableHeader?: string;
+    tableCell?: string;
+    taskCheckbox?: string;
+    callout?: string;
+    tabs?: string;
+    steps?: string;
+    image?: string;
+    video?: string;
+    audio?: string;
+    embed?: string;
+    definitionList?: string;
+    definitionTerm?: string;
+    definitionDescription?: string;
+    summary?: string;
+    footnotes?: string;
+    terminal?: string;
+    details?: string;
+    fileTree?: string;
+    gallery?: string;
+    cardGrid?: string;
+    api?: string;
+    aside?: string;
+    badge?: string;
+}
+export interface MarkdownElementProps {
+    children?: ReactNode;
+    node?: unknown;
+    [key: string]: unknown;
+}
+declare const componentDescriptors: {
+    readonly callout: {
+        readonly className: "callout";
+        readonly override: "Callout";
+    };
+    readonly tabs: {
+        readonly className: "tabs";
+        readonly override: "Tabs";
+    };
+    readonly 'code-group': {
+        readonly className: "tabs";
+        readonly override: "CodeGroup";
+    };
+    readonly steps: {
+        readonly className: "steps";
+        readonly override: "Steps";
+    };
+    readonly 'code-block': {
+        readonly className: "codeBlock";
+        readonly override: "CodeBlock";
+    };
+    readonly 'copy-snippet': {
+        readonly className: "copySnippet";
+        readonly override: "CopySnippet";
+    };
+    readonly table: {
+        readonly className: "table";
+        readonly override: "Table";
+    };
+    readonly image: {
+        readonly className: "image";
+        readonly override: "Image";
+    };
+    readonly terminal: {
+        readonly className: "terminal";
+        readonly override: "Terminal";
+    };
+    readonly details: {
+        readonly className: "details";
+        readonly override: "Details";
+    };
+    readonly 'file-tree': {
+        readonly className: "fileTree";
+        readonly override: "FileTree";
+    };
+    readonly gallery: {
+        readonly className: "gallery";
+        readonly override: "Gallery";
+    };
+    readonly 'card-grid': {
+        readonly className: "cardGrid";
+        readonly override: "CardGrid";
+    };
+    readonly api: {
+        readonly className: "api";
+        readonly override: "Api";
+    };
+    readonly aside: {
+        readonly className: "aside";
+        readonly override: "Aside";
+    };
+    readonly badge: {
+        readonly className: "badge";
+        readonly override: "Badge";
+    };
+};
+export type MarkdownComponentName = keyof typeof componentDescriptors;
+/**
+ * Shared structural map for Markdown HAST and MDX SSR.
+ *
+ * The map adds stable semantic hooks. Visual styling stays in tokens/CSS;
+ * interactive state lives in React components and static React Islands.
+ */
+export declare function createMarkdownComponentMap(classNames?: MarkdownClassNames, slots?: MarkdownSlots, components?: MarkdownComponents, urlTransform?: MarkdownUrlTransform): MarkdownComponentMap;
+/** Add trusted MDX component names without letting lowercase tags bypass Markdown semantics. */
+export declare function createMarkdownMdxComponentMap(classNames?: MarkdownClassNames, slots?: MarkdownSlots, components?: MarkdownComponents & Record<string, ElementType>, urlTransform?: MarkdownUrlTransform): MarkdownComponentMap;
+export {};

package/dist/react/semanticOverrideProps.d.ts

@@ -0,0 +1,4 @@
+import { type ReactNode } from 'react';
+import type { MarkdownComponentName, MarkdownElementProps } from './componentMap';
+/** Normalize compiler data attributes into the public props promised to named replacements. */
+export declare function semanticOverrideProps(component: MarkdownComponentName, props: MarkdownElementProps, children: ReactNode): MarkdownElementProps;

package/dist/react/slots.d.ts

@@ -0,0 +1,39 @@
+import { type ComponentType, type ReactNode } from 'react';
+export type MarkdownIconName = 'copy' | 'download' | 'code' | 'maximize' | 'minus' | 'plus' | 'reset' | 'sort' | 'table' | 'folder' | 'file' | 'workflow' | 'link' | 'close' | 'previous' | 'next';
+export interface MarkdownIconSlotProps {
+    name: MarkdownIconName;
+    size?: number;
+    className?: string;
+    'aria-hidden'?: boolean | 'true' | 'false';
+}
+export interface MarkdownCaptionSlotProps {
+    children?: ReactNode;
+    className?: string;
+    'data-df-slot'?: string;
+}
+export interface MarkdownSlots {
+    CopyIcon?: ComponentType<MarkdownIconSlotProps>;
+    DownloadIcon?: ComponentType<MarkdownIconSlotProps>;
+    MaximizeIcon?: ComponentType<MarkdownIconSlotProps>;
+    CodeIcon?: ComponentType<MarkdownIconSlotProps>;
+    MinusIcon?: ComponentType<MarkdownIconSlotProps>;
+    PlusIcon?: ComponentType<MarkdownIconSlotProps>;
+    ResetIcon?: ComponentType<MarkdownIconSlotProps>;
+    SortIcon?: ComponentType<MarkdownIconSlotProps>;
+    TableIcon?: ComponentType<MarkdownIconSlotProps>;
+    FolderIcon?: ComponentType<MarkdownIconSlotProps>;
+    FileIcon?: ComponentType<MarkdownIconSlotProps>;
+    WorkflowIcon?: ComponentType<MarkdownIconSlotProps>;
+    LinkIcon?: ComponentType<MarkdownIconSlotProps>;
+    CloseIcon?: ComponentType<MarkdownIconSlotProps>;
+    PreviousIcon?: ComponentType<MarkdownIconSlotProps>;
+    NextIcon?: ComponentType<MarkdownIconSlotProps>;
+    ImageCaption?: ComponentType<MarkdownCaptionSlotProps>;
+}
+export declare function MarkdownSlotsProvider({ slots, children }: {
+    slots?: MarkdownSlots;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<MarkdownSlots>>;
+export declare function useMarkdownSlots(): MarkdownSlots;
+export declare function getMarkdownIconSlot(slots: MarkdownSlots | undefined, name: MarkdownIconName): ((props: Omit<MarkdownIconSlotProps, "name">) => import("react").ReactElement<MarkdownIconSlotProps, string | import("react").JSXElementConstructor<any>>) | undefined;
+export declare function getMarkdownCaptionSlot(slots: MarkdownSlots | undefined): ComponentType<MarkdownCaptionSlotProps> | undefined;

package/dist/react/urlTransform.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export type MarkdownUrlProperty = 'href' | 'src' | 'poster' | 'srcSet';
+export type MarkdownUrlTransform = (value: string, property: MarkdownUrlProperty) => string;
+/** Keep relative URLs and a small set of non-executable absolute protocols. */
+export declare function sanitizeMarkdownUrl(value: string): string | undefined;
+export declare function MarkdownUrlTransformProvider({ transform, children }: {
+    transform?: MarkdownUrlTransform;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<MarkdownUrlTransform | undefined>>;
+export declare function useMarkdownUrlTransform(): MarkdownUrlTransform | undefined;
+export declare function transformMarkdownSrcSet(value: string, transform?: MarkdownUrlTransform): string;
+export declare function transformMarkdownUrlProps(props: Record<string, unknown>, transform?: MarkdownUrlTransform): Record<string, unknown>;

package/dist/server/analyze.d.ts

@@ -0,0 +1,6 @@
+/** Build-tool analysis entry point, isolated from the SSR renderer graph. */
+export { detectMarkdownAssets } from '../compiler/assets';
+export { analyzeMarkdown } from '../compiler/analyze';
+export { analyzeMdxModuleBoundary } from '../compiler/mdxModules';
+export type { AnalyzeMarkdownOptions, MarkdownAnalysis, MarkdownCodeExample, MarkdownHeading } from '../compiler/analyze';
+export type { MdxImportBinding, MdxImportDeclaration, MdxModuleBoundary } from '../compiler/mdxModules';

package/dist/server/analyze.js

@@ -0,0 +1,132 @@
+import { n as k, c as w } from "../directiveValidation-BdIao7Yn.js";
+import { d as K } from "../directiveValidation-BdIao7Yn.js";
+import x from "github-slugger";
+import { remarkDefinitionList as b } from "remark-definition-list";
+import D from "remark-directive";
+import M from "remark-gfm";
+import S from "remark-parse";
+import { unified as E } from "unified";
+import { visit as y } from "unist-util-visit";
+import { a as I, n as v, m as C } from "../plugins-DQ-VUuCT.js";
+import { createProcessor as A } from "@mdx-js/mdx";
+function L(t) {
+  return "children" in t && Array.isArray(t.children);
+}
+function f(t) {
+  return t.type === "text" || t.type === "inlineCode" ? String(t.value ?? "") : t.type === "image" ? String(t.alt ?? "") : t.type === "code" || t.type === "html" || t.type === "definition" ? "" : L(t) ? t.children.map(f).join(" ") : "";
+}
+function q(t, e = {}) {
+  const s = E().use(S).use(b).use(M).use(D).parse(k(t)), c = new x(), m = [], o = [], r = [], l = [];
+  let g = 0;
+  const u = /* @__PURE__ */ new Map();
+  y(s, "definition", (n) => {
+    n.url && u.set(n.identifier.toLowerCase(), n.url);
+  }), y(s, (n) => {
+    if (n.type === "heading") {
+      const i = n, a = f(i).replace(/\s+/g, " ").trim();
+      m.push({ level: i.depth, text: a, slug: c.slug(a) });
+    }
+    if (n.type === "code") {
+      const i = n;
+      i.lang || (g += 1), o.push({
+        language: i.lang || "text",
+        ...i.meta ? { meta: i.meta } : {},
+        code: i.value
+      });
+    }
+    if (n.type === "link") {
+      const i = n;
+      i.url && r.push(i.url);
+    }
+    if (n.type === "image") {
+      const i = n;
+      i.url && l.push(i.url);
+    }
+    if (n.type === "linkReference") {
+      const i = n, a = u.get(i.identifier.toLowerCase());
+      a && r.push(a);
+    }
+    if (n.type === "imageReference") {
+      const i = n, a = u.get(i.identifier.toLowerCase());
+      a && l.push(a);
+    }
+  });
+  const h = I(v(e.plugins), {
+    source: t,
+    mode: "markdown"
+  });
+  return {
+    text: f(s).replace(/\s+/g, " ").trim(),
+    headings: m,
+    codeExamples: o,
+    links: r,
+    images: l,
+    missingCodeBlockLanguages: g,
+    directiveIssues: w(s, C(h)).map(
+      ({ message: n, line: i, column: a }) => ({
+        message: n,
+        line: i,
+        column: a
+      })
+    )
+  };
+}
+function P(t) {
+  return t.specifiers.map((e) => e.type === "ImportDefaultSpecifier" ? { imported: "default", local: e.local.name } : e.type === "ImportNamespaceSpecifier" ? { imported: "*", local: e.local.name, namespace: !0 } : {
+    imported: e.type === "ImportSpecifier" ? "name" in e.imported ? e.imported.name : String(e.imported.value ?? "") : "",
+    local: e.local.name
+  });
+}
+function j(t) {
+  return !!(t && typeof t == "object" && typeof t.type == "string");
+}
+function R(t) {
+  const e = t;
+  return typeof e.start == "number" && typeof e.end == "number";
+}
+function d(t, e) {
+  if (!t || typeof t != "object") return;
+  if (Array.isArray(t)) {
+    for (const s of t) d(s, e);
+    return;
+  }
+  const p = t;
+  j(t) && e(t);
+  for (const [s, c] of Object.entries(p))
+    s === "loc" || s === "position" || d(c, e);
+}
+function F(t) {
+  const e = A().parse(t), p = [], s = [], c = [];
+  d(e, (o) => {
+    if (o.type === "ImportExpression") {
+      const r = o.source.type === "Literal" && typeof o.source.value == "string" ? o.source.value : void 0;
+      s.push({
+        kind: "dynamic-import",
+        specifier: r
+      });
+    }
+  });
+  for (const o of e.children ?? [])
+    if (o.type === "mdxjsEsm")
+      for (const r of o.data?.estree?.body ?? [])
+        if (r.type === "ImportDeclaration") {
+          if (p.push({
+            specifier: String(r.source.value),
+            bindings: P(r)
+          }), !R(r))
+            throw new Error("Unable to locate an MDX import declaration in the source document");
+          c.push({ start: r.start, end: r.end });
+        } else (r.type === "ExportNamedDeclaration" || r.type === "ExportAllDeclaration") && r.source && s.push({
+          kind: "export-from",
+          specifier: String(r.source.value)
+        });
+  const m = [
+    ...new Map(c.map((o) => [`${o.start}:${o.end}`, o])).values()
+  ].sort((o, r) => r.start - o.start).reduce((o, r) => `${o.slice(0, r.start)}${o.slice(r.end)}`, t).replace(/^\s*\n/, "");
+  return { imports: p, sourceWithoutImports: m, unsupportedReferences: s };
+}
+export {
+  q as analyzeMarkdown,
+  F as analyzeMdxModuleBoundary,
+  K as detectMarkdownAssets
+};

package/dist/server/cache.d.ts

@@ -0,0 +1,16 @@
+import type { PreparedMarkdown, RenderMarkdownOptions } from '../compiler/types';
+export interface MarkdownServerContextOptions {
+    /** Maximum number of prepared entries retained by this context. */
+    maxEntries?: number;
+}
+interface MarkdownServerContext {
+    prepare(source: string, options?: RenderMarkdownOptions): Promise<PreparedMarkdown>;
+    clear(): void;
+}
+/**
+ * Renderer-scoped Markdown cache. It deduplicates concurrent preparation and
+ * stays bounded; hosts clear it when a full build invalidates the content
+ * graph, while safe single-page dev rebuilds can retain hot entries.
+ */
+export declare function createMarkdownServerContext({ maxEntries, warningState }?: MarkdownServerContextOptions): MarkdownServerContext;
+export {};

package/dist/server/createMarkdownRenderer.d.ts

@@ -0,0 +1,39 @@
+import { type ElementType, type ReactNode } from 'react';
+import { type MarkdownClassNames, type MarkdownComponents } from '../react/componentMap';
+import type { MarkdownAssets } from '../compiler/assets';
+import { type MarkdownServerContextOptions } from './cache';
+import type { RenderMarkdownOptions } from '../compiler/types';
+import { type MarkdownSlots } from '../react/slots';
+import type { MarkdownUrlTransform } from '../react/urlTransform';
+export interface MarkdownRenderOptions {
+    markdown?: RenderMarkdownOptions;
+    classNames?: MarkdownClassNames;
+    components?: MarkdownComponents;
+    slots?: MarkdownSlots;
+    className?: string;
+    as?: ElementType;
+    urlTransform?: MarkdownUrlTransform;
+}
+export interface MdxRenderOptions extends Omit<MarkdownRenderOptions, 'components'> {
+    /** Host and author components made available to trusted MDX. */
+    components?: MarkdownComponents & Record<string, ElementType>;
+    /** Base URL used by the MDX runtime for generated module metadata. */
+    baseUrl?: URL;
+}
+export interface RenderedMarkdown {
+    content: ReactNode;
+    assets: MarkdownAssets;
+}
+export interface MarkdownRenderer {
+    render(source: string, options?: MarkdownRenderOptions): Promise<RenderedMarkdown>;
+    renderMdx(source: string, options?: MdxRenderOptions): Promise<RenderedMarkdown>;
+    clear(): void;
+}
+/**
+ * Build/SSR renderer for Markdown and trusted MDX.
+ *
+ * The interface returns React content plus resource facts. HAST, Unified
+ * processors, plugin ordering and compiler caches remain private so hosts do
+ * not have to assemble the rendering pipeline themselves.
+ */
+export declare function createMarkdownRenderer(contextOptions?: MarkdownServerContextOptions): MarkdownRenderer;

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+/** Build/SSR-only entry point with compiler details hidden behind renderers. */
+export { createMarkdownRenderer } from './server/createMarkdownRenderer';
+export { defineMarkdownPlugin } from './compiler/plugins';
+export type { MarkdownAssets, MarkdownLabels, MarkdownPlugin, MarkdownPluginBrowserCompiler, MarkdownPluginCacheValue, MarkdownPluginClientAsset, MarkdownPluginClientResource, MarkdownPluginClientResourceDirectory, MarkdownPluginStyleAsset, MarkdownUnknownLanguagePolicy, RenderMarkdownOptions } from './compiler/prepareMarkdown';
+export type { MarkdownRenderer, MarkdownRenderOptions, MdxRenderOptions, RenderedMarkdown } from './server/createMarkdownRenderer';

package/dist/server.js

@@ -0,0 +1,137 @@
+import * as p from "react/jsx-runtime";
+import { jsx as c } from "react/jsx-runtime";
+import { evaluate as w } from "@mdx-js/mdx";
+import { c as f, a as h, b as k } from "./Markdown-D33gcJbF.js";
+import { a as M, n as P } from "./directiveValidation-BdIao7Yn.js";
+import { n as x, d as v, c as y, a as N, p as L } from "./prepareMarkdown-CHqN2JF5.js";
+import { a as b, b as S, s as C, c as T } from "./plugins-DQ-VUuCT.js";
+import { d as G } from "./plugins-DQ-VUuCT.js";
+import { createHash as z } from "node:crypto";
+async function O(a = {}, r, t = { warnedLanguages: /* @__PURE__ */ new Set() }) {
+  const s = x(a), e = M(), n = r ?? "", o = b(s.plugins, { source: n, mode: "mdx" }), l = S(o), d = { ...s, plugins: o }, u = v(n, l);
+  o.forEach((g) => e.markPluginAssets(g));
+  const m = u.highlightedCode ? await y(
+    u.codeLanguages,
+    d,
+    t.warnedLanguages,
+    l
+  ) : void 0, i = N("mdx", e, d, u, m);
+  return {
+    remarkPlugins: i.remarkPlugins,
+    rehypePlugins: i.rehypePlugins,
+    remarkRehypeOptions: { handlers: i.handlers },
+    getAssets: () => e.snapshot()
+  };
+}
+function R(a, r) {
+  const { plugins: t, ...s } = r ?? {}, e = C({ ...s, plugins: T(t) });
+  if (e !== void 0)
+    return z("sha256").update(a).update("\0").update(e).digest("hex");
+}
+function A(a, r, t, s) {
+  for (a.delete(r), a.set(r, t); a.size > s; ) {
+    const e = a.keys().next().value;
+    if (e === void 0) break;
+    a.delete(e);
+  }
+  return t;
+}
+function H(a, r, t, s) {
+  if (!r) return t();
+  const e = a.get(r);
+  if (e)
+    return a.delete(r), a.set(r, e), e;
+  const n = t().catch((o) => {
+    throw a.get(r) === n && a.delete(r), o;
+  });
+  return A(a, r, n, s);
+}
+function F({
+  maxEntries: a = 64,
+  warningState: r = /* @__PURE__ */ new Set()
+} = {}) {
+  const t = Number.isFinite(a) && a > 0 ? Math.floor(a) : 64, s = /* @__PURE__ */ new Map();
+  return {
+    prepare(e, n) {
+      return H(
+        s,
+        R(e, n),
+        () => L(e, n, { warnedLanguages: r }),
+        t
+      );
+    },
+    clear() {
+      s.clear(), r.clear();
+    }
+  };
+}
+function q(a = {}) {
+  const r = /* @__PURE__ */ new Set(), t = F({ ...a, warningState: r });
+  return {
+    async render(s, e = {}) {
+      const n = await t.prepare(s, e.markdown);
+      return {
+        content: /* @__PURE__ */ c(
+          k,
+          {
+            document: n.document,
+            classNames: e.classNames,
+            components: e.components,
+            slots: e.slots,
+            className: e.className,
+            as: e.as,
+            "data-df-runtime": "static",
+            urlTransform: e.urlTransform
+          }
+        ),
+        assets: n.assets
+      };
+    },
+    async renderMdx(s, e = {}) {
+      if (e.markdown?.html && e.markdown.html !== "trusted")
+        throw new Error("MDX executes trusted JSX and does not support sanitize or strip HTML policies");
+      const n = await O(e.markdown, s, {
+        warnedLanguages: r
+      }), l = (await w(
+        {
+          value: P(s),
+          data: { docfuseLocale: e.markdown?.locale?.trim() || void 0 }
+        },
+        {
+          ...p,
+          remarkPlugins: n.remarkPlugins,
+          rehypePlugins: n.rehypePlugins,
+          remarkRehypeOptions: n.remarkRehypeOptions,
+          baseUrl: e.baseUrl ?? import.meta.url
+        }
+      )).default, d = f(
+        e.classNames,
+        e.slots,
+        e.components,
+        e.urlTransform
+      );
+      return {
+        content: /* @__PURE__ */ c(
+          h,
+          {
+            "data-df-runtime": "static",
+            as: e.as,
+            className: e.className,
+            classNames: e.classNames,
+            slots: e.slots,
+            urlTransform: e.urlTransform,
+            children: /* @__PURE__ */ c(l, { components: d })
+          }
+        ),
+        assets: n.getAssets()
+      };
+    },
+    clear() {
+      t.clear();
+    }
+  };
+}
+export {
+  q as createMarkdownRenderer,
+  G as defineMarkdownPlugin
+};

package/dist/shared/copyText.d.ts

@@ -0,0 +1,2 @@
+/** Copy text in both secure and legacy browser contexts. */
+export declare function copyMarkdownText(value: string): Promise<boolean>;

package/dist/shared/fileKinds.d.ts

@@ -0,0 +1,6 @@
+export type MarkdownFileKind = 'package' | 'config' | 'typescript' | 'javascript' | 'markdown' | 'style' | 'data' | 'database' | 'shell' | 'container' | 'diff' | 'component' | 'source' | 'environment' | 'file';
+export type MarkdownFileIconName = 'astro' | 'bun' | 'console' | 'css' | 'database' | 'deno' | 'diff' | 'docker' | 'docfuse' | 'document' | 'environment' | 'git' | 'github-actions' | 'go' | 'javascript' | 'json' | 'markdown' | 'nodejs' | 'npm' | 'pnpm' | 'python' | 'react' | 'rust' | 'sass' | 'config' | 'settings' | 'svelte' | 'typescript' | 'vue' | 'yaml' | 'yarn';
+/** Filename associations take precedence over extension and language fallbacks. */
+export declare function markdownFileKind(filename: string, language?: string): MarkdownFileKind;
+/** Material Icon Theme-style filename associations, with filenames taking priority. */
+export declare function markdownFileIconName(filename: string, language?: string): MarkdownFileIconName;