@coderminer/vue-markdown 0.0.0-stage → 1.0.0

package/dist/components/context.d.ts

@@ -0,0 +1,45 @@
+import { InjectionKey, Slot, VNodeChild } from 'vue';
+import { DiagnosticFormatter, MarkdownComponentValue, MarkdownDocument, MarkdownHighlighter, MarkdownLabels, MarkdownNode, MarkdownRegionComponents, MarkdownTheme, MathEngine, MermaidRenderer } from '../core/types';
+export interface LinkClickPayload {
+    url: string;
+    target: string;
+    node: MarkdownNode;
+    event: MouseEvent;
+}
+export interface CustomTagClickPayload {
+    tag: string;
+    props: Record<string, unknown>;
+    node: MarkdownNode;
+    event: MouseEvent;
+}
+export interface TaskChangePayload {
+    checked: boolean;
+    node: MarkdownNode;
+}
+export interface RenderContext {
+    components: Record<string, MarkdownComponentValue>;
+    nodeComponents?: Record<string, MarkdownComponentValue>;
+    regions?: MarkdownRegionComponents;
+    document?: MarkdownDocument;
+    theme?: MarkdownTheme;
+    labels: MarkdownLabels;
+    linkTarget: string;
+    externalLinkTarget: string;
+    highlighter?: MarkdownHighlighter;
+    mathEngine?: MathEngine;
+    mermaidRenderer?: MermaidRenderer;
+    diagnosticsFormatter?: DiagnosticFormatter;
+    /** Host-authored region slots keyed by documented slot name. */
+    slots?: Readonly<Record<string, Slot | undefined>>;
+    /** Render a host slot, falling back to the default region when empty. */
+    renderHostSlot(name: string, props: Record<string, unknown>, fallback: () => VNodeChild): VNodeChild;
+    onLinkClick(payload: LinkClickPayload): void;
+    onCustomTagClick(payload: CustomTagClickPayload): void;
+    onTaskChange(payload: TaskChangePayload): void;
+    onRenderError?(diagnostic: import('../core/types').MarkdownDiagnostic): void;
+    onMathError?(diagnostic: import('../core/types').MarkdownDiagnostic): void;
+}
+export declare const RENDER_CONTEXT: InjectionKey<RenderContext>;
+export declare function useRenderContext(): RenderContext;
+/** True when a slot produced no meaningful output and the default should win. */
+export declare function isEmptySlotContent(value: VNodeChild): boolean;

package/dist/components/index.d.ts

@@ -0,0 +1,42 @@
+export { default as MarkdownRenderer } from './MarkdownRenderer';
+export { default as MarkdownConfigProvider } from './MarkdownConfigProvider';
+export { default as MarkdownRoot } from './MarkdownRoot';
+export { default as MarkdownContent } from './MarkdownContent';
+export { default as MarkdownToc } from './MarkdownToc';
+export { default as MarkdownTocItem } from './MarkdownTocItem';
+export { default as MarkdownError } from './MarkdownError';
+export { default as MarkdownEmpty } from './MarkdownEmpty';
+export { default as MarkdownLoading } from './MarkdownLoading';
+export { default as MarkdownParagraph } from './MarkdownParagraph';
+export { default as MarkdownHeading } from './MarkdownHeading';
+export { default as MarkdownEmphasis } from './MarkdownEmphasis';
+export { default as MarkdownStrong } from './MarkdownStrong';
+export { default as MarkdownStrikethrough } from './MarkdownStrikethrough';
+export { default as MarkdownLink } from './MarkdownLink';
+export { default as MarkdownImage } from './MarkdownImage';
+export { default as MarkdownList } from './MarkdownList';
+export { default as MarkdownListItem } from './MarkdownListItem';
+export { default as MarkdownBlockquote } from './MarkdownBlockquote';
+export { default as MarkdownHorizontalRule } from './MarkdownHorizontalRule';
+export { default as MarkdownTable } from './MarkdownTable';
+export { default as MarkdownTableSection } from './MarkdownTableSection';
+export { default as MarkdownTableRow } from './MarkdownTableRow';
+export { default as MarkdownTableCell } from './MarkdownTableCell';
+export { default as MarkdownInlineCode } from './MarkdownInlineCode';
+export { default as MarkdownCode } from './MarkdownCode';
+export { default as CodeBlock } from './CodeBlock';
+export { default as VueSyntaxHighlighter } from './VueSyntaxHighlighter';
+export { default as MermaidBlock } from './MermaidBlock';
+export { default as MermaidLiveEditor } from './MermaidLiveEditor';
+export { default as MarkdownTaskItem } from './MarkdownTaskItem';
+export { default as MarkdownFootnoteReference } from './MarkdownFootnoteReference';
+export { default as MarkdownFootnotes } from './MarkdownFootnotes';
+export { default as MarkdownMath } from './MarkdownMath';
+export { default as MarkdownMermaid } from './MarkdownMermaid';
+export { default as MarkdownBreak } from './MarkdownBreak';
+export { default as MarkdownHtml } from './MarkdownHtml';
+export { default as MarkdownCustomTag } from './MarkdownCustomTag';
+export { default as MarkdownChildren } from './MarkdownChildren';
+export * from './context';
+export * from './config';
+export * from './types';

package/dist/components/index.js

@@ -0,0 +1,38 @@
+import { n as e, r as t, t as n } from "../chunks/config-aRYo2R8_.js";
+import { n as r, r as i, t as a } from "../chunks/context-8NfW6fxI.js";
+import { a as o, i as s, n as c, r as l } from "../chunks/render-Cs8iKrgz.js";
+import { t as u } from "../chunks/MarkdownCode-B1k9tmW5.js";
+import { t as d } from "../chunks/MarkdownBlockquote-DVXziX2t.js";
+import { t as f } from "../chunks/MarkdownBreak-BwCi2Itt.js";
+import { t as p } from "../chunks/MarkdownCustomTag-BBdn3-WO.js";
+import { t as m } from "../chunks/MarkdownEmphasis-CppivOEu.js";
+import { t as h } from "../chunks/MarkdownHeading-DaNcP0_6.js";
+import { t as g } from "../chunks/MarkdownHorizontalRule-QNe_cuUI.js";
+import { t as _ } from "../chunks/MarkdownImage-BRy76svs.js";
+import { t as v } from "../chunks/MarkdownInlineCode-MXZYFwex.js";
+import { t as y } from "../chunks/MarkdownLink-Dbx3NwgV.js";
+import { t as b } from "../chunks/MarkdownList-BJ-_C71k.js";
+import { t as x } from "../chunks/MarkdownListItem-Z1EHIY26.js";
+import { t as S } from "../chunks/MarkdownFootnoteReference-Dy3Khwyj.js";
+import { t as C } from "../chunks/MarkdownFootnotes-BRPzkbXv.js";
+import { t as w } from "../chunks/MarkdownParagraph-BxLSmSaG.js";
+import { t as T } from "../chunks/MarkdownStrikethrough-CblvbqDk.js";
+import { t as E } from "../chunks/MarkdownTaskItem-BcmKo1lk.js";
+import { t as D } from "../chunks/MarkdownStrong-uU5MzAoJ.js";
+import { t as O } from "../chunks/MarkdownTable-DmBTg_CR.js";
+import { t as k } from "../chunks/MarkdownTableCell-eiCJe847.js";
+import { t as A } from "../chunks/MarkdownTableRow-DuJaPntg.js";
+import { t as j } from "../chunks/MarkdownTableSection-PFHz-R33.js";
+import { n as M, t as N } from "../chunks/MarkdownRenderer-DLRRfsdI.js";
+import { t as P } from "../chunks/MarkdownContent-BAK6dqo7.js";
+import { t as F } from "../chunks/MarkdownEmpty-Av5k6bqa.js";
+import { t as I } from "../chunks/MarkdownError-C0sPs5W0.js";
+import { t as L } from "../chunks/MarkdownLoading-D-RYtXxf.js";
+import { t as R } from "../chunks/MarkdownRoot-DEE6iVfh.js";
+import { t as z } from "../chunks/MarkdownTocItem-DT9mR3vL.js";
+import { t as B } from "../chunks/MarkdownToc-BdOHF-Yo.js";
+import { t as V } from "../chunks/MarkdownConfigProvider-5N3ylrIu.js";
+import { t as H } from "../chunks/VueSyntaxHighlighter-DyLsYMwy.js";
+import { t as U } from "../chunks/MermaidLiveEditor-W-qf3G-5.js";
+import { t as W } from "../chunks/MarkdownHtml-66lYkvwM.js";
+export { o as CodeBlock, n as MARKDOWN_CONFIG, d as MarkdownBlockquote, f as MarkdownBreak, M as MarkdownChildren, u as MarkdownCode, V as MarkdownConfigProvider, P as MarkdownContent, p as MarkdownCustomTag, m as MarkdownEmphasis, F as MarkdownEmpty, I as MarkdownError, S as MarkdownFootnoteReference, C as MarkdownFootnotes, h as MarkdownHeading, g as MarkdownHorizontalRule, W as MarkdownHtml, _ as MarkdownImage, v as MarkdownInlineCode, y as MarkdownLink, b as MarkdownList, x as MarkdownListItem, L as MarkdownLoading, s as MarkdownMath, c as MarkdownMermaid, w as MarkdownParagraph, N as MarkdownRenderer, R as MarkdownRoot, T as MarkdownStrikethrough, D as MarkdownStrong, O as MarkdownTable, k as MarkdownTableCell, A as MarkdownTableRow, j as MarkdownTableSection, E as MarkdownTaskItem, B as MarkdownToc, z as MarkdownTocItem, l as MermaidBlock, U as MermaidLiveEditor, a as RENDER_CONTEXT, H as VueSyntaxHighlighter, r as isEmptySlotContent, e as provideMarkdownConfig, t as useMarkdownConfig, i as useRenderContext };

package/dist/components/render.d.ts

@@ -0,0 +1,9 @@
+import { Component, VNodeChild } from 'vue';
+import { MarkdownNode } from '../core/types';
+import { RenderContext } from './context';
+/** Element tags that map to a semantic node kind. */
+export declare const TAG_TO_KIND: Record<string, string>;
+export declare function resolveTagComponent(tag: string, ctx: RenderContext): Component | string | undefined;
+export declare function resolveKindComponent(kind: string, ctx: RenderContext): Component | string | undefined;
+export declare function renderNode(node: MarkdownNode, ctx: RenderContext): VNodeChild;
+export declare function renderNodes(nodes: readonly MarkdownNode[], ctx: RenderContext): VNodeChild[];

package/dist/components/scroll-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Lock page scrolling for every fullscreen surface on the page. The original
+ * overflow is restored only when the last surface releases the lock.
+ */
+export declare function lockPageScroll(): void;
+/** Release one page-scroll lock. Safe to call when the caller owns no lock. */
+export declare function unlockPageScroll(): void;

package/dist/components/types.d.ts

@@ -0,0 +1,29 @@
+import { Component, VNodeChild } from 'vue';
+import { MarkdownDocument, MarkdownNode, MarkdownRegionComponents, TocItem } from '../core/types';
+import { RenderContext } from './context';
+export type VueMarkdownTagComponents = Record<string, Component | string | undefined>;
+export interface MarkdownNodeRenderContext {
+    node: MarkdownNode;
+    kind: MarkdownNode['kind'];
+    /** The element/custom tag, or `undefined` for semantic nodes. */
+    tag?: string;
+    /** A safe, always-present attribute map for element/custom nodes. */
+    attrs: Record<string, string>;
+    key: string;
+    children: () => VNodeChild;
+    defaultRender: () => VNodeChild;
+    context: RenderContext;
+}
+export type MarkdownNodeRenderer = (context: MarkdownNodeRenderContext) => VNodeChild;
+export type VueMarkdownNodeComponents = Record<string, Component | string | MarkdownNodeRenderer | undefined>;
+export type VueMarkdownRegionComponents = {
+    [K in keyof MarkdownRegionComponents]?: Component | string | undefined;
+};
+/** Exposed instance API of `MarkdownRenderer`. */
+export interface MarkdownRendererInstance {
+    scrollToHeading(id: string, options?: ScrollIntoViewOptions): void;
+    getDocument(): MarkdownDocument | undefined;
+    getToc(): TocItem[];
+    refresh(): Promise<void>;
+    updateSource(source: string): void;
+}

package/dist/composables/useActiveHeading.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRefOrGetter } from 'vue';
+export interface UseActiveHeadingOptions {
+    /**
+     * Scope heading lookups to one rendered document root. Pass this when a
+     * page contains multiple renderers that may generate the same heading IDs.
+     */
+    root?: MaybeRefOrGetter<Element | Document | null | undefined>;
+}
+/** Find an element by id inside a document or a scoped root element. */
+export declare function findElementById(scope: Element | Document, id: string): HTMLElement | null;
+/** Tracks the heading currently in view without touching the DOM before mount. */
+export declare function useActiveHeading(ids: MaybeRefOrGetter<string[]>, enabled?: MaybeRefOrGetter<boolean>, options?: UseActiveHeadingOptions): import('vue').Ref<string | undefined, string | undefined>;

package/dist/composables/useCodeHighlighter.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+import { HighlightResult, MarkdownDiagnostic, MarkdownHighlighter, MarkdownTheme } from '../core/types';
+export interface UseCodeHighlighterOptions {
+    source: MaybeRefOrGetter<string>;
+    language: MaybeRefOrGetter<string>;
+    highlighter?: MaybeRefOrGetter<MarkdownHighlighter | undefined>;
+    theme?: MaybeRefOrGetter<MarkdownTheme | undefined>;
+    /** Nearest provider or render-context theme, below the local `theme` prop. */
+    contextTheme?: MaybeRefOrGetter<MarkdownTheme | undefined>;
+    /** When false the highlighter is neither loaded nor run (for example, a region replacement). */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Optional debounce in milliseconds. */
+    delay?: MaybeRefOrGetter<number>;
+    onDiagnostic?: (diagnostic: MarkdownDiagnostic) => void;
+}
+export interface UseCodeHighlighterReturn {
+    result: ShallowRef<HighlightResult>;
+    active: ShallowRef<MarkdownHighlighter | undefined>;
+    resolvedTheme: ComputedRef<MarkdownTheme>;
+    refresh: () => Promise<void>;
+    getHighlighted: () => HighlightResult;
+}
+/**
+ * Shared highlighter state for `CodeBlock` and `VueSyntaxHighlighter`.
+ *
+ * Keeping the lazy default adapter, theme mapping, readiness loading, and
+ * diagnostics in one place prevents the two public components from drifting
+ * apart as adapters are added.
+ */
+export declare function useCodeHighlighter(options: UseCodeHighlighterOptions): UseCodeHighlighterReturn;

package/dist/composables/useLineWindow.d.ts

@@ -0,0 +1,38 @@
+import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+import { HighlightLine, MarkdownNode } from '../core/types';
+export interface VisibleLine {
+    index: number;
+    nodes: MarkdownNode[];
+}
+export interface UseLineWindowOptions {
+    nodes: MaybeRefOrGetter<readonly MarkdownNode[]>;
+    source: MaybeRefOrGetter<string>;
+    maxLines?: MaybeRefOrGetter<number>;
+    virtual?: MaybeRefOrGetter<boolean>;
+    virtualThreshold?: MaybeRefOrGetter<number>;
+    lineHeight?: MaybeRefOrGetter<number>;
+    highlightLines?: MaybeRefOrGetter<readonly HighlightLine[] | undefined>;
+}
+export interface UseLineWindowReturn {
+    highlightedLines: ComputedRef<MarkdownNode[][]>;
+    expanded: Ref<boolean>;
+    truncatable: ComputedRef<boolean>;
+    totalLines: ComputedRef<number>;
+    virtualActive: ComputedRef<boolean>;
+    startLine: ComputedRef<number>;
+    endLine: ComputedRef<number>;
+    visibleLines: ComputedRef<VisibleLine[]>;
+    lineHeight: ComputedRef<number>;
+    scrollRef: Ref<HTMLElement | undefined>;
+    onScroll: (event: Event) => void;
+    measure: () => void;
+    toggle: () => void;
+    isHighlightedLine: (index: number) => boolean;
+}
+/**
+ * Shared line windowing used by `CodeBlock` and `VueSyntaxHighlighter`.
+ *
+ * The composable owns only presentation state: split lines, truncation, and
+ * the visible window. Highlighting itself stays in `useCodeHighlighter`.
+ */
+export declare function useLineWindow(options: UseLineWindowOptions): UseLineWindowReturn;

package/dist/composables/useMarkdownDocument.d.ts

@@ -0,0 +1,23 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+import { MarkdownDiagnostic, MarkdownDocument, MarkdownDocumentOptions, MarkdownLabels, MarkdownNodeComponents, MarkdownRegionComponents, MarkdownTagComponents, TocItem } from '../core/types';
+export type MarkdownStatus = 'idle' | 'pending' | 'ready' | 'error';
+export interface UseMarkdownDocumentReturn {
+    document: ShallowRef<MarkdownDocument | undefined>;
+    toc: ComputedRef<TocItem[]>;
+    status: ShallowRef<MarkdownStatus>;
+    diagnostics: ShallowRef<MarkdownDiagnostic[]>;
+    pipeline: ComputedRef<string>;
+    plugins: ComputedRef<string[]>;
+    /** Tag components contributed by plugins; local props are merged by the host. */
+    resolvedComponents: ComputedRef<MarkdownTagComponents>;
+    /** Semantic node components contributed by plugins. */
+    resolvedNodeComponents: ComputedRef<MarkdownNodeComponents>;
+    /** Structural regions contributed by plugins. */
+    resolvedRegions: ComputedRef<MarkdownRegionComponents>;
+    /** Labels contributed by plugins. */
+    resolvedLabels: ComputedRef<Partial<MarkdownLabels>>;
+    /** Design tokens contributed by plugins. */
+    resolvedTokens: ComputedRef<Record<string, string>>;
+    refresh: () => Promise<void>;
+}
+export declare function useMarkdownDocument(source: MaybeRefOrGetter<string>, options?: MaybeRefOrGetter<MarkdownDocumentOptions>): UseMarkdownDocumentReturn;

package/dist/core/adapters.d.ts

@@ -0,0 +1,7 @@
+import { DiagnosticFormatter, MarkdownHighlighter, MarkdownSlugger, MarkdownUrlTransform, MathEngine, MermaidRenderer } from './types';
+export declare function isValidHighlighter(value: unknown): value is MarkdownHighlighter;
+export declare function isValidMathEngine(value: unknown): value is MathEngine;
+export declare function isValidMermaidRenderer(value: unknown): value is MermaidRenderer;
+export declare function isValidDiagnosticFormatter(value: unknown): value is DiagnosticFormatter;
+export declare function isValidSlugger(value: unknown): value is MarkdownSlugger;
+export declare function isValidUrlTransform(value: unknown): value is MarkdownUrlTransform;

package/dist/core/config.d.ts

@@ -0,0 +1,5 @@
+import { MarkdownConfig, MarkdownPreset } from './types';
+/** Merge configuration maps with `next` taking precedence. */
+export declare function mergeMarkdownConfig(base: MarkdownConfig | undefined, next: MarkdownConfig | undefined): MarkdownConfig;
+/** Merge presets; later presets win and plugins are appended in order. */
+export declare function mergeMarkdownPreset(base: MarkdownPreset | undefined, next: MarkdownPreset): MarkdownPreset;

package/dist/core/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import { MarkdownDiagnostic, DiagnosticPhase, SourceRange } from './types';
+export declare function createDiagnostic(code: string, message: string, options?: {
+    severity?: MarkdownDiagnostic['severity'];
+    phase?: DiagnosticPhase;
+    plugin?: string;
+    source?: SourceRange;
+    details?: string;
+}): MarkdownDiagnostic;
+export declare function errorMessage(error: unknown): string;

package/dist/core/finalize.d.ts

@@ -0,0 +1,18 @@
+import { MarkdownDiagnostic, MarkdownDocument, MarkdownDocumentOptions, MarkdownSlugger, PipelineResult } from './types';
+import { ResolvedPlugins } from '../plugins/registry';
+export interface FinalizeDocumentOptions {
+    source: string;
+    result: PipelineResult;
+    options: MarkdownDocumentOptions;
+    plugins: ResolvedPlugins;
+    pipelineName: string;
+    slugger: MarkdownSlugger;
+    idPrefix: string;
+    diagnostics: MarkdownDiagnostic[];
+}
+/**
+ * Turn a pipeline result into the public document model. Both the reactive
+ * composable and static export use this path so filtering, URL policy, heading
+ * IDs, and plugin document transforms cannot diverge.
+ */
+export declare function finalizeMarkdownDocument(input: FinalizeDocumentOptions): MarkdownDocument;

package/dist/core/hast-nodes.d.ts

@@ -0,0 +1,6 @@
+import { RootContent } from 'hast';
+import { MarkdownNode } from './types';
+/** Convert an already-parsed trusted hast subtree into normalized nodes. */
+export declare function hastToMarkdownNodes(nodes: readonly RootContent[]): MarkdownNode[];
+/** Convert trusted engine HTML into normalized nodes. */
+export declare function htmlToMarkdownNodes(html: string): MarkdownNode[];

package/dist/core/highlight-lines.d.ts

@@ -0,0 +1,8 @@
+import { HighlightLine } from './types';
+/**
+ * Expand numeric lines and `start-end` ranges into a lookup set.
+ *
+ * Invalid, zero, negative, and reversed entries are ignored. Plain numeric
+ * strings are treated as a single line.
+ */
+export declare function resolveHighlightedLines(values: readonly HighlightLine[] | undefined): Set<number>;

package/dist/core/identity.d.ts

@@ -0,0 +1,4 @@
+/** Stable process-local identity for objects and functions. */
+export declare function identityOf(value: unknown): string;
+export declare function listIdentity(list: readonly unknown[] | undefined): string;
+export declare function stringListIdentity(list: readonly string[] | undefined): string;

package/dist/core/labels.d.ts

@@ -0,0 +1,4 @@
+import { MarkdownLabelContext, MarkdownLabelValue, MarkdownLabels } from '../core/types';
+/** Resolve a static or context-aware label value. */
+export declare function resolveLabel(value: MarkdownLabelValue, context?: MarkdownLabelContext): string;
+export declare const DEFAULT_LABELS: MarkdownLabels;

package/dist/core/manifest.d.ts

@@ -0,0 +1,38 @@
+import { MarkdownPart } from './parts';
+/**
+ * Machine-readable customization manifest for one public component.
+ *
+ * Manifests are Vue-free so documentation, the demo inspector, and validation
+ * tests can consume them without importing component code.
+ */
+export interface MarkdownComponentManifest {
+    name: string;
+    parts: readonly MarkdownPart[];
+    tokens: readonly string[];
+    slots: readonly string[];
+    labels: readonly string[];
+    overrideKeys: readonly string[];
+    tags?: readonly string[];
+    behaviors?: readonly string[];
+}
+export type ManifestIssueCode = 'duplicate-manifest' | 'undeclared-part' | 'missing-part' | 'undeclared-label' | 'missing-slot';
+export interface ManifestValidationIssue {
+    code: ManifestIssueCode;
+    component: string;
+    message: string;
+}
+export interface ManifestRenderSnapshot {
+    parts?: readonly string[];
+    labels?: readonly string[];
+    slots?: readonly string[];
+    /** `strict` also requires every declared part to be rendered. */
+    mode?: 'strict' | 'observed';
+}
+export declare const COMPONENT_MANIFESTS: Record<string, MarkdownComponentManifest>;
+export declare function getComponentManifest(name: string): MarkdownComponentManifest | undefined;
+/**
+ * Compare a manifest with rendered output. Missing snapshot fields are skipped
+ * so a test can validate only the parts, labels, or slots it can observe.
+ */
+export declare function validateManifest(entry: MarkdownComponentManifest, snapshot: ManifestRenderSnapshot): ManifestValidationIssue[];
+export declare function validateManifestRegistry(manifests?: Record<string, MarkdownComponentManifest>): ManifestValidationIssue[];

package/dist/core/memo.d.ts

@@ -0,0 +1,5 @@
+import { MarkdownDocument } from './types';
+export declare function memoGet(key: string): MarkdownDocument | undefined;
+export declare function memoSet(key: string, document: MarkdownDocument): void;
+export declare function memoClear(): void;
+export declare function memoSize(): number;

package/dist/core/model-hast.d.ts

@@ -0,0 +1,8 @@
+import { Root } from 'hast';
+import { MarkdownDocument } from './types';
+/**
+ * Serialize the normalized document model back to hast for static export.
+ * The model has already passed sanitization, filtering, URL policy, and plugin
+ * document transforms, so this function performs no new trust decisions.
+ */
+export declare function modelToHast(document: MarkdownDocument): Root;

package/dist/core/model.d.ts

@@ -0,0 +1,10 @@
+import { MarkdownDocument, MarkdownNode } from './types';
+export interface BuildDocumentOptions {
+    nodes: MarkdownNode[];
+    plugins: string[];
+    pipeline: string;
+    frontmatter?: Record<string, unknown>;
+}
+export declare function buildDocument(options: BuildDocumentOptions): MarkdownDocument;
+/** Recompute derived collections after a document transform. */
+export declare function withDerivedDocument(document: MarkdownDocument): MarkdownDocument;

package/dist/core/normalize.d.ts

@@ -0,0 +1,27 @@
+import { Root } from 'hast';
+import { AllowElement, MarkdownDiagnostic, MarkdownDocument, MarkdownNode, MarkdownSlugger, MarkdownUrlTransform, TocItem } from './types';
+export interface NormalizeOptions {
+    slugger: MarkdownSlugger;
+    idPrefix?: string;
+    urlTransform?: MarkdownUrlTransform;
+    baseUrl?: string;
+    allowedElements?: string[];
+    disallowedElements?: string[];
+    unwrapDisallowed?: boolean;
+    allowElement?: AllowElement;
+    diagnostics?: MarkdownDiagnostic[];
+}
+export interface NormalizeResult {
+    nodes: MarkdownNode[];
+    toc: TocItem[];
+    customTags: MarkdownDocument['customTags'];
+}
+export declare function normalizeHast(root: Root, options: NormalizeOptions): NormalizeResult;
+/**
+ * Keep headings up to `depth`. A missing, zero, negative, or non-finite depth
+ * means all available levels. Values above six are also effectively unlimited.
+ */
+export declare function filterTocByDepth(toc: readonly TocItem[], depth: number | undefined): TocItem[];
+export declare function extractToc(nodes: readonly MarkdownNode[]): TocItem[];
+export declare function collectCustomTags(nodes: readonly MarkdownNode[]): MarkdownDocument['customTags'];
+export declare function walkNodes(nodes: readonly MarkdownNode[], visit: (node: MarkdownNode, parent: MarkdownNode | undefined) => void, parent?: MarkdownNode): void;

package/dist/core/parts.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Stable part names and token names.
+ *
+ * Parts are rendered as `class="vmd-<part>"` plus `data-vmd-part="<part>"`.
+ * They are stable within a major version and are never generated or hashed.
+ */
+export declare const VMD_CLASS_PREFIX = "vmd-";
+export declare const PARTS: {
+    readonly root: "root";
+    readonly body: "body";
+    readonly tocColumn: "toc-column";
+    readonly content: "content";
+    readonly toc: "toc";
+    readonly tocNav: "toc-nav";
+    readonly tocItem: "toc-item";
+    readonly paragraph: "paragraph";
+    readonly heading: "heading";
+    readonly headingAnchor: "heading-anchor";
+    readonly emphasis: "emphasis";
+    readonly strong: "strong";
+    readonly strikethrough: "strikethrough";
+    readonly link: "link";
+    readonly image: "image";
+    readonly list: "list";
+    readonly listItem: "list-item";
+    readonly blockquote: "blockquote";
+    readonly hr: "hr";
+    readonly break: "break";
+    readonly table: "table";
+    readonly tableSection: "table-section";
+    readonly tableRow: "table-row";
+    readonly tableCell: "table-cell";
+    readonly inlineCode: "inline-code";
+    readonly code: "code";
+    readonly codeHeader: "code-header";
+    readonly codeTitle: "code-title";
+    readonly codeFileName: "code-file-name";
+    readonly codeHeading: "code-heading";
+    readonly codeLang: "code-lang";
+    readonly codeToolbar: "code-toolbar";
+    readonly codeActions: "code-actions";
+    readonly codeAction: "code-action";
+    readonly codeBody: "code-body";
+    readonly codeFeedback: "code-feedback";
+    readonly highlighter: "highlighter";
+    readonly highlighterHeader: "highlighter-header";
+    readonly highlighterActions: "highlighter-actions";
+    readonly highlighterFooter: "highlighter-footer";
+    readonly highlighterBody: "highlighter-body";
+    readonly highlighterGutter: "highlighter-gutter";
+    readonly highlighterLine: "highlighter-line";
+    readonly highlighterHidden: "highlighter-hidden";
+    readonly highlighterEmpty: "highlighter-empty";
+    readonly highlighterToggle: "highlighter-toggle";
+    readonly math: "math";
+    readonly mathError: "math-error";
+    readonly mermaid: "mermaid";
+    readonly mermaidHeader: "mermaid-header";
+    readonly mermaidTabs: "mermaid-tabs";
+    readonly mermaidActions: "mermaid-actions";
+    readonly mermaidAction: "mermaid-action";
+    readonly mermaidPreview: "mermaid-preview";
+    readonly mermaidSource: "mermaid-source";
+    readonly mermaidPending: "mermaid-pending";
+    readonly mermaidError: "mermaid-error";
+    readonly mermaidFallback: "mermaid-fallback";
+    readonly mermaidFullscreen: "mermaid-fullscreen";
+    readonly editor: "editor";
+    readonly editorPane: "editor-pane";
+    readonly editorDivider: "editor-divider";
+    readonly editorPreview: "editor-preview";
+    readonly editorDiagnostics: "editor-diagnostics";
+    readonly editorEmpty: "editor-empty";
+    readonly editorToolbar: "editor-toolbar";
+    readonly editorFullscreen: "editor-fullscreen";
+    readonly html: "html";
+    readonly customTag: "custom-tag";
+    readonly taskItem: "task-item";
+    readonly taskCheckbox: "task-checkbox";
+    readonly footnoteReference: "footnote-reference";
+    readonly footnotes: "footnotes";
+    readonly searchMatch: "search-match";
+    readonly error: "error";
+    readonly empty: "empty";
+    readonly loading: "loading";
+};
+export type MarkdownPart = (typeof PARTS)[keyof typeof PARTS];
+export declare const TOKENS: {
+    readonly fontFamily: "--vmd-font-family";
+    readonly fontMono: "--vmd-font-mono";
+    readonly fontSize: "--vmd-font-size";
+    readonly lineHeight: "--vmd-line-height";
+    readonly colorText: "--vmd-color-text";
+    readonly colorMuted: "--vmd-color-muted";
+    readonly colorBg: "--vmd-color-bg";
+    readonly colorSurface: "--vmd-color-surface";
+    readonly colorBorder: "--vmd-color-border";
+    readonly colorAccent: "--vmd-color-accent";
+    readonly colorAccentContrast: "--vmd-color-accent-contrast";
+    readonly colorDanger: "--vmd-color-danger";
+    readonly colorSuccess: "--vmd-color-success";
+    readonly space1: "--vmd-space-1";
+    readonly space2: "--vmd-space-2";
+    readonly space3: "--vmd-space-3";
+    readonly space4: "--vmd-space-4";
+    readonly space5: "--vmd-space-5";
+    readonly space6: "--vmd-space-6";
+    readonly radiusSm: "--vmd-radius-sm";
+    readonly radiusMd: "--vmd-radius-md";
+    readonly radiusLg: "--vmd-radius-lg";
+    readonly shadowSm: "--vmd-shadow-sm";
+    readonly shadowMd: "--vmd-shadow-md";
+    readonly motionDuration: "--vmd-motion-duration";
+    readonly motionEasing: "--vmd-motion-easing";
+    readonly codeBg: "--vmd-code-bg";
+    readonly codeText: "--vmd-code-text";
+    readonly codeBorder: "--vmd-code-border";
+    readonly codeToolbarBg: "--vmd-code-toolbar-bg";
+    readonly mathColor: "--vmd-math-color";
+    readonly mathBg: "--vmd-math-bg";
+    readonly mermaidBg: "--vmd-mermaid-bg";
+    readonly mermaidBorder: "--vmd-mermaid-border";
+    readonly zFullscreen: "--vmd-z-fullscreen";
+};
+export type MarkdownToken = (typeof TOKENS)[keyof typeof TOKENS];
+export interface PartAttributes {
+    class: string;
+    'data-vmd-part': string;
+}
+/** Build the class and `data-vmd-part` attributes for a documented part. */
+export declare function partAttrs(part: MarkdownPart): PartAttributes;
+/** Merge part attributes with host-provided class names. */
+export declare function partClass(part: MarkdownPart, extra?: string): string;
+export declare const PART_NAMES: readonly MarkdownPart[];
+export declare const TOKEN_NAMES: readonly MarkdownToken[];

package/dist/core/preset.d.ts

@@ -0,0 +1,10 @@
+import { MarkdownPreset } from './types';
+/**
+ * Define a shareable preset. Presets contain components, plugin instances, and
+ * functions, so they are declarative and inspectable but not JSON-serializable.
+ */
+export declare function defineMarkdownPreset(preset: MarkdownPreset): MarkdownPreset;
+/** Compose presets in order; later presets override earlier values. */
+export declare function composePresets(...presets: Array<MarkdownPreset | false | null | undefined>): MarkdownPreset;
+/** Resolve a single preset, a preset list, or nothing. */
+export declare function resolvePreset(input: MarkdownPreset | readonly MarkdownPreset[] | undefined): MarkdownPreset | undefined;

package/dist/core/run.d.ts

@@ -0,0 +1,16 @@
+import { MarkdownDiagnostic, MarkdownDocumentOptions, MarkdownPipeline, MarkdownSlugger, PipelineContext } from './types';
+import { ResolvedPlugins } from '../plugins/registry';
+export interface MarkdownRun {
+    pipeline: MarkdownPipeline;
+    plugins: ResolvedPlugins;
+    source: string;
+    context: PipelineContext;
+    slugger: MarkdownSlugger;
+    diagnostics: MarkdownDiagnostic[];
+}
+/**
+ * Resolve and prepare one non-reactive pipeline run. Export uses this helper so
+ * source transforms, plugin resolution, and slugger setup match the
+ * composable's run.
+ */
+export declare function prepareMarkdownRun(source: string, options?: MarkdownDocumentOptions, diagnostics?: MarkdownDiagnostic[]): MarkdownRun;

package/dist/core/search.d.ts

@@ -0,0 +1,5 @@
+import { MarkdownDocument, MarkdownNode, SearchOptions } from './types';
+/** Split text nodes into match/non-match segments without changing structure. */
+export declare function segmentSearch(nodes: readonly MarkdownNode[], options: SearchOptions): void;
+export declare function searchDocument(document: MarkdownDocument, options: SearchOptions): MarkdownDocument;
+export declare function countSearchMatches(nodes: readonly MarkdownNode[]): number;