@godxjp/markdown 33.21.0 → 33.22.1

package/dist/chunk-XXBFDQOW.js

@@ -0,0 +1,118 @@
+"use client";
+
+// src/highlight.ts
+import { createLowlight } from "lowlight";
+import bash from "highlight.js/lib/languages/bash";
+import css from "highlight.js/lib/languages/css";
+import diff from "highlight.js/lib/languages/diff";
+import dockerfile from "highlight.js/lib/languages/dockerfile";
+import go from "highlight.js/lib/languages/go";
+import ini from "highlight.js/lib/languages/ini";
+import java from "highlight.js/lib/languages/java";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import markdown from "highlight.js/lib/languages/markdown";
+import php from "highlight.js/lib/languages/php";
+import python from "highlight.js/lib/languages/python";
+import rust from "highlight.js/lib/languages/rust";
+import shell from "highlight.js/lib/languages/shell";
+import sql from "highlight.js/lib/languages/sql";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+import yaml from "highlight.js/lib/languages/yaml";
+import { visit } from "unist-util-visit";
+var lowlight = createLowlight({
+  bash,
+  css,
+  diff,
+  dockerfile,
+  go,
+  ini,
+  java,
+  javascript,
+  json,
+  markdown,
+  php,
+  python,
+  rust,
+  shell,
+  sql,
+  typescript,
+  xml,
+  yaml
+});
+var SCOPES = {
+  comment: "comment",
+  quote: "comment",
+  doctag: "keyword",
+  keyword: "keyword",
+  built_in: "keyword",
+  type: "keyword",
+  "selector-tag": "keyword",
+  tag: "punctuation",
+  name: "keyword",
+  section: "keyword",
+  string: "string",
+  char: "string",
+  regexp: "string-expression",
+  subst: "string-expression",
+  "template-variable": "string-expression",
+  "title.function": "function",
+  title: "function",
+  "title.class": "constant",
+  number: "constant",
+  literal: "constant",
+  symbol: "constant",
+  "variable.constant": "constant",
+  "variable.language": "constant",
+  "selector-id": "constant",
+  "selector-class": "constant",
+  bullet: "constant",
+  params: "parameter",
+  attr: "parameter",
+  attribute: "parameter",
+  property: "parameter",
+  "template-tag": "parameter",
+  punctuation: "punctuation",
+  operator: "punctuation",
+  link: "link",
+  addition: "inserted",
+  deletion: "deleted"
+};
+function tokenOf(className) {
+  if (!Array.isArray(className) || !String(className[0]).startsWith("hljs-")) return void 0;
+  const parts = className.map(
+    (name, i) => i === 0 ? String(name).slice(5) : String(name).replace(/_+$/, "")
+  );
+  for (let n = parts.length; n > 0; n--) {
+    const token = SCOPES[parts.slice(0, n).join(".")];
+    if (token) return token;
+  }
+  return void 0;
+}
+function retag(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.type !== "element") return [node];
+    const children = retag(node.children);
+    const token = tokenOf(node.properties?.className);
+    return token ? [{ type: "element", tagName: "span", properties: { dataCodeToken: token }, children }] : children;
+  });
+}
+var SKIP = /* @__PURE__ */ new Set(["mermaid", "math"]);
+function rehypeHighlight() {
+  return (tree) => {
+    visit(tree, "element", (node, _index, parent) => {
+      if (node.tagName !== "code" || parent?.type !== "element" || parent.tagName !== "pre") return;
+      const classes = node.properties?.className ?? [];
+      const language = classes.find((name) => name.startsWith("language-"))?.slice(9);
+      if (!language || SKIP.has(language) || !lowlight.registered(language)) return;
+      if (!node.children.every((child) => child.type === "text")) return;
+      const text = node.children.map((child) => child.type === "text" ? child.value : "").join("");
+      node.children = retag(lowlight.highlight(language, text).children);
+    });
+  };
+}
+
+export {
+  rehypeHighlight
+};

package/dist/codec/index.js

@@ -1,73 +1,15 @@
 // src/codec/parse.ts
 import { fromMarkdown } from "mdast-util-from-markdown";
-import { toMarkdown } from "mdast-util-to-markdown";
+import { toMarkdown as toMarkdown2 } from "mdast-util-to-markdown";
 
 // src/codec/model.ts
 var CALLOUT_KINDS = ["note", "tip", "important", "warning", "caution"];
 var COLUMNS_MIN = 2;
 var COLUMNS_MAX = 4;
+var MODELLED_DIRECTIVES = ["toggle", "columns", "column"];
 
-// src/codec/readers.ts
-var CALLOUT = /^\[!([A-Za-z]+)\](?:[ \t]+([^\n]*))?$/;
-function readCallout(node) {
-  const [first, ...rest] = node.children;
-  if (first?.type !== "paragraph") return null;
-  const [head, ...tail] = first.children;
-  if (head?.type !== "text") return null;
-  const newline = head.value.indexOf("\n");
-  if (newline === -1 && tail.length > 0) return null;
-  const line = newline === -1 ? head.value : head.value.slice(0, newline);
-  const match = CALLOUT.exec(line);
-  const kind = match?.[1]?.toLowerCase();
-  if (!match || !kind || !CALLOUT_KINDS.includes(kind)) return null;
-  const remainder = [
-    ...newline === -1 ? [] : [{ ...head, value: head.value.slice(newline + 1) }],
-    ...tail
-  ].filter((n) => !(n.type === "text" && n.value === ""));
-  return {
-    kind,
-    title: match[2]?.trim() || null,
-    body: [
-      ...remainder.length ? [{ type: "paragraph", children: remainder }] : [],
-      ...rest
-    ]
-  };
-}
-function labelOf(node) {
-  const first = node.children[0];
-  return first?.type === "paragraph" && first.data?.directiveLabel ? first : null;
-}
-function readToggle(node) {
-  if (node.name !== "toggle" || Object.keys(node.attributes ?? {}).length > 0) return null;
-  const label = labelOf(node);
-  return {
-    summary: label?.children ?? [],
-    body: label ? node.children.slice(1) : node.children
-  };
-}
-function readColumns(node, nested) {
-  if (node.name !== "columns" || nested || labelOf(node) || Object.keys(node.attributes ?? {}).length) {
-    return null;
-  }
-  const columns = node.children;
-  if (columns.length < COLUMNS_MIN || columns.length > COLUMNS_MAX) return null;
-  const parts = [];
-  for (const column of columns) {
-    if (column.type !== "containerDirective" || column.name !== "column" || labelOf(column))
-      return null;
-    const attributes = Object.entries(column.attributes ?? {});
-    if (attributes.length > 1) return null;
-    let width = null;
-    if (attributes.length === 1) {
-      const [key, value] = attributes[0];
-      if (key !== "width" || typeof value !== "string" || !/^(?:[1-9]\d?|100)$/.test(value))
-        return null;
-      width = Number(value);
-    }
-    parts.push({ width, body: column.children });
-  }
-  return parts;
-}
+// src/codec/directive.ts
+import { toMarkdown } from "mdast-util-to-markdown";
 
 // src/codec/syntax.ts
 import { directive } from "micromark-extension-directive";
@@ -186,6 +128,87 @@ function toMarkdownOptions() {
   };
 }
 
+// src/codec/directive.ts
+var markdownOf = (node) => toMarkdown(node, toMarkdownOptions()).replace(/\n+$/, "");
+function directiveParts(node) {
+  const [first, ...rest] = node.children;
+  const hasLabel = first?.type === "paragraph" && Boolean(first.data?.directiveLabel);
+  const attributes = {};
+  for (const [key, value] of Object.entries(node.attributes ?? {})) attributes[key] = value ?? "";
+  return {
+    name: node.name,
+    label: hasLabel ? markdownOf({ type: "paragraph", children: first.children }) : null,
+    attributes,
+    source: markdownOf(node),
+    body: markdownOf({
+      type: "root",
+      children: hasLabel ? rest : node.children
+    })
+  };
+}
+
+// src/codec/readers.ts
+var CALLOUT = /^\[!([A-Za-z]+)\](?:[ \t]+([^\n]*))?$/;
+function readCallout(node) {
+  const [first, ...rest] = node.children;
+  if (first?.type !== "paragraph") return null;
+  const [head, ...tail] = first.children;
+  if (head?.type !== "text") return null;
+  const newline = head.value.indexOf("\n");
+  if (newline === -1 && tail.length > 0) return null;
+  const line = newline === -1 ? head.value : head.value.slice(0, newline);
+  const match = CALLOUT.exec(line);
+  const kind = match?.[1]?.toLowerCase();
+  if (!match || !kind || !CALLOUT_KINDS.includes(kind)) return null;
+  const remainder = [
+    ...newline === -1 ? [] : [{ ...head, value: head.value.slice(newline + 1) }],
+    ...tail
+  ].filter((n) => !(n.type === "text" && n.value === ""));
+  return {
+    kind,
+    title: match[2]?.trim() || null,
+    body: [
+      ...remainder.length ? [{ type: "paragraph", children: remainder }] : [],
+      ...rest
+    ]
+  };
+}
+function labelOf(node) {
+  const first = node.children[0];
+  return first?.type === "paragraph" && first.data?.directiveLabel ? first : null;
+}
+function readToggle(node) {
+  if (node.name !== "toggle" || Object.keys(node.attributes ?? {}).length > 0) return null;
+  const label = labelOf(node);
+  return {
+    summary: label?.children ?? [],
+    body: label ? node.children.slice(1) : node.children
+  };
+}
+function readColumns(node, nested) {
+  if (node.name !== "columns" || nested || labelOf(node) || Object.keys(node.attributes ?? {}).length) {
+    return null;
+  }
+  const columns = node.children;
+  if (columns.length < COLUMNS_MIN || columns.length > COLUMNS_MAX) return null;
+  const parts = [];
+  for (const column of columns) {
+    if (column.type !== "containerDirective" || column.name !== "column" || labelOf(column))
+      return null;
+    const attributes = Object.entries(column.attributes ?? {});
+    if (attributes.length > 1) return null;
+    let width = null;
+    if (attributes.length === 1) {
+      const [key, value] = attributes[0];
+      if (key !== "width" || typeof value !== "string" || !/^(?:[1-9]\d?|100)$/.test(value))
+        return null;
+      width = Number(value);
+    }
+    parts.push({ width, body: column.children });
+  }
+  return parts;
+}
+
 // src/codec/parse.ts
 var WIKILINK = /!\[\[([^[\]\n]+)\]\]|\[\[([^[\]\n|#]+)(?:#([^[\]\n|]+))?(?:\|([^[\]\n]+))?\]\]/g;
 function parseMdast(markdown) {
@@ -195,7 +218,7 @@ function parseMdast(markdown) {
   });
 }
 function raw(node, inline2) {
-  const source = node.type === "html" ? node.value : toMarkdown(node, toMarkdownOptions()).replace(/\n+$/, "");
+  const source = node.type === "html" ? node.value : toMarkdown2(node, toMarkdownOptions()).replace(/\n+$/, "");
   return { type: inline2 ? "rawInline" : "rawBlock", attrs: { source } };
 }
 function withMark(marks, mark) {
@@ -342,7 +365,12 @@ function directiveBlock(node, depth) {
       }))
     };
   }
-  return raw(node, false);
+  if (MODELLED_DIRECTIVES.includes(node.name)) return raw(node, false);
+  return { type: "directive", attrs: { name: node.name, source: directiveParts(node).source } };
+}
+function readDirective(source) {
+  const [only, ...rest] = parseMdast(source.replace(/\r\n?/g, "\n")).children;
+  return only?.type === "containerDirective" && rest.length === 0 ? directiveParts(only) : null;
 }
 function nonEmpty(content2) {
   return content2.length ? content2 : [{ type: "paragraph" }];
@@ -421,7 +449,7 @@ function parse(markdown) {
 }
 
 // src/codec/serialize.ts
-import { toMarkdown as toMarkdown2 } from "mdast-util-to-markdown";
+import { toMarkdown as toMarkdown3 } from "mdast-util-to-markdown";
 var MARK_RANK = ["link", "bold", "italic", "strike"];
 var hasMark = (node, type) => node.marks?.some((m) => m.type === type) ?? false;
 var linkOf = (node) => node.marks?.find((m) => m.type === "link");
@@ -601,6 +629,7 @@ function block2(node) {
     case "embed":
       return [{ type: "html", value: `![[${String(attrs.target)}]]` }];
     case "rawBlock":
+    case "directive":
       return [{ type: "html", value: String(attrs.source) }];
     case "frontmatter":
       return [{ type: "yaml", value: String(attrs.source) }];
@@ -635,7 +664,7 @@ function decodeDollarEscapes(markdown) {
 }
 function serialize(doc) {
   const root = { type: "root", children: flow(doc.content ?? []) };
-  const markdown = toMarkdown2(root, toMarkdownOptions());
+  const markdown = toMarkdown3(root, toMarkdownOptions());
   if (markdown.trim() === "") return "";
   const tidy = markdown.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").replace(/\n+$/, "\n");
   return decodeDollarEscapes(decodeAttentionReferences(tidy));
@@ -675,9 +704,11 @@ export {
   CODEC_ID,
   COLUMNS_MAX,
   COLUMNS_MIN,
+  MODELLED_DIRECTIVES,
   frontmatterOf,
   normalize,
   outline,
   parse,
+  readDirective,
   serialize
 };

package/dist/fixtures-CKcZEUes.d.ts

@@ -0,0 +1,246 @@
+import * as React from 'react';
+import { Options as Options$1, Components } from 'react-markdown';
+import { Root } from 'hast';
+import { Options } from 'rehype-sanitize';
+
+/** What a host is told about each heading, in document order. */
+type HeadingInfo = {
+    depth: number;
+    text: string;
+    index: number;
+};
+/**
+ * Chooses a heading's anchor. Return `undefined` to give the heading no id.
+ *
+ * The default is GitHub's slug (`github-slugger`, the same rule `rehype-slug` uses), de-duplicated
+ * in document order (`a`, `a-1`, `a-2`). A host whose server already assigned anchors (godx-task
+ * keeps its outline server-side, so a link and the page agree) passes its own: computing "the same"
+ * slug in two languages is one rule written twice, and it drifts.
+ */
+type HeadingIdResolver = (heading: HeadingInfo) => string | undefined;
+/** rehype plugin: an `id` on every heading. Runs BEFORE the sanitiser, which allows `id` on h1–h6. */
+declare function rehypeHeadingIds(options?: {
+    resolve?: HeadingIdResolver;
+}): (tree: Root) => void;
+
+/**
+ * THE ONE SANITISER SCHEMA (gh#1108). godx-task and godx-content each carried their own copy of
+ * this; every consumer now renders through this one, so a policy change happens once.
+ *
+ * Built on `rehype-sanitize`'s `defaultSchema` (GitHub's), with three deliberate changes:
+ *
+ * - `clobberPrefix: ""`. The default re-prefixes every `id`, but remark-gfm already writes footnote
+ *   ids and their `href`s as a matched `user-content-` pair, so the second prefix split the pair and
+ *   footnote links went nowhere (measured in godx-task). The clobber exists to stop a body minting
+ *   an id that collides with the host's; this renderer never parses raw HTML (no `rehype-raw`), so
+ *   the only ids in the tree are the ones the pipeline generated. `raw-html.test` pins that.
+ * - `protocols`: links and images allow only `http`, `https`, `mailto` (links) and relative URLs.
+ *   `javascript:`, `data:`, `vbscript:` and every other scheme are dropped.
+ * - Task-list checkboxes stay `disabled` (the default): ticking one would be a write to the body.
+ * - KaTeX's output (math.ts `katexSchema`: MathML, its own classes, geometry-only inline styles,
+ *   `svg` paths for radicals and stretchy arrows) and the code tokens (`data-code-token`, the kit's
+ *   twelve names) — both produced by the pipeline before this schema judges them (renderer v6).
+ *
+ * Hosts extend it with `extendSchema`, never by editing a copy.
+ */
+declare const markdownSchema: Options;
+/** Extra tags / attributes a host needs (a callout marker, a section element). Additive only. */
+type SchemaExtension = {
+    tagNames?: string[];
+    attributes?: Record<string, NonNullable<Options["attributes"]>[string]>;
+};
+/**
+ * The schema plus a host's additions. ADDITIVE: an extension can allow a tag or an attribute, never
+ * widen `protocols` or bring raw HTML back, so a consumer cannot loosen the URL policy by accident.
+ *
+ * A rule for an attribute the base ALREADY constrains is MERGED into that rule (gh#1116): the
+ * sanitiser reads the first rule it finds for an attribute, so appending `["className",
+ * "math-inline"]` beside the default `["className", /^language-./]` was silently ignored and the
+ * formula class stripped. Merged, it is one rule allowing both. An attribute the base allows with
+ * no value constraint stays unconstrained.
+ */
+declare function extendSchema(extension?: SchemaExtension): Options;
+/**
+ * react-markdown's `urlTransform`, with the same allow-list as the schema, so a URL is checked
+ * where it is written as well as where it is sanitised. Relative URLs (`/x`, `x`, `#a`, `?q`) pass;
+ * a scheme outside the list becomes `""`. A host scheme such as `asset:` is resolved by the host's
+ * `resolveUrl` BEFORE this check, so it can only turn into an allowed URL or be dropped.
+ */
+declare function safeUrl(url: string, key: string): string;
+
+/** GitHub alert kinds, the only callouts v1 knows. Serialized uppercase. */
+declare const CALLOUT_KINDS: readonly ["note", "tip", "important", "warning", "caution"];
+type CalloutKind = (typeof CALLOUT_KINDS)[number];
+
+/**
+ * DIRECTIVE BLOCKS: a container directive the kit does not model itself (`:::poll[…]{…}`,
+ * `::::form`), read once so the codec, the renderer and the block editor hand a host the same
+ * parts. Here everything is the CANONICAL Markdown the codec writes (what the editor saves);
+ * `<Markdown directives>` slices the same parts from the body as written, which is the same text for
+ * a body the editor saved.
+ */
+type DirectiveBlock = {
+    /** The directive's name: `poll` for `:::poll`. */
+    name: string;
+    /** The `[label]` as inline Markdown, or `null` when the directive has none. */
+    label: string | null;
+    /** The `{…}` attributes; a bare flag (`{anonymous}`) is `""`, `{#x}` is `id`, `{.x}` is `class`. */
+    attributes: Record<string, string>;
+    /** The whole directive, fences included: canonical from the codec, as written from `<Markdown>`. */
+    source: string;
+    /** The content between the fences (without the label) as Markdown; `""` when empty. */
+    body: string;
+};
+
+type PluggableList = NonNullable<Options$1["remarkPlugins"]>;
+/** What a host's directive renderer receives: the block's parts plus its content, already rendered. */
+type DirectiveRenderProps = DirectiveBlock & {
+    /** The body as the renderer draws it (the label excluded) — a `::::form`'s `:::poll` cards. */
+    children: React.ReactNode;
+};
+/**
+ * Draws one container directive (`:::poll[…]{…}`). Return `undefined` to leave the block as the
+ * kit renders an unknown directive (its content in a `div.ui-prose-directive`) — a block the host
+ * judges invalid. Called during render: return elements, call no hooks here.
+ */
+type DirectiveRenderer = (block: DirectiveRenderProps) => React.ReactNode | undefined;
+/**
+ * The stored body's format, and the renderer generation that produced its output. A consumer
+ * records both on every saved version (content-media contracts § 6.6) and never re-interprets an
+ * old version under a different format. `RENDERER_VERSION` moves when the SAME input renders
+ * differently — a schema change, a new default plugin — not on every release.
+ */
+declare const MARKDOWN_FORMAT = "md";
+declare const RENDERER_VERSION = 6;
+type MarkdownProps = {
+    /** The Markdown source. */
+    children: string;
+    /**
+     * remark plugins run after GFM (a callout or embed marker plugin). Whatever they emit still goes
+     * through the sanitiser, so a marker attribute must be allowed with `schema`.
+     */
+    remarkPlugins?: PluggableList;
+    /**
+     * rehype plugins run AFTER the sanitiser, on a tree that is already safe. Presentation only: a
+     * plugin here must not introduce URLs, raw HTML or event handlers — it is past the gate.
+     */
+    rehypePlugins?: PluggableList;
+    /** Tags / attributes a host plugin needs. Additive; cannot widen the URL policy. */
+    schema?: SchemaExtension;
+    /**
+     * Element overrides (react-markdown `components`). A host `pre` renders every fence EXCEPT
+     * ```mermaid, which is drawn through the gate first; `mermaid={false}` hands those to it too.
+     */
+    components?: Components;
+    /**
+     * Resolves a host-specific URL (`asset:…`, a wiki link) to a real one. Runs before the sanitiser
+     * and the scheme allow-list, so whatever it returns is still checked; `undefined` keeps the URL.
+     */
+    resolveUrl?: (url: string, key: "href" | "src" | string) => string | undefined;
+    /** Heading anchors: GitHub slugs by default; a host with server-side anchors supplies its own. */
+    headingId?: HeadingIdResolver;
+    /**
+     * Render ```mermaid fences as gated diagrams (default true). They are drawn BEFORE a host `pre`
+     * is consulted, so a host code renderer keeps Mermaid; `false` hands mermaid fences to the host
+     * `pre` (or plain code) as well (gh#1116).
+     */
+    mermaid?: boolean;
+    /**
+     * Tokenise fenced code in a known language as `<span data-code-token="keyword">` … (default
+     * true), which `Prose` colours. `false` leaves the code as plain text — a host `pre` that runs
+     * its own highlighter.
+     */
+    highlight?: boolean;
+    /**
+     * NARROW the elements a body may produce — an activity feed that shows only inline formatting.
+     * react-markdown's own options, applied after the sanitiser; they can only remove, never allow
+     * what the schema strips (gh#1116).
+     */
+    allowedElements?: Options$1["allowedElements"];
+    disallowedElements?: Options$1["disallowedElements"];
+    allowElement?: Options$1["allowElement"];
+    /** With an element filter: keep a removed element's children (its text) instead of dropping it. */
+    unwrapDisallowed?: boolean;
+    /**
+     * A table cell whose trimmed text has no whitespace and at most this many characters — a code,
+     * an id, a date, 優先度 — is stamped `data-short`, and `Prose` keeps it on one line: CJK otherwise
+     * breaks between any two ideographs in a narrow column (gh#1150). A sentence still wraps.
+     * Characters are user-perceived (grapheme clusters). Default 24; `false` stamps nothing.
+     */
+    shortCellLength?: number | false;
+    /**
+     * Visible callout titles per kind when a callout has none of its own (`> [!WARNING]`). English by
+     * default — this package carries no i18n; a host passes its localized strings.
+     */
+    calloutTitles?: Partial<Record<CalloutKind, string>>;
+    /**
+     * Where an EXTERNAL link opens. An external link is an absolute http(s) URL whose origin differs
+     * from `origin`. `"new-tab"` gives it `target="_blank"` and `rel="noopener noreferrer"`. Relative
+     * links, `#anchors`, wikilinks resolved to a path, and `mailto:` stay in the tab. The default,
+     * `"same-tab"`, changes nothing. Markdown has no syntax for `target`, so this is a renderer policy.
+     */
+    externalLinks?: "same-tab" | "new-tab";
+    /**
+     * The page origin that `externalLinks` compares against. Defaults to `location.origin`. Pass it
+     * when rendering on the server, or every absolute link counts as external there and hydration
+     * disagrees on same-origin ones.
+     */
+    origin?: string;
+    /**
+     * Host renderers for container directives the kit does not model, by name:
+     * `{ poll: (block) => <PollCard … /> }`. Each receives the directive's name, label, attributes,
+     * canonical source and body Markdown (`DirectiveBlock`, the same parts the codec and the block
+     * editor give) and its rendered content. A directive without a renderer renders as before.
+     * `toggle`, `columns` and `column` are the kit's own and cannot be overridden.
+     */
+    directives?: Readonly<Record<string, DirectiveRenderer>>;
+};
+
+type MermaidSvgCheck = {
+    ok: true;
+    svg: SVGSVGElement;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Parses `svg` as XML and checks every element and attribute. On success returns the PARSED root,
+ * which the caller inserts as a node — never re-serialised into HTML, so what was checked is what
+ * is shown (an HTML re-parse of an SVG string can differ from the XML parse: mutation XSS).
+ */
+declare function checkMermaidSvg(svg: string): MermaidSvgCheck;
+type MermaidDiagramProps = {
+    /** The fence's text. */
+    source: string;
+    /** Accessible name of the rendered diagram (the figure). */
+    label?: string;
+};
+/**
+ * A ```mermaid fence. Shows the code until the diagram has rendered AND passed `checkMermaidSvg`,
+ * and keeps showing it if either fails — so the page is never blank and never unsafe.
+ */
+declare function MermaidDiagram({ source, label }: MermaidDiagramProps): React.JSX.Element;
+
+/**
+ * THE SHARED FIXTURE CORPUS (gh#1108). Input Markdown → the exact sanitised HTML this renderer
+ * produces with its defaults. Browser, server and export paths (a PHP exporter included) conform to
+ * these rather than to each other: "same output" is checked against one list, not argued about.
+ *
+ * `hostile` fixtures carry an attack; `forbidden` lists substrings that must never appear in their
+ * output, so a schema change that re-opens one fails even if somebody re-blesses the HTML.
+ *
+ * Changing an expected `html` for an existing input is a renderer change: bump `RENDERER_VERSION`.
+ *
+ * The HTML is the renderer's, not React's: compare after removing the `<link rel="preload">` React's
+ * static renderer adds for each image (`normalizeFixtureHtml` in the tests).
+ */
+type MarkdownFixture = {
+    name: string;
+    markdown: string;
+    html: string;
+    hostile?: boolean;
+    forbidden?: string[];
+};
+declare const MARKDOWN_FIXTURES: MarkdownFixture[];
+
+export { type DirectiveBlock as D, type HeadingIdResolver as H, MARKDOWN_FIXTURES as M, RENDERER_VERSION as R, type SchemaExtension as S, type DirectiveRenderProps as a, type DirectiveRenderer as b, type HeadingInfo as c, MARKDOWN_FORMAT as d, type MarkdownFixture as e, type MarkdownProps as f, MermaidDiagram as g, type MermaidDiagramProps as h, type MermaidSvgCheck as i, checkMermaidSvg as j, extendSchema as k, markdownSchema as m, rehypeHeadingIds as r, safeUrl as s };

package/dist/highlight-TYIW3L3V.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  rehypeHighlight
+} from "./chunk-XXBFDQOW.js";
+import {
+  CODE_TOKENS
+} from "./chunk-ANYWBQJT.js";
+export {
+  CODE_TOKENS,
+  rehypeHighlight
+};