@coderminer/vue-markdown 0.0.0-stage → 1.0.1

package/dist/core/types.d.ts

@@ -0,0 +1,392 @@
+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;
+}
+/** Target applied to links whose destination is outside the current base URL. */
+export type MarkdownExternalLinkTarget = '_self' | '_blank';
+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?: MarkdownExternalLinkTarget;
+    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-BrgMLgUp.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, o as C, r as w, t as T } from "./chunks/normalize-VKfQXZiK.js";
+import { a as E, d as D, f as O, i as k, n as A, o as j, p as M, r as N, s as P, t as F, u as I } from "./chunks/useActiveHeading-CnyGTG1u.js";
+import { _ as L, a as R, c as z, d as B, f as V, g as H, h as U, i as W, l as G, n as K, o as q, p as J, r as Y, s as X, t as Z, u as Q } from "./chunks/registry-B7BfEkuy.js";
+import { a as $, i as ee, n as te, r as ne, t as re } from "./chunks/preset-BjaOuJUL.js";
+import { a as ie, i as ae, n as oe, o as se, r as ce, t as le } from "./chunks/adapters-CMwX_NEI.js";
+import { a as ue, i as de, n as fe, o as pe, r as me, s as he, t as ge } from "./chunks/identity-Bi27FKyx.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, me as assertPipelineResult, O as buildDocument, K as codePlugin, T as collectCustomTags, re as composePresets, U as countSearchMatches, I as createDefaultSlugger, g as createDiagnostic, ge as createMemoKey, he as createOfficialPipeline, fe as createPipelineIdentity, B as createPluginContext, Y as customTagsPlugin, W as defaultPlugins, y as defaultUrlTransform, de as defineMarkdownPipeline, V as defineMarkdownPlugin, te as defineMarkdownPreset, h as errorMessage, d as exportMarkdownHtml, o as exportMarkdownHtmlSync, S as extractToc, w as filterTocByDepth, F as findElementById, R as frontmatterPlugin, q as fullPlugins, i as getComponentManifest, X as gfmPlugin, _ as isExternalUrl, le as isValidDiagnosticFormatter, oe as isValidHighlighter, ce as isValidMathEngine, ae as isValidMermaidRenderer, ie as isValidSlugger, se as isValidUrlTransform, z as linkPlugin, k as memoClear, E as memoGet, j as memoSet, P as memoSize, ee as mergeMarkdownConfig, $ as mergeMarkdownPreset, x as normalizeCustomTagProps, b as normalizeHast, r as partAttrs, c as partClass, p as resolveLabel, ue as resolvePipeline, Z as resolvePlugins, ne as resolvePreset, v as resolveUrl, H as searchDocument, G as searchPlugin, L as segmentSearch, Q as tocPlugin, A as useActiveHeading, N as useMarkdownDocument, e as validateManifest, s as validateManifestRegistry, pe as validatePipeline, J as validatePlugin, C as walkNodes, M as withDerivedDocument, D as withUniqueSlugs };

package/dist/highlight/convert-hast.d.ts

@@ -0,0 +1,8 @@
+import { MarkdownNode } from '../core/types';
+import { hastToMarkdownNodes } from '../core/hast-to-nodes';
+/**
+ * Convert an already-parsed hast subtree into normalized nodes. This path has
+ * no HTML parser dependency, which keeps hast-first adapters such as Shiki
+ * parser-free.
+ */
+export declare function highlightedNodesFromHast(nodes: Parameters<typeof hastToMarkdownNodes>[0]): MarkdownNode[];

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,4 @@
+export { highlightjs } from './highlightjs';
+export { default } from './highlightjs';
+export { highlightedNodesFromHast } from './convert-hast';
+export { clearHighlightCache, plaintextHighlight, runHighlighter, splitHighlightLines, } from './shared';

package/dist/highlight/index.js

@@ -0,0 +1,4 @@
+import { i as e, n as t, r as n, t as r } from "../chunks/shared-NjFDPmkb.js";
+import { t as i } from "../chunks/highlightjs-BxJFpKS1.js";
+import { t as a } from "../chunks/convert-hast-C4Rg2ZuF.js";
+export { r as clearHighlightCache, i as default, i as highlightjs, a as highlightedNodesFromHast, t as plaintextHighlight, n as runHighlighter, e as splitHighlightLines };

package/dist/highlight/shared.d.ts

@@ -0,0 +1,11 @@
+import { HighlightOptions, HighlightResult, MarkdownHighlighter, MarkdownNode } from '../core/types';
+export declare function plaintextHighlight(code: string, language?: string): HighlightResult;
+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,75 @@
+import { t as e } from "../chunks/objectSpread2-CtBNx0TF.js";
+import { t } from "../chunks/asyncToGenerator-ChigusFD.js";
+import { n } from "../chunks/shared-NjFDPmkb.js";
+import { t as r } from "../chunks/convert-hast-C4Rg2ZuF.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 };

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,11 @@
+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 };

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export declare const version = "1.0.1";
+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 './mermaid/plugin';
+export * from './composables/useMarkdownDocument';
+export * from './composables/useActiveHeading';
+export * from './components';