@markmap/plugin-math 0.0.0-stage → 1.0.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Gerald
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @markmap/plugin-math
 
-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.
+TeX math in Markmap labels, rendered with MathJax.
+
+See the [Markmap README](https://github.com/markmap/markmap#readme) for how the packages fit together.

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import type { ContentPlugin } from '@markmap/core';
+import type { MathSvg } from './mathjax';
+/** Parses `$…$` (and `$$…$$`) into math nodes. Pass it to `parse(md, { plugins })`. */
+export { default as remarkMath } from 'remark-math';
+export interface MathContentOptions {
+    /**
+     * Load the TeX converter. Defaults to a dynamic import of MathJax, so it stays out of
+     * the initial bundle and loads the first time a formula is drawn.
+     */
+    load?: () => Promise<{
+        texToSvg(tex: string, display: boolean): MathSvg;
+    }>;
+    /** Size of 1ex as a fraction of the font size. */
+    exFactor?: number;
+}
+/**
+ * Draws `$…$` in labels as MathJax SVG. Formulas are measured from the TeX source until
+ * MathJax has loaded and converted them, then the view renders again with the real
+ * size. Invalid TeX keeps showing its source.
+ */
+export declare function createMathContent(options?: MathContentOptions): ContentPlugin;
+/** Math in labels, with MathJax loaded on first use. */
+export declare const mathContent: ContentPlugin;

package/dist/index.js

@@ -0,0 +1,186 @@
+import { n as withColor } from "./shapes-Bx9ID-CD.js";
+import remarkMath from "remark-math";
+// src/index.ts
+/** Placeholder and error look: the TeX source in the code font. */
+function sourceStyle(style, ctx) {
+	return {
+		font: {
+			...style.font,
+			family: ctx.theme.codeFontFamily,
+			size: style.font.size * .875
+		},
+		fill: "var(--mm-code-text)"
+	};
+}
+function sourceSize(tex, style, ctx) {
+	const { font } = sourceStyle(style, ctx);
+	return {
+		width: ctx.measurer.measure(tex, font),
+		height: style.font.lineHeight,
+		baseline: (style.font.lineHeight + style.font.size * .7) / 2
+	};
+}
+/** Fit a `viewBox` in `box`, centered and keeping its aspect ratio, like SVG does. */
+function fitViewBox(viewBox, box) {
+	const [minX, minY, width, height] = viewBox.split(/\s+/).map(Number);
+	const k = Math.min(box.width / width, box.height / height);
+	return [
+		k,
+		0,
+		0,
+		k,
+		box.x + (box.width - width * k) / 2 - minX * k,
+		box.y + (box.height - height * k) / 2 - minY * k
+	];
+}
+var escapeAttr = (value) => value.replace(/[&"<>]/g, (c) => `&#${c.charCodeAt(0)};`);
+var isMathCode = (node) => node?.type === "element" && node.tagName === "code" && Array.isArray(node.properties.className) && node.properties.className.includes("language-math");
+var textOf = (node) => node.children.map((child) => child.type === "text" ? child.value : "").join("");
+/** Standalone HTML `<svg>` for a popover, sized in ex so it scales with the text. */
+function popoverSvg(tex, svg) {
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${svg.width}ex" height="${svg.height}ex" viewBox="${escapeAttr(svg.viewBox)}" style="vertical-align:${svg.verticalAlign}ex" role="img" focusable="false" aria-label="${escapeAttr(tex)}">${svg.body}</svg>`;
+}
+/**
+* Draws `$…$` in labels as MathJax SVG. Formulas are measured from the TeX source until
+* MathJax has loaded and converted them, then the view renders again with the real
+* size. Invalid TeX keeps showing its source.
+*/
+function createMathContent(options = {}) {
+	const load = options.load ?? (() => import("./mathjax-ClZ0hICZ.js"));
+	const exFactor = options.exFactor ?? .5;
+	let converter;
+	/** Converted formulas by TeX; an `Error` when the TeX is invalid. */
+	const formulas = /* @__PURE__ */ new Map();
+	const converting = /* @__PURE__ */ new Map();
+	const convert = (tex, ctx) => {
+		let task = converting.get(tex);
+		if (!task) {
+			converter ??= load();
+			task = converter.then(({ texToSvg }) => {
+				try {
+					formulas.set(tex, texToSvg(tex, false));
+				} catch (error) {
+					formulas.set(tex, error instanceof Error ? error : new Error(String(error)));
+				}
+			}).catch((error) => {
+				converter = void 0;
+				formulas.set(tex, error instanceof Error ? error : new Error(String(error)));
+			}).finally(() => converting.delete(tex));
+			converting.set(tex, task);
+		}
+		ctx.defer?.(task);
+	};
+	/** Replace `$…$` and `$$…$$` (code with `language-math` after sanitizing) with SVG. */
+	const popover = async (tree) => {
+		const found = [];
+		const visit = (parent) => {
+			parent.children.forEach((child, index) => {
+				if (child.type !== "element") return;
+				const [only] = child.children;
+				if (child.tagName === "pre" && child.children.length === 1 && isMathCode(only)) found.push({
+					parent,
+					index,
+					tex: textOf(only),
+					display: true
+				});
+				else if (isMathCode(child)) found.push({
+					parent,
+					index,
+					tex: textOf(child),
+					display: false
+				});
+				else visit(child);
+			});
+		};
+		visit(tree);
+		if (!found.length) return;
+		let texToSvg;
+		try {
+			converter ??= load();
+			({texToSvg} = await converter);
+		} catch {
+			converter = void 0;
+			return;
+		}
+		for (const { parent, index, tex, display } of found) {
+			let svg;
+			try {
+				svg = texToSvg(tex, display);
+			} catch {
+				continue;
+			}
+			const markup = popoverSvg(tex, svg);
+			const raw = {
+				type: "raw",
+				value: display ? `<div class="markmap-math-display" style="margin:0.5em 0;text-align:center;overflow-x:auto">${markup}</div>` : markup
+			};
+			parent.children[index] = raw;
+		}
+	};
+	const formula = (inline, ctx) => {
+		const found = formulas.get(inline.value);
+		if (!found) convert(inline.value, ctx);
+		return found instanceof Error ? void 0 : found;
+	};
+	return {
+		name: "math",
+		popover,
+		atoms: { inlineMath: {
+			measure(inline, style, ctx) {
+				const svg = formula(inline, ctx);
+				if (!svg) return sourceSize(inline.value, style, ctx);
+				const ex = style.font.size * exFactor;
+				const height = svg.height * ex;
+				return {
+					width: svg.width * ex,
+					height,
+					baseline: height + svg.verticalAlign * ex
+				};
+			},
+			render(inline, box, style, ctx) {
+				const svg = formulas.get(inline.value);
+				const sourceText = () => {
+					const source = sourceStyle(style, ctx);
+					const { baseline } = sourceSize(inline.value, style, ctx);
+					const run = {
+						text: inline.value,
+						x: 0,
+						y: baseline,
+						...source
+					};
+					return {
+						kind: "text",
+						x: box.x,
+						y: box.y,
+						runs: [run]
+					};
+				};
+				if (!svg || svg instanceof Error) return [sourceText()];
+				const attrs = [
+					`x="${box.x}"`,
+					`y="${box.y}"`,
+					`width="${box.width}"`,
+					`height="${box.height}"`,
+					`viewBox="${escapeAttr(svg.viewBox)}"`,
+					`style="color:${escapeAttr(style.fill)};overflow:visible"`
+				].join(" ");
+				return [{
+					kind: "custom",
+					backends: ["svg"],
+					svg: () => `<svg ${attrs}>${svg.body}</svg>`
+				}, svg.shapes ? {
+					kind: "group",
+					backends: ["canvas"],
+					transform: fitViewBox(svg.viewBox, box),
+					children: withColor(svg.shapes, style.fill)
+				} : {
+					...sourceText(),
+					backends: ["canvas"]
+				}];
+			}
+		} }
+	};
+}
+/** Math in labels, with MathJax loaded on first use. */
+var mathContent = createMathContent();
+export { createMathContent, mathContent, remarkMath };

package/dist/mathjax-ClZ0hICZ.js

@@ -0,0 +1,122 @@
+import { t as svgToPrimitives } from "./shapes-Bx9ID-CD.js";
+import "@mathjax/src/js/input/tex/base/BaseConfiguration.js";
+import "@mathjax/src/js/input/tex/action/ActionConfiguration.js";
+import "@mathjax/src/js/input/tex/ams/AmsConfiguration.js";
+import "@mathjax/src/js/input/tex/amscd/AmsCdConfiguration.js";
+import "@mathjax/src/js/input/tex/bbox/BboxConfiguration.js";
+import "@mathjax/src/js/input/tex/boldsymbol/BoldsymbolConfiguration.js";
+import "@mathjax/src/js/input/tex/braket/BraketConfiguration.js";
+import "@mathjax/src/js/input/tex/bussproofs/BussproofsConfiguration.js";
+import "@mathjax/src/js/input/tex/cancel/CancelConfiguration.js";
+import "@mathjax/src/js/input/tex/cases/CasesConfiguration.js";
+import "@mathjax/src/js/input/tex/centernot/CenternotConfiguration.js";
+import "@mathjax/src/js/input/tex/color/ColorConfiguration.js";
+import "@mathjax/src/js/input/tex/colortbl/ColortblConfiguration.js";
+import "@mathjax/src/js/input/tex/empheq/EmpheqConfiguration.js";
+import "@mathjax/src/js/input/tex/enclose/EncloseConfiguration.js";
+import "@mathjax/src/js/input/tex/extpfeil/ExtpfeilConfiguration.js";
+import "@mathjax/src/js/input/tex/gensymb/GensymbConfiguration.js";
+import "@mathjax/src/js/input/tex/mathtools/MathtoolsConfiguration.js";
+import "@mathjax/src/js/input/tex/mhchem/MhchemConfiguration.js";
+import "@mathjax/src/js/input/tex/newcommand/NewcommandConfiguration.js";
+import "@mathjax/src/js/input/tex/noerrors/NoErrorsConfiguration.js";
+import "@mathjax/src/js/input/tex/noundefined/NoUndefinedConfiguration.js";
+import "@mathjax/src/js/input/tex/physics/PhysicsConfiguration.js";
+import "@mathjax/src/js/input/tex/tagformat/TagFormatConfiguration.js";
+import "@mathjax/src/js/input/tex/textcomp/TextcompConfiguration.js";
+import "@mathjax/src/js/input/tex/textmacros/TextMacrosConfiguration.js";
+import "@mathjax/src/js/input/tex/unicode/UnicodeConfiguration.js";
+import "@mathjax/src/js/input/tex/upgreek/UpgreekConfiguration.js";
+import "@mathjax/src/js/input/tex/verb/VerbConfiguration.js";
+import { MathJaxTexFont } from "@mathjax/mathjax-tex-font/js/svg.js";
+import { liteAdaptor } from "@mathjax/src/js/adaptors/liteAdaptor.js";
+import { RegisterHTMLHandler } from "@mathjax/src/js/handlers/html.js";
+import { TeX } from "@mathjax/src/js/input/tex.js";
+import { mathjax } from "@mathjax/src/js/mathjax.js";
+import { SVG } from "@mathjax/src/js/output/svg.js";
+// src/mathjax.ts
+/**
+* TeX packages that only lay out math. The rest, such as `html`, `texhtml`, `require`,
+* `autoload`, `setoptions` and `configmacros`, can reach outside the formula or change
+* the converter, so Markdown cannot use them.
+*/
+var SAFE_PACKAGES = [
+	"base",
+	"action",
+	"ams",
+	"amscd",
+	"bbox",
+	"boldsymbol",
+	"braket",
+	"bussproofs",
+	"cancel",
+	"cases",
+	"centernot",
+	"color",
+	"colortbl",
+	"empheq",
+	"enclose",
+	"extpfeil",
+	"gensymb",
+	"mathtools",
+	"mhchem",
+	"newcommand",
+	"noerrors",
+	"noundefined",
+	"physics",
+	"tagformat",
+	"textcomp",
+	"textmacros",
+	"unicode",
+	"upgreek",
+	"verb"
+];
+var adaptor = liteAdaptor();
+RegisterHTMLHandler(adaptor);
+var doc = mathjax.document("", {
+	InputJax: new TeX({ packages: SAFE_PACKAGES }),
+	OutputJax: new SVG({
+		fontData: MathJaxTexFont,
+		fontCache: "none",
+		linebreaks: { inline: false }
+	})
+});
+var ex = (value) => Number.parseFloat(value ?? "") || 0;
+/** MathJax's element tree in the form {@link svgToPrimitives} takes. */
+function toSvgNode(node) {
+	const attrs = {};
+	for (const { name, value } of adaptor.allAttributes(node)) attrs[name] = value;
+	const children = adaptor.childNodes(node).map((child) => {
+		const tag = adaptor.kind(child);
+		return tag.startsWith("#") ? {
+			tag,
+			attrs: {},
+			children: []
+		} : toSvgNode(child);
+	});
+	return {
+		tag: adaptor.kind(node),
+		attrs,
+		children
+	};
+}
+/** Convert TeX to SVG. Throws on TeX errors. */
+function texToSvg(tex, display) {
+	const container = doc.convert(tex, { display });
+	const svg = adaptor.firstChild(container);
+	const body = adaptor.innerHTML(svg).replace(/\sdata-latex(?:-item)?="[^"]*"/g, "");
+	if (body.includes("data-mjx-error")) {
+		const message = /data-mjx-error="([^"]*)"/.exec(body)?.[1] ?? "TeX error";
+		throw new Error(message);
+	}
+	const style = adaptor.getAttribute(svg, "style") ?? "";
+	return {
+		body: body.replace(/<\/?(?:a|script|foreignObject)\b[^>]*>/gi, "").replace(/\shref="[^"]*"/gi, ""),
+		viewBox: adaptor.getAttribute(svg, "viewBox") ?? "0 0 0 0",
+		width: ex(adaptor.getAttribute(svg, "width")),
+		height: ex(adaptor.getAttribute(svg, "height")),
+		verticalAlign: ex(/vertical-align:\s*([-\d.]+)ex/.exec(style)?.[1]),
+		shapes: svgToPrimitives(toSvgNode(svg).children)
+	};
+}
+export { texToSvg };

package/dist/mathjax.d.ts

@@ -0,0 +1,48 @@
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/action/ActionConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+import '@mathjax/src/js/input/tex/amscd/AmsCdConfiguration.js';
+import '@mathjax/src/js/input/tex/bbox/BboxConfiguration.js';
+import '@mathjax/src/js/input/tex/boldsymbol/BoldsymbolConfiguration.js';
+import '@mathjax/src/js/input/tex/braket/BraketConfiguration.js';
+import '@mathjax/src/js/input/tex/bussproofs/BussproofsConfiguration.js';
+import '@mathjax/src/js/input/tex/cancel/CancelConfiguration.js';
+import '@mathjax/src/js/input/tex/cases/CasesConfiguration.js';
+import '@mathjax/src/js/input/tex/centernot/CenternotConfiguration.js';
+import '@mathjax/src/js/input/tex/color/ColorConfiguration.js';
+import '@mathjax/src/js/input/tex/colortbl/ColortblConfiguration.js';
+import '@mathjax/src/js/input/tex/empheq/EmpheqConfiguration.js';
+import '@mathjax/src/js/input/tex/enclose/EncloseConfiguration.js';
+import '@mathjax/src/js/input/tex/extpfeil/ExtpfeilConfiguration.js';
+import '@mathjax/src/js/input/tex/gensymb/GensymbConfiguration.js';
+import '@mathjax/src/js/input/tex/mathtools/MathtoolsConfiguration.js';
+import '@mathjax/src/js/input/tex/mhchem/MhchemConfiguration.js';
+import '@mathjax/src/js/input/tex/newcommand/NewcommandConfiguration.js';
+import '@mathjax/src/js/input/tex/noerrors/NoErrorsConfiguration.js';
+import '@mathjax/src/js/input/tex/noundefined/NoUndefinedConfiguration.js';
+import '@mathjax/src/js/input/tex/physics/PhysicsConfiguration.js';
+import '@mathjax/src/js/input/tex/tagformat/TagFormatConfiguration.js';
+import '@mathjax/src/js/input/tex/textcomp/TextcompConfiguration.js';
+import '@mathjax/src/js/input/tex/textmacros/TextMacrosConfiguration.js';
+import '@mathjax/src/js/input/tex/unicode/UnicodeConfiguration.js';
+import '@mathjax/src/js/input/tex/upgreek/UpgreekConfiguration.js';
+import '@mathjax/src/js/input/tex/verb/VerbConfiguration.js';
+import type { Primitive } from '@markmap/core';
+/** A formula as self-contained SVG, measured in ex. */
+export interface MathSvg {
+    /** Markup inside the formula's `<svg>` element: paths only, no fonts or links. */
+    body: string;
+    viewBox: string;
+    width: number;
+    height: number;
+    /** Distance of the baseline below the bottom edge (usually negative), from `vertical-align`. */
+    verticalAlign: number;
+    /**
+     * The formula as primitives in `viewBox` coordinates, for backends that cannot use SVG
+     * markup, with `currentColor` standing for the text color. `undefined` when the
+     * formula uses something that has no primitive.
+     */
+    shapes?: Primitive[];
+}
+/** Convert TeX to SVG. Throws on TeX errors. */
+export declare function texToSvg(tex: string, display: boolean): MathSvg;

package/dist/shapes-Bx9ID-CD.js

@@ -0,0 +1,217 @@
+import { multiply, translate } from "@markmap/core";
+// src/shapes.ts
+/** Paint that stands for the label's text color until a formula is drawn. */
+var CURRENT_COLOR = "currentColor";
+var Unsupported = class extends Error {};
+var COMMON_ATTRS = [
+	"transform",
+	"fill",
+	"stroke",
+	"stroke-width"
+];
+var ALLOWED_ATTRS = {
+	g: COMMON_ATTRS,
+	path: [...COMMON_ATTRS, "d"],
+	rect: [
+		...COMMON_ATTRS,
+		"x",
+		"y",
+		"width",
+		"height"
+	],
+	line: [
+		...COMMON_ATTRS,
+		"x1",
+		"y1",
+		"x2",
+		"y2"
+	],
+	ellipse: [
+		...COMMON_ATTRS,
+		"cx",
+		"cy",
+		"rx",
+		"ry"
+	],
+	svg: [
+		"x",
+		"y",
+		"width",
+		"height",
+		"viewBox"
+	]
+};
+function number(value, fallback) {
+	if (value == null && fallback != null) return fallback;
+	const result = Number(value);
+	if (value == null || value.trim() === "" || !Number.isFinite(result)) throw new Unsupported();
+	return result;
+}
+var numbers = (value) => value.trim().split(/[\s,]+/).map((part) => number(part));
+function parseTransform(value) {
+	let matrix = [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	if (value.replace(/(\w+)\(([^)]*)\)/g, (_, name, args) => {
+		const v = numbers(args);
+		let next;
+		if (name === "translate" && v.length <= 2) next = translate(v[0], v[1] ?? 0);
+		else if (name === "scale" && v.length <= 2) next = [
+			v[0],
+			0,
+			0,
+			v[1] ?? v[0],
+			0,
+			0
+		];
+		else if (name === "matrix" && v.length === 6) next = v;
+		else throw new Unsupported();
+		matrix = multiply(matrix, next);
+		return "";
+	}).trim()) throw new Unsupported();
+	return matrix;
+}
+var inheritPaint = (value, current) => value == null ? current : value === "none" ? void 0 : value;
+function inherit(attrs, paints) {
+	return {
+		fill: inheritPaint(attrs.fill, paints.fill),
+		stroke: inheritPaint(attrs.stroke, paints.stroke),
+		strokeWidth: number(attrs["stroke-width"], paints.strokeWidth)
+	};
+}
+/** A shape's paints; a stroke of width 0 draws nothing. */
+var paintsOf = ({ fill, stroke, strokeWidth }) => ({
+	fill,
+	...stroke && strokeWidth > 0 ? {
+		stroke,
+		strokeWidth
+	} : {}
+});
+function shape(node, paints) {
+	const { attrs } = node;
+	switch (node.tag) {
+		case "path":
+			if (!attrs.d) throw new Unsupported();
+			return {
+				kind: "path",
+				d: attrs.d,
+				...paintsOf(paints)
+			};
+		case "rect": return {
+			kind: "rect",
+			x: number(attrs.x, 0),
+			y: number(attrs.y, 0),
+			w: number(attrs.width),
+			h: number(attrs.height),
+			...paintsOf(paints)
+		};
+		case "line": {
+			const [x1, y1] = [number(attrs.x1, 0), number(attrs.y1, 0)];
+			const [x2, y2] = [number(attrs.x2, 0), number(attrs.y2, 0)];
+			return {
+				kind: "path",
+				d: `M${x1},${y1}L${x2},${y2}`,
+				...paintsOf(paints)
+			};
+		}
+		case "ellipse": {
+			const [cx, cy] = [number(attrs.cx, 0), number(attrs.cy, 0)];
+			const [rx, ry] = [number(attrs.rx), number(attrs.ry)];
+			const arc = `A${rx},${ry} 0 1 0`;
+			return {
+				kind: "path",
+				d: `M${cx - rx},${cy}${arc} ${cx + rx},${cy}${arc} ${cx - rx},${cy}Z`,
+				...paintsOf(paints)
+			};
+		}
+		default: throw new Unsupported();
+	}
+}
+/**
+* What a nested `<svg>` does to its content: place it, fit its view box to its size, and
+* hide what overflows. MathJax relies on that to cut stretched rules to length.
+*/
+function nestedView({ x, y, width, height, viewBox }) {
+	const [minX, minY, boxWidth, boxHeight] = numbers(viewBox ?? "");
+	const [w, h] = [number(width), number(height)];
+	if (!(boxWidth > 0) || !(boxHeight > 0)) throw new Unsupported();
+	const k = Math.min(w / boxWidth, h / boxHeight);
+	const left = minX - (w / k - boxWidth) / 2;
+	const top = minY - (h / k - boxHeight) / 2;
+	return {
+		transform: [
+			k,
+			0,
+			0,
+			k,
+			number(x, 0) - left * k,
+			number(y, 0) - top * k
+		],
+		clip: {
+			x: left,
+			y: top,
+			width: w / k,
+			height: h / k
+		}
+	};
+}
+function convert(node, outer) {
+	const allowed = ALLOWED_ATTRS[node.tag];
+	if (!allowed) throw new Unsupported();
+	for (const name of Object.keys(node.attrs)) if (!allowed.includes(name) && !name.startsWith("data-")) throw new Unsupported();
+	const paints = inherit(node.attrs, outer);
+	const isContainer = node.tag === "g" || node.tag === "svg";
+	if (!isContainer && node.children.length) throw new Unsupported();
+	const content = isContainer ? node.children.map((child) => convert(child, paints)) : [shape(node, paints)];
+	if (node.tag === "svg") return {
+		kind: "group",
+		...nestedView(node.attrs),
+		children: content
+	};
+	const { transform } = node.attrs;
+	if (!isContainer && !transform) return content[0];
+	return {
+		kind: "group",
+		...transform ? { transform: parseTransform(transform) } : {},
+		children: content
+	};
+}
+/**
+* Turn MathJax's SVG into primitives, in its view box coordinates, for backends that
+* cannot use SVG markup. Only what MathJax is known to emit is accepted: anything else
+* returns `undefined`, so a formula is never drawn wrong.
+*/
+function svgToPrimitives(nodes) {
+	try {
+		const paints = {
+			fill: CURRENT_COLOR,
+			strokeWidth: 1
+		};
+		return nodes.map((node) => convert(node, paints));
+	} catch (error) {
+		if (error instanceof Unsupported) return void 0;
+		throw error;
+	}
+}
+/** A copy of `primitives` with the text color filled in. */
+function withColor(primitives, color) {
+	const paint = (value) => value === CURRENT_COLOR ? color : value;
+	return primitives.map((p) => {
+		if (p.kind === "group") return {
+			...p,
+			children: withColor(p.children, color)
+		};
+		if (p.kind === "rect" || p.kind === "path") return {
+			...p,
+			fill: paint(p.fill),
+			stroke: paint(p.stroke)
+		};
+		return p;
+	});
+}
+export { withColor as n, svgToPrimitives as t };

package/dist/shapes.d.ts

@@ -0,0 +1,15 @@
+import { type Primitive } from '@markmap/core';
+/** An element of MathJax's SVG output. */
+export interface SvgNode {
+    tag: string;
+    attrs: Readonly<Record<string, string>>;
+    children: readonly SvgNode[];
+}
+/**
+ * Turn MathJax's SVG into primitives, in its view box coordinates, for backends that
+ * cannot use SVG markup. Only what MathJax is known to emit is accepted: anything else
+ * returns `undefined`, so a formula is never drawn wrong.
+ */
+export declare function svgToPrimitives(nodes: readonly SvgNode[]): Primitive[] | undefined;
+/** A copy of `primitives` with the text color filled in. */
+export declare function withColor(primitives: readonly Primitive[], color: string): Primitive[];

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@markmap/plugin-math",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-next.0",
+  "description": "TeX math in Markmap labels, rendered with MathJax",
+  "homepage": "https://github.com/markmap/markmap#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markmap/markmap.git",
+    "directory": "packages/plugin-math"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@markmap/core": "1.0.0-next.0",
+    "@mathjax/mathjax-tex-font": "^4.1.3",
+    "@mathjax/src": "^4.1.3",
+    "mdast-util-math": "^3.0.0",
+    "remark-math": "^6.0.0"
+  },
+  "devDependencies": {
+    "@markmap/parse": "1.0.0-next.0",
+    "@markmap/render": "1.0.0-next.0",
+    "@types/hast": "^3.0.5",
+    "@types/mdast": "^4.0.4"
+  },
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build:types": "tsc -b",
+    "build:js": "vite build"
+  }
 }