@coderminer/vue-markdown 0.0.0-stage → 1.0.0

package/dist/core/security.d.ts

@@ -0,0 +1,21 @@
+import { Properties } from 'hast';
+/** Tags that may appear in the normalized model. */
+export declare const ALLOWED_TAGS: Set<string>;
+/** Tags whose content must never reach the model. */
+export declare const DANGEROUS_TAGS: Set<string>;
+declare const URL_ATTRIBUTES: Set<string>;
+export { URL_ATTRIBUTES };
+export declare function toAttributeName(key: string): string;
+export declare function isAllowedAttribute(tag: string, name: string): boolean;
+/**
+ * Validate one URL-bearing attribute value. `srcset` holds a comma-separated
+ * candidate list, so each candidate is checked individually.
+ */
+export declare function sanitizeUrlValue(value: string, key: string): string | undefined;
+export declare function sanitizeStyleValue(value: string): string | undefined;
+export interface PropertiesToAttrsOptions {
+    /** Allow a constrained inline-style subset for trusted engine output. */
+    allowStyle?: boolean;
+}
+/** Convert hast properties into safe, normalized attributes. */
+export declare function propertiesToAttrs(tag: string, properties: Properties | undefined, options?: PropertiesToAttrsOptions): Record<string, string>;

package/dist/core/slugger.d.ts

@@ -0,0 +1,6 @@
+import { MarkdownSlugger } from './types';
+/**
+ * Ensure a host slugger still produces unique heading IDs. The wrapper keeps
+ * the host's formatting and appends a numeric suffix for duplicates.
+ */
+export declare function withUniqueSlugs(slugger: MarkdownSlugger): MarkdownSlugger;

package/dist/core/types.d.ts

@@ -0,0 +1,390 @@
+import { Root } from 'hast';
+import { PluggableList } from 'unified';
+/** A position inside the original Markdown source. */
+export interface SourcePosition {
+    line: number;
+    column: number;
+    offset?: number;
+}
+/** A half-open range inside the original Markdown source. */
+export interface SourceRange {
+    start: SourcePosition;
+    end: SourcePosition;
+}
+/** A piece of a text node, optionally marked as a search match. */
+export interface MarkdownTextSegment {
+    value: string;
+    match?: boolean;
+}
+export interface MarkdownTextNode {
+    kind: 'text';
+    key: string;
+    value: string;
+    segments?: MarkdownTextSegment[];
+    source?: SourceRange;
+}
+export interface MarkdownElementNode {
+    kind: 'element';
+    key: string;
+    tag: string;
+    attrs: Record<string, string>;
+    children: MarkdownNode[];
+    source?: SourceRange;
+}
+export interface MarkdownCodeNode {
+    kind: 'code';
+    key: string;
+    code: string;
+    language: string;
+    highlighted?: MarkdownNode[];
+    source?: SourceRange;
+}
+export interface MarkdownMathNode {
+    kind: 'math';
+    key: string;
+    tex: string;
+    displayMode: boolean;
+    rendered?: MarkdownNode[];
+    source?: SourceRange;
+}
+export interface MarkdownMermaidNode {
+    kind: 'mermaid';
+    key: string;
+    code: string;
+    complete: boolean;
+    index: number;
+    source?: SourceRange;
+}
+export interface MarkdownCustomTagNode {
+    kind: 'custom';
+    key: string;
+    tag: string;
+    props: Record<string, unknown>;
+    attrs: Record<string, string>;
+    children: MarkdownNode[];
+    source?: SourceRange;
+}
+export interface MarkdownPluginNode {
+    kind: 'plugin';
+    key: string;
+    type: string;
+    payload: unknown;
+    children?: MarkdownNode[];
+    source?: SourceRange;
+}
+/** The immutable, serializable document model. */
+export type MarkdownNode = MarkdownTextNode | MarkdownElementNode | MarkdownCodeNode | MarkdownMathNode | MarkdownMermaidNode | MarkdownCustomTagNode | MarkdownPluginNode;
+export interface TocItem {
+    id: string;
+    text: string;
+    level: number;
+}
+/** Renderer-level search state emitted with `search-change`. */
+export interface SearchChangePayload {
+    query: string;
+    caseSensitive: boolean;
+    matches: number;
+}
+/** Options for segmenting text nodes into search matches. */
+export interface SearchOptions {
+    query?: string;
+    caseSensitive?: boolean;
+}
+export interface CustomTagInstance {
+    key: string;
+    tag: string;
+    props: Record<string, unknown>;
+    attrs: Record<string, string>;
+}
+export interface MarkdownDocument {
+    nodes: MarkdownNode[];
+    toc: TocItem[];
+    customTags: CustomTagInstance[];
+    frontmatter?: Record<string, unknown>;
+    plugins: string[];
+    pipeline: string;
+}
+export type DiagnosticSeverity = 'error' | 'warning';
+export type DiagnosticPhase = 'setup' | 'source' | 'remark' | 'rehype' | 'normalize' | 'document' | 'search' | 'render' | 'pipeline';
+export interface MarkdownDiagnostic {
+    code: string;
+    message: string;
+    severity: DiagnosticSeverity;
+    phase?: DiagnosticPhase;
+    plugin?: string;
+    source?: SourceRange;
+    /** Optional raw parser/engine detail shown only by opt-in UI. */
+    details?: string;
+}
+/**
+ * A component reference accepted by the core types.
+ *
+ * The core stays free of Vue types; the Vue-facing aliases in
+ * `components/types.ts` narrow this to Vue's `Component`.
+ */
+export type MarkdownComponentValue = string | object | ((...args: never[]) => unknown) | undefined;
+export type MarkdownTagComponents = Record<string, MarkdownComponentValue>;
+export type MarkdownNodeComponents = Record<string, MarkdownComponentValue>;
+export interface MarkdownRegionComponents {
+    root?: MarkdownComponentValue;
+    content?: MarkdownComponentValue;
+    toc?: MarkdownComponentValue;
+    tocItem?: MarkdownComponentValue;
+    codeBlock?: MarkdownComponentValue;
+    mermaidBlock?: MarkdownComponentValue;
+    error?: MarkdownComponentValue;
+    empty?: MarkdownComponentValue;
+    loading?: MarkdownComponentValue;
+}
+export type MarkdownLabelContext = Record<string, unknown>;
+export type MarkdownLabelValue = string | ((context: MarkdownLabelContext) => string);
+export interface MarkdownLabels {
+    toc: MarkdownLabelValue;
+    error: MarkdownLabelValue;
+    empty: MarkdownLabelValue;
+    loading: MarkdownLabelValue;
+    headingAnchor: MarkdownLabelValue;
+    externalLink: MarkdownLabelValue;
+    copy: MarkdownLabelValue;
+    copied: MarkdownLabelValue;
+    copyFailed: MarkdownLabelValue;
+    download: MarkdownLabelValue;
+    footnoteReference: MarkdownLabelValue;
+    footnotes: MarkdownLabelValue;
+    math: MarkdownLabelValue;
+    mermaid: MarkdownLabelValue;
+    mermaidFallback: MarkdownLabelValue;
+    preview: MarkdownLabelValue;
+    source: MarkdownLabelValue;
+    retry: MarkdownLabelValue;
+    showAll: MarkdownLabelValue;
+    showLess: MarkdownLabelValue;
+    exportPng: MarkdownLabelValue;
+    fullscreen: MarkdownLabelValue;
+    exitFullscreen: MarkdownLabelValue;
+    zoomIn: MarkdownLabelValue;
+    zoomOut: MarkdownLabelValue;
+    reset: MarkdownLabelValue;
+    editor: MarkdownLabelValue;
+    editorEmpty: MarkdownLabelValue;
+    editorLine: MarkdownLabelValue;
+    editorSplitter: MarkdownLabelValue;
+    editorDiagnostics: MarkdownLabelValue;
+    editorReset: MarkdownLabelValue;
+    editorSyntaxError: MarkdownLabelValue;
+    editorParseError: MarkdownLabelValue;
+}
+export type MarkdownTheme = 'light' | 'dark' | 'auto' | 'custom';
+export interface HighlightOptions {
+    theme?: string;
+    colorScheme?: 'light' | 'dark';
+    [option: string]: unknown;
+}
+export interface HighlightResult {
+    language: string;
+    nodes: MarkdownNode[];
+    mode?: 'content' | 'block';
+    className?: string;
+}
+/** A 1-based line number or an inclusive `start-end` range string. */
+export type HighlightLine = number | string;
+export interface CodeBlockAction {
+    key: string;
+    label: MarkdownLabelValue;
+    run(context: {
+        code: string;
+        language: string;
+        copy(): Promise<void>;
+        download(): Promise<void>;
+    }): void | Promise<void>;
+}
+export interface MermaidAction {
+    key: string;
+    label: MarkdownLabelValue;
+    run(context: {
+        source: string;
+        copy(): Promise<void>;
+        exportPng(): Promise<void>;
+        downloadSvg(): void;
+        fullscreen(): Promise<void> | void;
+        retry(): Promise<void>;
+        zoomIn(): void;
+        zoomOut(): void;
+        resetZoom(): void;
+    }): void | Promise<void>;
+}
+export interface MarkdownHighlighter {
+    id: string;
+    load?(): Promise<void>;
+    languages?: string[];
+    loadLanguage?(language: string): Promise<void>;
+    highlight(code: string, language: string, options: HighlightOptions): HighlightResult;
+}
+export interface MathRenderOptions {
+    displayMode?: boolean;
+    [option: string]: unknown;
+}
+export interface MathRenderResult {
+    nodes: MarkdownNode[];
+    error?: string;
+}
+export interface MathEngine {
+    id: string;
+    load?(): Promise<void>;
+    render(tex: string, options: MathRenderOptions): MathRenderResult;
+}
+export interface MermaidRenderOptions {
+    theme?: MarkdownTheme;
+    id?: string;
+    [option: string]: unknown;
+}
+export interface MermaidRenderResult {
+    nodes: MarkdownNode[];
+    svg?: string;
+    error?: string;
+}
+export interface MermaidRenderer {
+    id: string;
+    render(source: string, options: MermaidRenderOptions): MermaidRenderResult | Promise<MermaidRenderResult>;
+}
+export interface DiagnosticFormatter {
+    id?: string;
+    format(error: unknown, source: string): MarkdownDiagnostic;
+}
+/** Parsed configuration shared by the provider, presets, and the renderer. */
+export interface MarkdownConfig {
+    theme?: MarkdownTheme;
+    tokens?: Record<string, string>;
+    labels?: Partial<MarkdownLabels>;
+    components?: MarkdownTagComponents;
+    regions?: MarkdownRegionComponents;
+    nodeComponents?: MarkdownNodeComponents;
+    plugins?: PluginInput[];
+    pipeline?: MarkdownPipeline;
+    highlighter?: MarkdownHighlighter;
+    mathEngine?: MathEngine;
+    mermaidRenderer?: MermaidRenderer;
+    diagnosticsFormatter?: DiagnosticFormatter;
+    slugger?: MarkdownSlugger;
+    urlTransform?: MarkdownUrlTransform;
+}
+/** A named, declarative bundle of configuration. Not JSON-serializable. */
+export interface MarkdownPreset extends MarkdownConfig {
+    name: string;
+}
+export interface MarkdownSlugger {
+    slug(value: string): string;
+    reset?(): void;
+}
+export interface MarkdownElementLike {
+    tag: string;
+    attrs: Record<string, string>;
+}
+export type MarkdownUrlTransform = (url: string, key: string, node: MarkdownElementLike) => string | null | undefined;
+export type AllowElement = (node: MarkdownElementNode, index: number | undefined, parent: MarkdownElementNode | undefined) => boolean | null | undefined;
+/** Result of a pipeline run: hast plus optional document metadata. */
+export interface PipelineResult {
+    hast: Root;
+    frontmatter?: Record<string, unknown>;
+}
+export interface PipelineCapabilities {
+    /** The pipeline exposes a synchronous path. */
+    sync?: boolean;
+    /** The pipeline reports plugin names. */
+    plugins?: boolean;
+}
+/**
+ * Add-only extension for the built-in raw HTML sanitizer. Property names use
+ * hast property casing (for example `srcSet`, `dateTime`). Extensions cannot
+ * remove the built-in strip list, change the URL policy, or bypass the core
+ * attribute policy.
+ */
+export interface HtmlSchemaExtension {
+    /** Extra tag names to allow. Dangerous tags remain stripped. */
+    tags?: string[];
+    /** Extra properties per tag; `'*'` applies to every tag. */
+    attributes?: Record<string, string[]>;
+}
+export interface PluginContext {
+    source: string;
+    options: MarkdownDocumentOptions;
+    diagnostics: MarkdownDiagnostic[];
+    addDiagnostic(diagnostic: MarkdownDiagnostic): void;
+    document?: MarkdownDocument;
+}
+export interface MarkdownPlugin {
+    name: string;
+    /**
+     * Core invariant markers cannot be disabled. Their names remain in the
+     * resolved set for ordering and diagnostics only.
+     */
+    core?: boolean;
+    phase?: 'pre' | 'normal' | 'post';
+    /**
+     * This plugin enables raw HTML parsing. Its rehype plugins run before the
+     * built-in sanitizer, and the official pipeline always sanitizes the result.
+     */
+    html?: boolean;
+    /** Add-only extension for the built-in raw HTML sanitizer. */
+    htmlSchema?: HtmlSchemaExtension;
+    remarkPlugins?: PluggableList;
+    rehypePlugins?: PluggableList;
+    remarkRehypeOptions?: Record<string, unknown>;
+    transformSource?(source: string, ctx: PluginContext): string;
+    transformDocument?(document: MarkdownDocument, ctx: PluginContext): MarkdownDocument | void;
+    nodeComponents?: MarkdownNodeComponents;
+    components?: MarkdownTagComponents;
+    regions?: MarkdownRegionComponents;
+    labels?: Partial<MarkdownLabels>;
+    tokens?: Record<string, string>;
+    setup?(ctx: PluginContext): void | (() => void);
+    onError?(error: unknown, phase: DiagnosticPhase, ctx: PluginContext): void;
+}
+export type PluginInput = MarkdownPlugin | false | null | undefined;
+export interface PipelineContext {
+    source: string;
+    /**
+     * The options that produced this run. Optional for custom pipelines that do
+     * not need plugin callbacks.
+     */
+    options?: MarkdownDocumentOptions;
+    plugins: MarkdownPlugin[];
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    remarkRehypeOptions: Record<string, unknown>;
+    slugger: MarkdownSlugger;
+    idPrefix: string;
+    diagnostics: MarkdownDiagnostic[];
+}
+export interface MarkdownPipeline {
+    name: string;
+    capabilities?: PipelineCapabilities;
+    process(source: string, ctx: PipelineContext): Promise<PipelineResult>;
+    processSync?(source: string, ctx: PipelineContext): PipelineResult;
+    dispose?(): void;
+}
+export interface MarkdownDocumentOptions {
+    components?: MarkdownTagComponents;
+    nodeComponents?: MarkdownNodeComponents;
+    regions?: MarkdownRegionComponents;
+    labels?: Partial<MarkdownLabels>;
+    tokens?: Record<string, string>;
+    plugins?: PluginInput[];
+    disablePlugins?: string[];
+    remarkPlugins?: PluggableList;
+    rehypePlugins?: PluggableList;
+    remarkRehypeOptions?: Record<string, unknown>;
+    pipeline?: MarkdownPipeline;
+    slugger?: MarkdownSlugger;
+    allowedElements?: string[];
+    disallowedElements?: string[];
+    unwrapDisallowed?: boolean;
+    allowElement?: AllowElement;
+    urlTransform?: MarkdownUrlTransform;
+    linkTarget?: string;
+    externalLinkTarget?: string;
+    baseUrl?: string;
+    idPrefix?: string;
+    /** Host-provided search state; search segments are recomputed when set. */
+    search?: SearchOptions;
+}

package/dist/core/url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * react-markdown-compatible URL transform.
+ *
+ * Relative URLs and the documented protocol set pass through. Dangerous
+ * protocols are removed. Image data URLs are accepted for raster formats only;
+ * `image/svg+xml` is rejected because it can carry script.
+ */
+export declare function defaultUrlTransform(url: string, key?: string): string;
+export declare function isExternalUrl(url: string): boolean;
+export declare function resolveUrl(url: string, baseUrl: string | undefined): string;

package/dist/editor/codemirror.d.ts

@@ -0,0 +1,14 @@
+import { EditorView } from '@codemirror/view';
+export interface MermaidEditorHandle {
+    destroy(): void;
+    focus(): void;
+    setValue(value: string): void;
+    focusLine(line: number): void;
+}
+export interface CreateEditorOptions {
+    value: string;
+    theme?: 'light' | 'dark' | 'auto' | 'custom';
+    onChange(value: string): void;
+}
+export declare function createMermaidEditor(parent: HTMLElement, options: CreateEditorOptions): Promise<MermaidEditorHandle>;
+export type { EditorView };

package/dist/editor/index.d.ts

@@ -0,0 +1,2 @@
+export { createMermaidEditor } from './codemirror';
+export type { CreateEditorOptions, MermaidEditorHandle } from './codemirror';

package/dist/editor/index.js

@@ -0,0 +1 @@
+export { t as createMermaidEditor } from "../chunks/codemirror-DyphMAEg.js";

package/dist/export/index.d.ts

@@ -0,0 +1,6 @@
+import { MarkdownDocumentOptions } from '../core/types';
+export type StaticHtmlOptions = MarkdownDocumentOptions;
+/** Render Markdown to static HTML with the same normalized document as rendering. */
+export declare function exportMarkdownHtml(source: string, options?: StaticHtmlOptions): Promise<string>;
+/** Synchronous static HTML export when every configured plugin is synchronous. */
+export declare function exportMarkdownHtmlSync(source: string, options?: StaticHtmlOptions): string;

package/dist/headless.d.ts

@@ -0,0 +1,21 @@
+export * from './core/types';
+export * from './core/parts';
+export * from './core/labels';
+export * from './core/diagnostics';
+export * from './core/url';
+export * from './core/model';
+export * from './core/normalize';
+export * from './core/search';
+export * from './core/slugger';
+export * from './core/manifest';
+export * from './core/config';
+export * from './core/preset';
+export * from './core/adapters';
+export * from './export';
+export * from './core/memo';
+export * from './pipeline';
+export * from './plugins/define';
+export * from './plugins/builtin';
+export * from './plugins/registry';
+export * from './composables/useMarkdownDocument';
+export * from './composables/useActiveHeading';

package/dist/headless.js

@@ -0,0 +1,12 @@
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, p as c, r as l, s as u, t as d, u as f } from "./chunks/export-DZQ3cUry.js";
+import { n as p, t as m } from "./chunks/labels-BtHiUTQI.js";
+import { n as h, t as g } from "./chunks/diagnostics-CtHoJyiX.js";
+import { n as _, r as v, t as y } from "./chunks/url-D2BoivaE.js";
+import { a as b, i as x, n as S, r as C, t as w } from "./chunks/normalize-CRYv3Wqt.js";
+import { a as T, d as E, f as D, i as O, n as k, o as A, p as j, r as M, s as N, t as P } from "./chunks/useActiveHeading-BaGVMJnB.js";
+import { _ as F, a as I, c as L, d as R, f as z, g as B, h as V, i as H, l as U, n as W, o as G, p as K, r as q, s as J, t as Y, u as X } from "./chunks/registry-DLjr93-V.js";
+import { a as Z, i as Q, n as $, r as ee, t as te } from "./chunks/preset-BjaOuJUL.js";
+import { a as ne, i as re, n as ie, o as ae, r as oe, t as se } from "./chunks/adapters-CMwX_NEI.js";
+import { a as ce, i as le, n as ue, o as de, r as fe, s as pe, t as me } from "./chunks/identity-jZEhX2d5.js";
+import "./pipeline.js";
+export { l as COMPONENT_MANIFESTS, m as DEFAULT_LABELS, u as PARTS, t as PART_NAMES, a as TOKENS, f as TOKEN_NAMES, n as VMD_CLASS_PREFIX, fe as assertPipelineResult, D as buildDocument, W as codePlugin, w as collectCustomTags, te as composePresets, V as countSearchMatches, g as createDiagnostic, me as createMemoKey, pe as createOfficialPipeline, ue as createPipelineIdentity, R as createPluginContext, q as customTagsPlugin, H as defaultPlugins, y as defaultUrlTransform, le as defineMarkdownPipeline, z as defineMarkdownPlugin, $ as defineMarkdownPreset, h as errorMessage, d as exportMarkdownHtml, o as exportMarkdownHtmlSync, S as extractToc, C as filterTocByDepth, P as findElementById, I as frontmatterPlugin, G as fullPlugins, i as getComponentManifest, J as gfmPlugin, _ as isExternalUrl, se as isValidDiagnosticFormatter, ie as isValidHighlighter, oe as isValidMathEngine, re as isValidMermaidRenderer, ne as isValidSlugger, ae as isValidUrlTransform, L as linkPlugin, O as memoClear, T as memoGet, A as memoSet, N as memoSize, Q as mergeMarkdownConfig, Z as mergeMarkdownPreset, x as normalizeHast, r as partAttrs, c as partClass, p as resolveLabel, ce as resolvePipeline, Y as resolvePlugins, ee as resolvePreset, v as resolveUrl, B as searchDocument, U as searchPlugin, F as segmentSearch, X as tocPlugin, k as useActiveHeading, M as useMarkdownDocument, e as validateManifest, s as validateManifestRegistry, de as validatePipeline, K as validatePlugin, b as walkNodes, j as withDerivedDocument, E as withUniqueSlugs };

package/dist/highlight/highlightjs.d.ts

@@ -0,0 +1,7 @@
+import { MarkdownHighlighter } from '../core/types';
+/**
+ * Default highlight.js adapter. It is intentionally synchronous so the
+ * renderer can produce highlighted output without blocking.
+ */
+export declare const highlightjs: MarkdownHighlighter;
+export default highlightjs;

package/dist/highlight/index.d.ts

@@ -0,0 +1,3 @@
+export { highlightjs } from './highlightjs';
+export { default } from './highlightjs';
+export { clearHighlightCache, highlightedNodesFromHast, highlightedNodesFromHtml, plaintextHighlight, runHighlighter, splitHighlightLines, } from './shared';

package/dist/highlight/index.js

@@ -0,0 +1,3 @@
+import { a as e, i as t, n, o as r, r as i, t as a } from "../chunks/shared-DNAvZ-UY.js";
+import { t as o } from "../chunks/highlightjs-BEh-YwEG.js";
+export { a as clearHighlightCache, o as default, o as highlightjs, n as highlightedNodesFromHast, i as highlightedNodesFromHtml, t as plaintextHighlight, e as runHighlighter, r as splitHighlightLines };

package/dist/highlight/shared.d.ts

@@ -0,0 +1,16 @@
+import { HighlightOptions, HighlightResult, MarkdownHighlighter, MarkdownNode } from '../core/types';
+import { hastToMarkdownNodes } from '../core/hast-nodes';
+export declare function plaintextHighlight(code: string, language?: string): HighlightResult;
+/** Convert trusted engine HTML into normalized nodes. */
+export declare function highlightedNodesFromHtml(html: string): MarkdownNode[];
+/** Convert an already-parsed hast subtree into normalized nodes. */
+export declare function highlightedNodesFromHast(nodes: Parameters<typeof hastToMarkdownNodes>[0]): MarkdownNode[];
+export declare function cacheKey(highlighter: MarkdownHighlighter, code: string, language: string, options: HighlightOptions): string;
+export declare function clearHighlightCache(): void;
+/**
+ * Run one adapter safely. Invalid adapters, thrown errors, and malformed
+ * results fall back to plain text instead of breaking the document.
+ */
+export declare function runHighlighter(highlighter: MarkdownHighlighter | undefined, code: string, language: string, options?: HighlightOptions): HighlightResult;
+/** Split highlighted nodes into lines while preserving element wrappers. */
+export declare function splitHighlightLines(nodes: readonly MarkdownNode[]): MarkdownNode[][];

package/dist/highlight/shiki.d.ts

@@ -0,0 +1,7 @@
+import { MarkdownHighlighter } from '../core/types';
+/**
+ * Optional Shiki adapter. The highlighter, themes, and requested languages
+ * load asynchronously; until then callers see plain text.
+ */
+export declare const shiki: MarkdownHighlighter;
+export default shiki;

package/dist/highlight/shiki.js

@@ -0,0 +1,76 @@
+import { t as e } from "../chunks/objectSpread2-CtBNx0TF.js";
+import { t } from "../chunks/asyncToGenerator-ChigusFD.js";
+import { i as n, n as r } from "../chunks/shared-DNAvZ-UY.js";
+import { createHighlighter as i } from "shiki";
+// src/highlight/shiki.ts
+var a = {
+	light: "github-light",
+	dark: "github-dark"
+}, o = [
+	"bash",
+	"css",
+	"diff",
+	"go",
+	"html",
+	"javascript",
+	"json",
+	"markdown",
+	"python",
+	"rust",
+	"shell",
+	"sql",
+	"tsx",
+	"typescript",
+	"xml",
+	"yaml"
+], s, c;
+function l() {
+	return u.apply(this, arguments);
+}
+function u() {
+	return u = t(function* () {
+		return c || (s || (s = i({
+			themes: [a.light, a.dark],
+			langs: o
+		}).then((e) => (c = e, e))), s);
+	}), u.apply(this, arguments);
+}
+function d(e) {
+	var t, n, r;
+	let i = e[0], a = i == null || (t = i.children) == null ? void 0 : t.find((e) => e.tagName === "pre"), o = a == null || (n = a.children) == null ? void 0 : n.find((e) => e.tagName === "code");
+	return (r = o == null ? void 0 : o.children) == null ? [] : r;
+}
+var f = {
+	id: "shiki",
+	languages: o,
+	load: function() {
+		var e = t(function* () {
+			yield l();
+		});
+		return function() {
+			return e.apply(this, arguments);
+		};
+	}(),
+	loadLanguage(e) {
+		return t(function* () {
+			let t = yield l();
+			t.getLoadedLanguages().includes(e) || (yield t.loadLanguage(e));
+		})();
+	},
+	highlight(t, i, o) {
+		var s;
+		if (!c) return n(t, i);
+		let l = c.getLoadedLanguages().includes(i) ? i : "text", u = (s = o.colorScheme) == null ? o.theme === "dark" ? "dark" : "light" : s, f = c.codeToHast(t, e({
+			lang: l,
+			themes: a,
+			defaultColor: u
+		}, o.theme ? { theme: o.theme } : {}));
+		return {
+			language: l,
+			nodes: r(d([f]))
+		};
+	}
+};
+export { f as default, f as shiki };
+
+//# sourceMappingURL=shiki.js.map

package/dist/highlight/shiki.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shiki.js","names":["_objectSpread2","plaintextHighlight","highlightedNodesFromHast","THEMES","DEFAULT_LANGUAGES","highlighterPromise","highlighter","getHighlighter","_getHighlighter","_asyncToGenerator","createHighlighter","instance","codeChildren","_root$children","_pre$children","_code$children","root","nodes","pre","node","code","shiki","_ref","language","_options$colorScheme","lang","colorScheme","options"],"sources":["../../src/highlight/shiki.ts"],"sourcesContent":["import { createHighlighter, type Highlighter } from 'shiki'\r\nimport type { MarkdownHighlighter } from '../core/types'\r\nimport { highlightedNodesFromHast, plaintextHighlight } from './shared'\r\n\r\nconst THEMES = {\r\n  light: 'github-light',\r\n  dark: 'github-dark',\r\n} as const\r\n\r\nconst DEFAULT_LANGUAGES = [\r\n  'bash',\r\n  'css',\r\n  'diff',\r\n  'go',\r\n  'html',\r\n  'javascript',\r\n  'json',\r\n  'markdown',\r\n  'python',\r\n  'rust',\r\n  'shell',\r\n  'sql',\r\n  'tsx',\r\n  'typescript',\r\n  'xml',\r\n  'yaml',\r\n]\r\n\r\nlet highlighterPromise: Promise<Highlighter> | undefined\r\nlet highlighter: Highlighter | undefined\r\n\r\nasync function getHighlighter(): Promise<Highlighter> {\r\n  if (highlighter) return highlighter\r\n  if (!highlighterPromise) {\r\n    highlighterPromise = createHighlighter({\r\n      themes: [THEMES.light, THEMES.dark],\r\n      langs: DEFAULT_LANGUAGES,\r\n    }).then((instance) => {\r\n      highlighter = instance\r\n      return instance\r\n    })\r\n  }\r\n  return highlighterPromise\r\n}\r\n\r\nfunction codeChildren(nodes: readonly unknown[]): readonly unknown[] {\r\n  const root = nodes[0] as { children?: readonly unknown[] } | undefined\r\n  const pre = root?.children?.find(\r\n    (node) => (node as { tagName?: string }).tagName === 'pre',\r\n  ) as { children?: readonly unknown[] } | undefined\r\n  const code = pre?.children?.find(\r\n    (node) => (node as { tagName?: string }).tagName === 'code',\r\n  ) as { children?: readonly unknown[] } | undefined\r\n  return code?.children ?? []\r\n}\r\n\r\n/**\r\n * Optional Shiki adapter. The highlighter, themes, and requested languages\r\n * load asynchronously; until then callers see plain text.\r\n */\r\nexport const shiki: MarkdownHighlighter = {\r\n  id: 'shiki',\r\n  languages: DEFAULT_LANGUAGES,\r\n  load: async () => {\r\n    await getHighlighter()\r\n  },\r\n  async loadLanguage(language) {\r\n    const instance = await getHighlighter()\r\n    if (!instance.getLoadedLanguages().includes(language)) {\r\n      await instance.loadLanguage(language as never)\r\n    }\r\n  },\r\n  highlight(code, language, options) {\r\n    if (!highlighter) return plaintextHighlight(code, language)\r\n    const loaded = highlighter.getLoadedLanguages()\r\n    const lang = loaded.includes(language as never) ? language : 'text'\r\n    // Keep both theme variants in the token style while making the active\r\n    // scheme the concrete color. Normalization preserves that constrained\r\n    // style subset, so tokens keep their colors instead of rendering\r\n    // monochrome.\r\n    const colorScheme =\r\n      options.colorScheme ?? (options.theme === 'dark' ? 'dark' : 'light')\r\n    const root = highlighter.codeToHast(code, {\r\n      lang: lang as never,\r\n      themes: THEMES,\r\n      defaultColor: colorScheme,\r\n      ...(options.theme ? { theme: options.theme as never } : {}),\r\n    })\r\n    return {\r\n      language: lang,\r\n      nodes: highlightedNodesFromHast(\r\n        codeChildren([root]) as never[],\r\n      ),\r\n    }\r\n  },\r\n}\r\n\r\nexport default shiki\r\n"],"mappings":";;;;;AAIA,IAAMG,IAAS;CACb,OAAO;CACP,MAAM;AACR,GAEMC,IAAoB;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,GAEIC,GACAC;AAEJ,SAAeC,IAAA;;;;C,OAAuC,IAAAE,EAAA,aAAA;EAWpD,OAVIH,MACCD,MACH,IAAqBK,EAAkB;GACrC,QAAQ,CAACP,EAAO,OAAOA,EAAO,IAAI;GAClC,OAAOC;EACT,CAAC,CAAC,CAAC,MAAM,OACP,IAAcO,GACPA,EACR,IAEIN;CACT,CAAA,G;;AAEA,SAASO,EAAa,GAA+C;;CACnE,IAAMI,IAAOC,EAAM,IACbC,IAAAF,KAAA,SAAA,IAAMA,EAAM,aAAA,OAAA,KAAA,IAAAH,EAAU,MACzB,MAAUM,EAA8B,YAAY,KACvD,GACMC,IAAAF,KAAA,SAAA,IAAOA,EAAK,aAAA,OAAA,KAAA,IAAAJ,EAAU,MACzB,MAAUK,EAA8B,YAAY,MACvD;CACA,QAAA,IAAAC,KAAA,OAAA,KAAA,IAAOA,EAAM,aAAA,OAAY,CAAC,IAAbL;AACf;AAMA,IAAaM,IAA6B;CACxC,IAAI;CACJ,WAAWjB;CACX,MAAA,WAAA;EAAkB,IAAAkB,IAAAb,EAAA,aAAA;GAChB,MAAMF,EAAe;EACvB,CAAA;;;;;CACA,aAAmB,GAAA;EAAU,OAAAE,EAAA,aAAA;GAC3B,IAAME,IAAW,MAAMJ,EAAe;GACtC,AAAKI,EAAS,mBAAmB,CAAC,CAAC,SAASY,CAAQ,MAClD,MAAMZ,EAAS,aAAaY,CAAiB;EAEjD,CAAA,CAAA,CAAA;;CACA,UAAU,GAAM,GAAU,GAAS;;EACjC,IAAI,CAACjB,GAAa,OAAOL,EAAmBmB,GAAMG,CAAQ;EAE1D,IAAME,IADSnB,EAAY,mBACd,CAAA,CAAO,SAASiB,CAAiB,IAAIA,IAAW,QAKvDG,KAAA,IACJC,EAAQ,gBAAA,OAAgBA,EAAQ,UAAU,SAAS,SAAS,UAApDH,GACJR,IAAOV,EAAY,WAAWc,GAAApB,EAAA;GAC5B;GACN,QAAQG;GACR,cAAcuB;EACV,GAAAC,EAAQ,QAAQ,EAAE,OAAOA,EAAQ,MAAe,IAAI,CAAC,CAC3D,CAAC;EACD,OAAO;GACL,UAAUF;GACV,OAAOvB,EACLU,EAAa,CAACI,CAAI,CAAC,CACrB;EACF;CACF;AACF"}

package/dist/html/index.d.ts

@@ -0,0 +1,17 @@
+import { HtmlSchemaExtension, MarkdownPlugin } from '../core/types';
+export interface HtmlPluginOptions {
+    /**
+     * Add-only extension for the built-in raw HTML sanitizer. Property names use
+     * hast casing, for example `srcSet` and `dateTime`.
+     */
+    schema?: HtmlSchemaExtension;
+}
+/**
+ * Enable sanitized raw HTML in the official pipeline.
+ *
+ * The plugin contributes `rehype-raw`; the official pipeline runs it before the
+ * built-in sanitizer and ignores manual `rehype-raw` entries. Importing this
+ * entry is the only supported way to render raw HTML.
+ */
+export declare function htmlPlugin(options?: HtmlPluginOptions): MarkdownPlugin;
+export type { HtmlSchemaExtension };

package/dist/html/index.js

@@ -0,0 +1,13 @@
+import e from "rehype-raw";
+// src/html/index.ts
+function t(t = {}) {
+	return {
+		name: "html",
+		html: !0,
+		htmlSchema: t.schema,
+		rehypePlugins: [[e, {}]]
+	};
+}
+export { t as htmlPlugin };
+
+//# sourceMappingURL=index.js.map

package/dist/html/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["rehypeRaw","htmlPlugin","options"],"sources":["../../src/html/index.ts"],"sourcesContent":["import rehypeRaw from 'rehype-raw'\nimport type { HtmlSchemaExtension, MarkdownPlugin } from '../core/types'\n\nexport interface HtmlPluginOptions {\n  /**\n   * Add-only extension for the built-in raw HTML sanitizer. Property names use\n   * hast casing, for example `srcSet` and `dateTime`.\n   */\n  schema?: HtmlSchemaExtension\n}\n\n/**\n * Enable sanitized raw HTML in the official pipeline.\n *\n * The plugin contributes `rehype-raw`; the official pipeline runs it before the\n * built-in sanitizer and ignores manual `rehype-raw` entries. Importing this\n * entry is the only supported way to render raw HTML.\n */\nexport function htmlPlugin(options: HtmlPluginOptions = {}): MarkdownPlugin {\n  return {\n    name: 'html',\n    html: true,\n    htmlSchema: options.schema,\n    rehypePlugins: [[rehypeRaw, {}]],\n  }\n}\n\nexport type { HtmlSchemaExtension }\n"],"mappings":";;AAkBA,SAAgBC,EAAW,IAA6B,CAAC,GAAmB;CAC1E,OAAO;EACL,MAAM;EACN,MAAM;EACN,YAAYC,EAAQ;EACpB,eAAe,CAAC,CAACF,GAAW,CAAC,CAAC,CAAC;CACjC;AACF"}