@godxjp/markdown 33.21.0 → 33.22.2

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.d.ts

@@ -1,45 +1,11 @@
+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 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}.
+ * 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.
  */
-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;
-
+declare function readDirective(source: string): DirectiveBlock | null;
 /** Markdown → document (plain JSON, ProseMirror/Tiptap shape). Pure: no DOM. */
 declare function parse(markdown: string): Doc;
 
@@ -68,4 +34,4 @@ 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 };
+export { CODEC_ID, DirectiveBlock, Doc, DocNode, type OutlineEntry, frontmatterOf, normalize, outline, parse, readDirective, serialize };

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/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 };