@godxjp/markdown 0.0.0-stage → 31.18.0

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# @godxjp/markdown
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The one Markdown renderer for GoDX apps (godx-task, godx-content, and later mailer, chatter and
+approval). One pipeline, one sanitiser schema, one fixture corpus — so a security fix happens once.
+
+````bash
+pnpm add @godxjp/markdown        # + `mermaid` (optional) to draw ```mermaid fences
+````
+
+```tsx
+import { Prose } from "@godxjp/ui/data-display";
+import { Markdown } from "@godxjp/markdown";
+
+<Prose>
+  <Markdown>{page.body}</Markdown>
+</Prose>;
+```
+
+## What it renders
+
+GFM — tables, task lists (read-only), fenced code with `language-*` classes, autolinks, footnotes,
+strikethrough — and an `id` on every heading (GitHub slugs, de-duplicated). The output is the same
+as `react-markdown` + `remark-gfm` + `rehype-sanitize`, which is what the apps rendered before.
+
+## Safety
+
+- **No raw HTML.** HTML in the source is dropped, never parsed into elements.
+- **One schema** (`markdownSchema`): links allow `http`, `https`, `mailto` and relative URLs;
+  images allow `http`, `https` and relative URLs. `javascript:`, `data:` and every other scheme are
+  removed — including a scheme split by tabs or newlines. SVG is never inlined from a URL.
+- **Mermaid is a picture only after its SVG passes `checkMermaidSvg`**: no `<script>`,
+  `<foreignObject>`, `<a>`, `<image>`, event handlers, non-fragment `href`, `url()` that leaves the
+  document, or `@import`. A diagram that fails, or a host without `mermaid`, shows the code.
+
+## Host extension points
+
+| prop                                | use                                                                                    |
+| ----------------------------------- | -------------------------------------------------------------------------------------- |
+| `remarkPlugins`                     | Host markers (callouts, embeds). Their output is still sanitised.                      |
+| `schema`                            | `{ tagNames, attributes }` the markers need. Additive: it cannot widen the URL policy. |
+| `resolveUrl(url, key)`              | Map a host scheme (`asset:…`) to a real URL before the sanitiser judges it.            |
+| `headingId({ depth, text, index })` | Use server-assigned anchors instead of slugs.                                          |
+| `components`                        | Element overrides; a host `pre` replaces the Mermaid default.                          |
+| `rehypePlugins`                     | Run after the sanitiser — presentation only.                                           |
+| `mermaid={false}`                   | Keep ```mermaid fences as code.                                                        |
+
+## Stored versions
+
+Record `MARKDOWN_FORMAT` (`"md"`) and `RENDERER_VERSION` on every saved version.
+`RENDERER_VERSION` changes when the same input renders differently.
+
+## Fixtures
+
+`MARKDOWN_FIXTURES` is the shared corpus: input Markdown → the exact sanitised HTML, with `forbidden`
+substrings for the hostile ones. A server or export path conforms to this list.

package/dist/index.d.ts

@@ -0,0 +1,158 @@
+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.
+ *
+ * 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.
+ * An attribute list for a tag the base already lists is appended to, not replaced.
+ */
+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;
+
+type PluggableList = NonNullable<Options$1["remarkPlugins"]>;
+/**
+ * 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 = 1;
+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` replaces the Mermaid default. */
+    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). `false` keeps them as code. */
+    mermaid?: boolean;
+};
+/**
+ * THE ONE RENDERER (gh#1108). GFM — tables, task lists, fenced code, autolinks, footnotes,
+ * strikethrough — plus heading anchors, sanitised by `markdownSchema`, with ```mermaid drawn only
+ * through the SVG gate. Raw HTML in the source is never parsed into elements (no `rehype-raw`): it
+ * stays visible text. Output matches `react-markdown` + `remark-gfm` + `rehype-sanitize`, which is
+ * what godx-task and godx-content rendered before, so the swap is drop-in.
+ *
+ * Renders bare elements; the host wraps it (`<Prose>` from `@godxjp/ui/data-display`), so this
+ * package carries no UI-kit dependency.
+ */
+declare function Markdown({ children, remarkPlugins, rehypePlugins, schema, components, resolveUrl, headingId, mermaid, }: MarkdownProps): React.JSX.Element;
+
+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 HeadingIdResolver, type HeadingInfo, MARKDOWN_FIXTURES, MARKDOWN_FORMAT, Markdown, type MarkdownFixture, type MarkdownProps, MermaidDiagram, type MermaidDiagramProps, type MermaidSvgCheck, RENDERER_VERSION, type SchemaExtension, checkMermaidSvg, extendSchema, markdownSchema, rehypeHeadingIds, safeUrl };

package/dist/index.js

@@ -0,0 +1,371 @@
+"use client";
+
+// src/markdown.tsx
+import * as React2 from "react";
+import ReactMarkdown from "react-markdown";
+import rehypeSanitize from "rehype-sanitize";
+import remarkGfm from "remark-gfm";
+import { visit as visit2 } from "unist-util-visit";
+
+// src/headings.ts
+import GithubSlugger from "github-slugger";
+import { visit } from "unist-util-visit";
+var HEADING = /^h([1-6])$/;
+function textOf(node) {
+  if (node.type === "text") return node.value;
+  if ("children" in node) return node.children.map(textOf).join("");
+  return "";
+}
+function rehypeHeadingIds(options = {}) {
+  return (tree) => {
+    const slugger = new GithubSlugger();
+    let index = 0;
+    visit(tree, "element", (node) => {
+      const match = HEADING.exec(node.tagName);
+      if (!match) return;
+      if (node.properties?.id != null) return;
+      const text = textOf(node);
+      const info = { depth: Number(match[1]), text, index: index++ };
+      const id = options.resolve ? options.resolve(info) : slugger.slug(text);
+      if (id) node.properties = { ...node.properties, id };
+    });
+  };
+}
+
+// src/mermaid.tsx
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "textpath",
+  "marker",
+  "defs",
+  "style",
+  "title",
+  "desc",
+  "lineargradient",
+  "radialgradient",
+  "stop",
+  "clippath",
+  "mask",
+  "pattern",
+  "symbol",
+  "use",
+  "filter",
+  "fegaussianblur",
+  "feoffset",
+  "feblend",
+  "feflood",
+  "fecomposite",
+  "femerge",
+  "femergenode",
+  "fedropshadow"
+]);
+var URL_REF = /url\s*\(\s*(['"]?)([^'")]*)\1\s*\)/gi;
+var CSS_HAZARD = /@import|expression\s*\(|javascript:|behavior\s*:|-moz-binding|<\//i;
+function urlsAreLocal(value) {
+  for (const match of value.matchAll(URL_REF)) {
+    if (!match[2].trim().startsWith("#")) return false;
+  }
+  return true;
+}
+function checkMermaidSvg(svg) {
+  if (typeof DOMParser === "undefined") return { ok: false, reason: "no DOMParser" };
+  const doc = new DOMParser().parseFromString(svg, "image/svg+xml");
+  if (doc.getElementsByTagName("parsererror").length > 0) return { ok: false, reason: "parse" };
+  const root = doc.documentElement;
+  if (root.localName.toLowerCase() !== "svg") return { ok: false, reason: "root" };
+  const elements = [root, ...Array.from(root.getElementsByTagName("*"))];
+  for (const element of elements) {
+    const name = element.localName.toLowerCase();
+    if (!ALLOWED_ELEMENTS.has(name)) return { ok: false, reason: `element ${name}` };
+    if (name === "style") {
+      const css = element.textContent ?? "";
+      if (CSS_HAZARD.test(css) || !urlsAreLocal(css)) return { ok: false, reason: "style" };
+    }
+    for (const attribute of Array.from(element.attributes)) {
+      const attr = attribute.localName.toLowerCase();
+      const value = attribute.value;
+      if (attr.startsWith("on")) return { ok: false, reason: `handler ${attr}` };
+      if ((attr === "href" || attr === "src") && !value.trim().startsWith("#")) {
+        return { ok: false, reason: `ref ${attr}` };
+      }
+      if (attr === "style" && CSS_HAZARD.test(value)) return { ok: false, reason: "style attr" };
+      if (!urlsAreLocal(value)) return { ok: false, reason: `url ${attr}` };
+    }
+  }
+  return { ok: true, svg: root };
+}
+var loading = null;
+function loadMermaid() {
+  loading ??= import("mermaid").then((module) => {
+    const api = module.default;
+    api.initialize({
+      startOnLoad: false,
+      securityLevel: "strict",
+      // SVG text labels, not HTML in <foreignObject> — which the gate rejects outright.
+      htmlLabels: false,
+      flowchart: { htmlLabels: false },
+      theme: document.documentElement.dataset.theme === "dark" ? "dark" : "default"
+    });
+    return api;
+  }).catch(() => null);
+  return loading;
+}
+function MermaidCode({ source }) {
+  return /* @__PURE__ */ jsx("pre", { "data-mermaid": "code", children: /* @__PURE__ */ jsx("code", { className: "language-mermaid", children: source }) });
+}
+function MermaidDiagram({ source, label }) {
+  const host = React.useRef(null);
+  const id = `godx-mermaid-${React.useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
+  const [state, setState] = React.useState("code");
+  React.useEffect(() => {
+    let cancelled = false;
+    setState("code");
+    void (async () => {
+      const api = await loadMermaid();
+      if (!api || cancelled) return;
+      try {
+        const { svg } = await api.render(id, source);
+        const checked = checkMermaidSvg(svg);
+        if (cancelled || !checked.ok || !host.current) return;
+        host.current.replaceChildren(document.importNode(checked.svg, true));
+        setState("diagram");
+      } catch {
+      } finally {
+        document.getElementById(`d${id}`)?.remove();
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [id, source]);
+  return /* @__PURE__ */ jsxs("figure", { "data-mermaid": state, "aria-label": state === "diagram" ? label : void 0, children: [
+    /* @__PURE__ */ jsx("div", { ref: host, hidden: state !== "diagram" }),
+    state === "code" ? /* @__PURE__ */ jsx(MermaidCode, { source }) : null
+  ] });
+}
+
+// src/schema.ts
+import { defaultSchema } from "rehype-sanitize";
+var markdownSchema = {
+  ...defaultSchema,
+  clobberPrefix: "",
+  protocols: {
+    ...defaultSchema.protocols,
+    href: ["http", "https", "mailto"],
+    src: ["http", "https"],
+    cite: ["http", "https"]
+  },
+  attributes: {
+    ...defaultSchema.attributes,
+    // Heading anchors (rehype-headings, below) and the code fence language.
+    h1: [...defaultSchema.attributes?.h1 ?? [], "id"],
+    h2: [...defaultSchema.attributes?.h2 ?? [], "id"],
+    h3: [...defaultSchema.attributes?.h3 ?? [], "id"],
+    h4: [...defaultSchema.attributes?.h4 ?? [], "id"],
+    h5: [...defaultSchema.attributes?.h5 ?? [], "id"],
+    h6: [...defaultSchema.attributes?.h6 ?? [], "id"]
+  }
+};
+function extendSchema(extension = {}) {
+  const attributes = { ...markdownSchema.attributes };
+  for (const [tag, list] of Object.entries(extension.attributes ?? {})) {
+    attributes[tag] = [...attributes[tag] ?? [], ...list];
+  }
+  return {
+    ...markdownSchema,
+    tagNames: [...markdownSchema.tagNames ?? [], ...extension.tagNames ?? []],
+    attributes
+  };
+}
+var SAFE_HREF = /^(https?:|mailto:)/i;
+var SAFE_SRC = /^https?:/i;
+var SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+function safeUrl(url, key) {
+  const value = url.trim();
+  const probe = value.replace(/[\x00-\x20\x7f]/g, "");
+  if (!SCHEME.test(probe)) return value;
+  if (key === "src") return SAFE_SRC.test(probe) ? value : "";
+  return SAFE_HREF.test(probe) ? value : "";
+}
+
+// src/markdown.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var MARKDOWN_FORMAT = "md";
+var RENDERER_VERSION = 1;
+var URL_ATTRIBUTES = {
+  a: "href",
+  img: "src",
+  blockquote: "cite",
+  q: "cite"
+};
+function rehypeResolveUrls(options) {
+  return (tree) => {
+    if (!options.resolve) return;
+    visit2(tree, "element", (node) => {
+      const key = URL_ATTRIBUTES[node.tagName];
+      const value = key ? node.properties?.[key] : void 0;
+      if (typeof value !== "string") return;
+      const resolved = options.resolve(value, key);
+      if (resolved !== void 0) node.properties = { ...node.properties, [key]: resolved };
+    });
+  };
+}
+function fenceOf(node) {
+  const code = node?.children?.[0];
+  if (!code || code.type !== "element" || code.tagName !== "code") return void 0;
+  const classes = code.properties?.className ?? [];
+  const language = classes.find((name) => name.startsWith("language-"))?.slice(9);
+  const text = code.children.map((child) => child.type === "text" ? child.value : "").join("");
+  return { language, text };
+}
+function Markdown({
+  children,
+  remarkPlugins = [],
+  rehypePlugins = [],
+  schema,
+  components,
+  resolveUrl,
+  headingId,
+  mermaid = true
+}) {
+  const sanitizeSchema = React2.useMemo(() => extendSchema(schema), [schema]);
+  const merged = React2.useMemo(() => {
+    const base = {};
+    if (mermaid) {
+      base.pre = ({ node, children: inner, ...props }) => {
+        const fence = fenceOf(node);
+        if (fence?.language === "mermaid") return /* @__PURE__ */ jsx2(MermaidDiagram, { source: fence.text });
+        return /* @__PURE__ */ jsx2("pre", { ...props, children: inner });
+      };
+    }
+    return { ...base, ...components };
+  }, [components, mermaid]);
+  return /* @__PURE__ */ jsx2(
+    ReactMarkdown,
+    {
+      remarkPlugins: [remarkGfm, ...remarkPlugins],
+      rehypePlugins: [
+        [rehypeResolveUrls, { resolve: resolveUrl }],
+        [rehypeHeadingIds, { resolve: headingId }],
+        [rehypeSanitize, sanitizeSchema],
+        ...rehypePlugins
+      ],
+      urlTransform: safeUrl,
+      components: merged,
+      children
+    }
+  );
+}
+
+// src/fixtures.ts
+var MARKDOWN_FIXTURES = [
+  {
+    name: "headings get GitHub anchors, de-duplicated",
+    markdown: "# \u6982\u8981\n\n## Setup\n\n## Setup",
+    html: '<h1 id="\u6982\u8981">\u6982\u8981</h1>\n<h2 id="setup">Setup</h2>\n<h2 id="setup-1">Setup</h2>'
+  },
+  {
+    name: "emphasis, strong, strikethrough, inline code",
+    markdown: "*em* **strong** ~~gone~~ `code`",
+    html: "<p><em>em</em> <strong>strong</strong> <del>gone</del> <code>code</code></p>"
+  },
+  {
+    name: "GFM table with alignment",
+    markdown: "| a | b |\n|:--|--:|\n| 1 | 2 |",
+    html: '<table><thead><tr><th style="text-align:left">a</th><th style="text-align:right">b</th></tr></thead><tbody><tr><td style="text-align:left">1</td><td style="text-align:right">2</td></tr></tbody></table>'
+  },
+  {
+    name: "task list stays read-only",
+    markdown: "- [x] done\n- [ ] todo",
+    html: '<ul class="contains-task-list">\n<li class="task-list-item"><input type="checkbox" disabled="" checked=""/> done</li>\n<li class="task-list-item"><input type="checkbox" disabled=""/> todo</li>\n</ul>'
+  },
+  {
+    name: "fenced code keeps its language class",
+    markdown: "```ts\nconst a = 1;\n```",
+    html: '<pre><code class="language-ts">const a = 1;\n</code></pre>'
+  },
+  {
+    name: "links and autolinks",
+    markdown: "[docs](https://example.com/a) <https://example.com> mail@example.com",
+    html: '<p><a href="https://example.com/a">docs</a> <a href="https://example.com">https://example.com</a> <a href="mailto:mail@example.com">mail@example.com</a></p>'
+  },
+  {
+    name: "relative and fragment links pass",
+    markdown: "[a](/wiki/Page) [b](#setup) [c](other)",
+    html: '<p><a href="/wiki/Page">a</a> <a href="#setup">b</a> <a href="other">c</a></p>'
+  },
+  {
+    name: "image by URL",
+    markdown: "![chart](https://cdn.example.com/c.png)",
+    html: '<p><img src="https://cdn.example.com/c.png" alt="chart"/></p>'
+  },
+  {
+    name: "footnote link and its target agree",
+    markdown: "Text[^1]\n\n[^1]: Note.",
+    html: '<p>Text<sup><a href="#user-content-fn-1" id="user-content-fnref-1" data-footnote-ref="true" aria-describedby="footnote-label">1</a></sup></p>\n<section data-footnotes="true" class="footnotes"><h2 class="sr-only" id="footnote-label">Footnotes</h2>\n<ol>\n<li id="user-content-fn-1">\n<p>Note. <a href="#user-content-fnref-1" data-footnote-backref="" aria-label="Back to reference 1" class="data-footnote-backref">\u21A9</a></p>\n</li>\n</ol>\n</section>'
+  },
+  {
+    name: "mermaid fence before the diagram has rendered",
+    markdown: "```mermaid\ngraph TD; A-->B\n```",
+    html: '<figure data-mermaid="code"><div hidden=""></div><pre data-mermaid="code"><code class="language-mermaid">graph TD; A--&gt;B\n</code></pre></figure>'
+  },
+  {
+    name: "raw HTML blocks are dropped, never parsed",
+    hostile: true,
+    markdown: '<script>alert(1)</script>\n\n<img src=x onerror="alert(1)">\n\n<div id="app-sidebar">x</div>',
+    html: "\n\n",
+    forbidden: ["<script", "<img", "onerror", "app-sidebar"]
+  },
+  {
+    name: "inline raw HTML is dropped, its text kept",
+    hostile: true,
+    markdown: 'a <b onclick="alert(1)">bold</b> <iframe src="https://evil.example"></iframe> z',
+    html: "<p>a bold  z</p>",
+    forbidden: ["<b", "onclick", "<iframe", "evil.example"]
+  },
+  {
+    name: "javascript: and data: links are dropped",
+    hostile: true,
+    markdown: "[a](javascript:alert(1)) [b](JAVASCRIPT:alert(1)) [c](data:text/html,<script>alert(1)</script>) [d](vbscript:x)",
+    html: "<p><a>a</a> <a>b</a> <a>c</a> <a>d</a></p>",
+    forbidden: ["javascript:", "JAVASCRIPT:", "data:", "vbscript:"]
+  },
+  {
+    name: "a scheme split by control characters is dropped",
+    hostile: true,
+    markdown: "[a](<java	script:alert(1)>)",
+    html: "<p><a>a</a></p>",
+    forbidden: ["script:"]
+  },
+  {
+    name: "data: and javascript: images are dropped",
+    hostile: true,
+    markdown: "![x](data:image/svg+xml;base64,PHN2Zz4=) ![y](javascript:alert(1))",
+    html: '<p><img alt="x"/> <img alt="y"/></p>',
+    forbidden: ["data:", "javascript:"]
+  }
+];
+export {
+  MARKDOWN_FIXTURES,
+  MARKDOWN_FORMAT,
+  Markdown,
+  MermaidDiagram,
+  RENDERER_VERSION,
+  checkMermaidSvg,
+  extendSchema,
+  markdownSchema,
+  rehypeHeadingIds,
+  safeUrl
+};

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@godxjp/markdown",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "31.18.0",
+  "description": "The one Markdown renderer for GoDX apps: GFM + heading anchors, 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",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/godx-jp/godxjp-ui.git",
+    "directory": "packages/markdown"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "github-slugger": "^2.0.0",
+    "react-markdown": "^10.1.0",
+    "rehype-sanitize": "^6.0.0",
+    "remark-gfm": "^4.0.1",
+    "unist-util-visit": "^5.1.0"
+  },
+  "peerDependencies": {
+    "mermaid": "^11.0.0",
+    "react": ">=19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mermaid": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "markdown",
+    "gfm",
+    "sanitize",
+    "mermaid",
+    "godxjp"
+  ]
+}