@godxjp/markdown 33.21.0 → 33.22.1

package/dist/katex-styles-JVRNFDYG.js

@@ -0,0 +1,4 @@
+"use client";
+
+// src/katex-styles.ts
+import "../katex.css";

package/dist/lazy.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { f as MarkdownProps } from './fixtures-CKcZEUes.js';
+export { D as DirectiveBlock, a as DirectiveRenderProps, b as DirectiveRenderer, H as HeadingIdResolver, c as HeadingInfo, M as MARKDOWN_FIXTURES, d as MARKDOWN_FORMAT, e as MarkdownFixture, g as MermaidDiagram, h as MermaidDiagramProps, i as MermaidSvgCheck, R as RENDERER_VERSION, S as SchemaExtension, j as checkMermaidSvg, k as extendSchema, m as markdownSchema, r as rehypeHeadingIds, s as safeUrl } from './fixtures-CKcZEUes.js';
+import 'react-markdown';
+import 'hast';
+import 'rehype-sanitize';
+
+/**
+ * Loads the engines a body needs (both when `markdown` is omitted). Await it before a server
+ * render or a hydration that must match the eager entry's HTML.
+ */
+declare function preloadMarkdownRuntime(markdown?: string): Promise<void>;
+/** `<Markdown>` with its engines loaded on demand (see the module comment). Same props. */
+declare function Markdown(props: MarkdownProps): React.JSX.Element;
+
+export { Markdown, MarkdownProps, preloadMarkdownRuntime };

package/dist/lazy.js

@@ -0,0 +1,126 @@
+"use client";
+import {
+  MARKDOWN_FIXTURES,
+  MARKDOWN_FORMAT,
+  MarkdownCore,
+  MermaidDiagram,
+  RENDERER_VERSION,
+  checkMermaidSvg,
+  extendSchema,
+  fromMarkdownExtensions,
+  markdownSchema,
+  micromarkExtensions,
+  rehypeHeadingIds,
+  safeUrl
+} from "./chunk-RRNN4HLQ.js";
+import "./chunk-ANYWBQJT.js";
+import "./chunk-AKKOCR2Y.js";
+
+// src/lazy.tsx
+import * as React from "react";
+
+// src/codec/parse.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+function parseMdast(markdown) {
+  return fromMarkdown(markdown, {
+    extensions: micromarkExtensions(),
+    mdastExtensions: fromMarkdownExtensions()
+  });
+}
+
+// src/lazy.tsx
+import { jsx } from "react/jsx-runtime";
+var loaded = {};
+var mathLoad;
+var highlightLoad;
+function loadMath() {
+  mathLoad ??= Promise.all([
+    import("./math-DOI7WLLZ.js"),
+    // The stylesheet only where there is a document to style (a server has none, and cannot
+    // import CSS).
+    typeof document === "undefined" ? void 0 : import("./katex-styles-JVRNFDYG.js")
+  ]).then(
+    ([math]) => {
+      loaded.math = math.rehypeMath;
+    },
+    (error) => {
+      mathLoad = void 0;
+      throw error;
+    }
+  );
+  return mathLoad;
+}
+function loadHighlight() {
+  highlightLoad ??= import("./highlight-TYIW3L3V.js").then(
+    (highlight) => {
+      loaded.highlight = highlight.rehypeHighlight;
+    },
+    (error) => {
+      highlightLoad = void 0;
+      throw error;
+    }
+  );
+  return highlightLoad;
+}
+function needsOf(tree) {
+  const needs = { math: false, highlight: false };
+  const walk = (node) => {
+    if (node.type === "inlineMath" || node.type === "math") needs.math = true;
+    else if (node.type === "code" && node.lang) {
+      if (node.lang === "math") needs.math = true;
+      else if (node.lang !== "mermaid") needs.highlight = true;
+    }
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(tree);
+  return needs;
+}
+function preloadMarkdownRuntime(markdown) {
+  const needs = markdown === void 0 ? { math: true, highlight: true } : needsOf(parseMdast(markdown));
+  return Promise.all([
+    needs.math ? loadMath() : void 0,
+    needs.highlight ? loadHighlight() : void 0
+  ]).then(() => void 0);
+}
+function Markdown(props) {
+  const needs = React.useRef({ math: false, highlight: false });
+  const [, rerender] = React.useReducer((n) => n + 1, 0);
+  const probe = React.useMemo(
+    () => () => (tree) => {
+      needs.current = needsOf(tree);
+    },
+    []
+  );
+  const highlight = props.highlight !== false;
+  React.useEffect(() => {
+    const pending = [
+      needs.current.math && !loaded.math ? loadMath() : void 0,
+      highlight && needs.current.highlight && !loaded.highlight ? loadHighlight() : void 0
+    ].filter(Boolean);
+    if (pending.length === 0) return;
+    let mounted = true;
+    Promise.all(pending).then(
+      () => mounted && rerender(),
+      () => void 0
+      // the fallback stays: a body without colour is still the body
+    );
+    return () => {
+      mounted = false;
+    };
+  });
+  return /* @__PURE__ */ jsx(MarkdownCore, { ...props, runtime: { math: loaded.math, highlight: loaded.highlight, probe } });
+}
+export {
+  MARKDOWN_FIXTURES,
+  MARKDOWN_FORMAT,
+  Markdown,
+  MermaidDiagram,
+  RENDERER_VERSION,
+  checkMermaidSvg,
+  extendSchema,
+  markdownSchema,
+  preloadMarkdownRuntime,
+  rehypeHeadingIds,
+  safeUrl
+};

package/dist/math-DOI7WLLZ.js

@@ -0,0 +1,13 @@
+"use client";
+import {
+  rehypeMath
+} from "./chunk-JJ2A3D7U.js";
+import {
+  KATEX_OPTIONS,
+  katexSchema
+} from "./chunk-AKKOCR2Y.js";
+export {
+  KATEX_OPTIONS,
+  katexSchema,
+  rehypeMath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@godxjp/markdown",
-  "version": "33.21.0",
+  "version": "33.22.1",
   "description": "The one Markdown renderer for GoDX apps: GFM + heading anchors, KaTeX math, highlighted code, one sanitiser schema, a shared fixture corpus, and Mermaid drawn only after its SVG passes a fail-closed gate.",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./lazy": {
+      "types": "./dist/lazy.d.ts",
+      "import": "./dist/lazy.js"
+    },
     "./codec": {
       "types": "./dist/codec/index.d.ts",
       "import": "./dist/codec/index.js"
@@ -19,7 +23,8 @@
     "./package.json": "./package.json"
   },
   "sideEffects": [
-    "*.css"
+    "*.css",
+    "./dist/katex-styles-*.js"
   ],
   "files": [
     "dist",

package/dist/codec/index.d.ts

@@ -1,71 +0,0 @@
-/**
- * The codec's document: plain JSON in the ProseMirror/Tiptap shape (`type` / `attrs` / `content` /
- * `text` / `marks`), so `@godxjp/block-editor` loads it with `setContent` and hands back what
- * `getJSON()` returns. No DOM, no editor instance — this module runs in a Worker (gh#1156).
- *
- * Node names follow Tiptap's StarterKit / Table / Details extensions where one exists:
- *   doc · paragraph · heading{level} · blockquote · codeBlock{language} · horizontalRule ·
- *   bulletList{tight} · orderedList{start,tight} · listItem · taskList{tight} · taskItem{checked} ·
- *   table · tableRow · tableHeader{align} · tableCell{align} · image{src,alt,title} · hardBreak
- * and the kit's own:
- *   callout{kind,title} · details · detailsSummary · detailsContent · columns · column{width} ·
- *   embed{target} (block `![[x]]`) · wikilink{target,heading,label} · embedInline{target} ·
- *   rawBlock{source} · rawInline{source} · frontmatter{source} (YAML, first block only)
- * Marks: bold · italic · strike · code · link{href,title}.
- */
-type Mark = {
-    type: "bold" | "italic" | "strike" | "code";
-} | {
-    type: "link";
-    attrs: {
-        href: string;
-        title: string | null;
-    };
-};
-type DocNode = {
-    type: string;
-    attrs?: Record<string, unknown>;
-    content?: DocNode[];
-    text?: string;
-    marks?: Mark[];
-};
-type Doc = DocNode & {
-    type: "doc";
-    content: DocNode[];
-};
-/** 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];
-/** Columns per `:::columns` block (grammar v1). */
-declare const COLUMNS_MIN = 2;
-declare const COLUMNS_MAX = 4;
-
-/** Markdown → document (plain JSON, ProseMirror/Tiptap shape). Pure: no DOM. */
-declare function parse(markdown: string): Doc;
-
-type OutlineEntry = {
-    depth: number;
-    text: string;
-    id: string;
-};
-/**
- * The body's headings with the ids `<Markdown>` gives them — GitHub slugs, de-duplicated in
- * document order, the renderer's default rule — for a table of contents (the kit's `Anchor`). Pure.
- * A host that passes its own `headingId` resolver to `<Markdown>` must use that same resolver here.
- */
-declare function outline(markdown: string): OutlineEntry[];
-/** The body's YAML front matter, verbatim (without the `---` fences), or null. Parse it with your YAML library. */
-declare function frontmatterOf(markdown: string): string | null;
-
-/** Document → canonical Markdown. Pure: no DOM. */
-declare function serialize(doc: Doc | DocNode): string;
-
-/**
- * Identifies the serializer's output. Bumped whenever `serialize` would write a stored body
- * differently, so a host can tell which normalization a saved `normalized_body` came from.
- */
-declare const CODEC_ID = "kit-md@2";
-/** `serialize(parse(markdown))` — the canonical form of a body, exactly what the editor saves. */
-declare function normalize(markdown: string): string;
-
-export { CALLOUT_KINDS, CODEC_ID, COLUMNS_MAX, COLUMNS_MIN, type CalloutKind, type Doc, type DocNode, type Mark, type OutlineEntry, frontmatterOf, normalize, outline, parse, serialize };