@godxjp/markdown 33.22.1 → 33.24.0

package/dist/codec/index.d.ts

@@ -0,0 +1,37 @@
+import { d as Doc, D as DirectiveBlock, e as DocNode } from '../directive-DqwrNF2I.js';
+export { C as CALLOUT_KINDS, a as COLUMNS_MAX, b as COLUMNS_MIN, c as CalloutKind, M as MODELLED_DIRECTIVES, f as Mark } from '../directive-DqwrNF2I.js';
+
+/**
+ * The parts of a directive block's `source` (a `directive` node's attribute), or `null` when the
+ * text is not exactly one container directive. Pure — a host's editor preview calls it.
+ */
+declare function readDirective(source: string): DirectiveBlock | null;
+/** 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 { CODEC_ID, DirectiveBlock, Doc, DocNode, type OutlineEntry, frontmatterOf, normalize, outline, parse, readDirective, serialize };

package/dist/directive-DqwrNF2I.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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} ·
+ *   directive{name,source} (a container directive the kit does not model: `:::poll[…]{…}`) ·
+ *   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;
+/** Directive names the kit draws itself (grammar v1). A host cannot register a renderer for them. */
+declare const MODELLED_DIRECTIVES: readonly string[];
+
+/**
+ * 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;
+};
+
+export { CALLOUT_KINDS as C, type DirectiveBlock as D, MODELLED_DIRECTIVES as M, COLUMNS_MAX as a, COLUMNS_MIN as b, type CalloutKind as c, type Doc as d, type DocNode as e, type Mark as f };

package/dist/{fixtures-CKcZEUes.d.ts → fixtures-kHqqmyjB.d.ts}

@@ -2,6 +2,7 @@ import * as React from 'react';
 import { Options as Options$1, Components } from 'react-markdown';
 import { Root } from 'hast';
 import { Options } from 'rehype-sanitize';
+import { D as DirectiveBlock, c as CalloutKind } from './directive-DqwrNF2I.js';
 
 /** What a host is told about each heading, in document order. */
 type HeadingInfo = {
@@ -68,30 +69,6 @@ declare function extendSchema(extension?: SchemaExtension): Options;
  */
 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 & {
@@ -243,4 +220,4 @@ type MarkdownFixture = {
 };
 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 };
+export { type DirectiveRenderProps as D, type HeadingIdResolver as H, MARKDOWN_FIXTURES as M, RENDERER_VERSION as R, type SchemaExtension as S, type DirectiveRenderer as a, type HeadingInfo as b, MARKDOWN_FORMAT as c, type MarkdownFixture as d, type MarkdownProps as e, MermaidDiagram as f, type MermaidDiagramProps as g, type MermaidSvgCheck as h, checkMermaidSvg as i, extendSchema as j, markdownSchema as m, rehypeHeadingIds as r, safeUrl as s };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 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 { e as MarkdownProps } from './fixtures-kHqqmyjB.js';
+export { D as DirectiveRenderProps, a as DirectiveRenderer, H as HeadingIdResolver, b as HeadingInfo, M as MARKDOWN_FIXTURES, c as MARKDOWN_FORMAT, d as MarkdownFixture, f as MermaidDiagram, g as MermaidDiagramProps, h as MermaidSvgCheck, R as RENDERER_VERSION, S as SchemaExtension, i as checkMermaidSvg, j as extendSchema, m as markdownSchema, r as rehypeHeadingIds, s as safeUrl } from './fixtures-kHqqmyjB.js';
+export { D as DirectiveBlock } from './directive-DqwrNF2I.js';
 import 'react-markdown';
 import 'hast';
 import 'rehype-sanitize';

package/dist/lazy.d.ts

@@ -1,6 +1,7 @@
 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 { e as MarkdownProps } from './fixtures-kHqqmyjB.js';
+export { D as DirectiveRenderProps, a as DirectiveRenderer, H as HeadingIdResolver, b as HeadingInfo, M as MARKDOWN_FIXTURES, c as MARKDOWN_FORMAT, d as MarkdownFixture, f as MermaidDiagram, g as MermaidDiagramProps, h as MermaidSvgCheck, R as RENDERER_VERSION, S as SchemaExtension, i as checkMermaidSvg, j as extendSchema, m as markdownSchema, r as rehypeHeadingIds, s as safeUrl } from './fixtures-kHqqmyjB.js';
+export { D as DirectiveBlock } from './directive-DqwrNF2I.js';
 import 'react-markdown';
 import 'hast';
 import 'rehype-sanitize';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@godxjp/markdown",
-  "version": "33.22.1",
+  "version": "33.24.0",
   "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",