@dskripchenko/math 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1868 @@
+// src/mathml.ts
+function escape(text) {
+	return text.replace(/[&<>"]/g, (c) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;"
+	})[c]);
+}
+var em = (n) => `${Math.round(n * 1e3) / 1e3}em`;
+/** Function application, invisible: `sin x` read as a function of x. */
+var APPLY = "<mo lspace=\"0\" rspace=\"0.1667em\">&#x2061;</mo>";
+function toMathML(node) {
+	switch (node.type) {
+		case "ident": return `<mi${node.upright && [...node.text].length === 1 ? " mathvariant=\"normal\"" : ""}>${escape(node.text)}</mi>`;
+		case "number": return `<mn>${escape(node.text)}</mn>`;
+		case "op": {
+			const a = [];
+			if (node.kind === "large" && [...node.text].length === 1) a.push("largeop=\"true\"");
+			if (node.movableLimits) a.push("movablelimits=\"true\"");
+			if (node.kind === "prefix") a.push("form=\"prefix\"", "lspace=\"0\"", "rspace=\"0.1667em\"");
+			if (node.stretchy) {
+				a.push("stretchy=\"true\"", "symmetric=\"true\"");
+				if (node.size) a.push(`minsize="${em(node.size)}"`, `maxsize="${em(node.size)}"`);
+			} else if (node.kind === "open" || node.kind === "close" || node.text === "|" || node.text === "‖" || node.text === "/") a.push("stretchy=\"false\"");
+			if (node.kind === "rel" && node.text.length === 1 && ":".includes(node.text)) a.push("lspace=\"0.2778em\"", "rspace=\"0.2778em\"");
+			if (node.kind === "punct") a.push("separator=\"true\"", "lspace=\"0\"", "rspace=\"0.1667em\"");
+			if (node.kind === "ord") a.push("lspace=\"0\"", "rspace=\"0\"");
+			return `<mo${a.length ? " " + a.join(" ") : ""}>${escape(node.text)}</mo>`;
+		}
+		case "text": return `<mtext>${escape(node.text.replace(/^ | $/g, "\xA0"))}</mtext>`;
+		case "space": return node.width >= 0 ? `<mspace width="${em(node.width)}"/>` : `<mspace style="margin-left:${em(node.width)}"/>`;
+		case "row": return `<mrow>${rowChildren(node.children)}</mrow>`;
+		case "scripts": {
+			const base = toMathML(node.base);
+			const fn = isFunction(node.base) ? APPLY : "";
+			const sub = node.sub ? toMathML(node.sub) : "";
+			const sup = node.sup ? toMathML(node.sup) : "";
+			if (node.over) {
+				if (node.sub && node.sup) return `<munderover>${base}${sub}${sup}</munderover>${fn}`;
+				if (node.sub) return `<munder>${base}${sub}</munder>${fn}`;
+				return `<mover>${base}${sup}</mover>${fn}`;
+			}
+			if (node.sub && node.sup) return `<msubsup>${base}${sub}${sup}</msubsup>${fn}`;
+			if (node.sub) return `<msub>${base}${sub}</msub>${fn}`;
+			return `<msup>${base}${sup}</msup>${fn}`;
+		}
+		case "frac": {
+			const frac = `<mfrac${node.thickness === 0 ? " linethickness=\"0\"" : ""}>${toMathML(node.num)}${toMathML(node.den)}</mfrac>`;
+			if (node.style === "display") return `<mrow displaystyle="true" scriptlevel="0">${frac}</mrow>`;
+			if (node.style === "text") return `<mrow displaystyle="false" scriptlevel="0">${frac}</mrow>`;
+			return frac;
+		}
+		case "sqrt": return node.index ? `<mroot>${toMathML(node.body)}${toMathML(node.index)}</mroot>` : `<msqrt>${toMathML(node.body)}</msqrt>`;
+		case "fenced": return `<mrow>${fence(node.open, "prefix")}${toMathML(node.body)}${fence(node.close, "postfix")}</mrow>`;
+		case "accent": {
+			const mark = `<mo stretchy="${node.stretchy ? "true" : "false"}">${escape(node.mark)}</mo>`;
+			return node.under ? `<munder accentunder="true">${toMathML(node.base)}${mark}</munder>` : `<mover accent="true">${toMathML(node.base)}${mark}</mover>`;
+		}
+		case "table": {
+			const rows = node.rows.map((cells) => {
+				return `<mtr>${cells.map((cell, i) => {
+					const style = [`text-align:${alignOf(node, i)}`];
+					if (node.aligned) style.push(i % 2 === 0 ? "padding-right:0" : "padding-left:0", i % 2 === 1 && i < cells.length - 1 ? "padding-right:2em" : "");
+					if (node.lines?.[i] === "solid") style.push("border-right:1px solid");
+					return `<mtd style="${style.filter(Boolean).join(";")}">${toMathML(cell)}</mtd>`;
+				}).join("")}</mtr>`;
+			}).join("");
+			const table = `<mtable${node.small ? " scriptlevel=\"1\"" : ""}>${rows}</mtable>`;
+			if (!node.open && !node.close) return table;
+			return `<mrow>${fence(node.open ?? "", "prefix")}${table}${fence(node.close ?? "", "postfix")}</mrow>`;
+		}
+		case "style": {
+			const a = [];
+			if (node.display !== void 0) a.push(`displaystyle="${node.display}"`);
+			if (node.scriptLevel !== void 0) a.push(`scriptlevel="${node.scriptLevel}"`);
+			if (node.color) a.push(`style="color:${escape(node.color)}"`);
+			return `<mrow ${a.join(" ")}>${toMathML(node.body)}</mrow>`;
+		}
+		case "phantom": return `<mphantom>${toMathML(node.body)}</mphantom>`;
+		case "boxed": return `<mrow style="border:1px solid;padding:0.15em 0.3em">${toMathML(node.body)}</mrow>`;
+	}
+}
+/** A row's children; a function name followed by its argument gets the invisible application sign. */
+function rowChildren(children) {
+	return children.map((c, i) => toMathML(c) + (c.type === "ident" && isFunction(c) && i < children.length - 1 ? APPLY : "")).join("");
+}
+function isFunction(node) {
+	return node.type === "ident" && node.upright === true && [...node.text].length > 1;
+}
+function alignOf(node, i) {
+	const a = node.aligned ? i % 2 === 0 ? "r" : "l" : node.align[Math.min(i, node.align.length - 1)] ?? "c";
+	return a === "l" ? "left" : a === "r" ? "right" : "center";
+}
+function fence(text, form) {
+	if (text === "") return "";
+	return `<mo fence="true" form="${form}" stretchy="true" symmetric="true">${escape(text)}</mo>`;
+}
+// src/fonts.ts
+/** Where a style's capitals, small letters and digits start (null: no digits in that style). */
+var BASES = {
+	bold: {
+		upper: 119808,
+		lower: 119834,
+		digit: 120782
+	},
+	italic: {
+		upper: 119860,
+		lower: 119886,
+		digit: null
+	},
+	"bold-italic": {
+		upper: 119912,
+		lower: 119938,
+		digit: 120782
+	},
+	script: {
+		upper: 119964,
+		lower: 119990,
+		digit: null
+	},
+	"bold-script": {
+		upper: 120016,
+		lower: 120042,
+		digit: 120782
+	},
+	fraktur: {
+		upper: 120068,
+		lower: 120094,
+		digit: null
+	},
+	"double-struck": {
+		upper: 120120,
+		lower: 120146,
+		digit: 120792
+	},
+	"bold-fraktur": {
+		upper: 120172,
+		lower: 120198,
+		digit: 120782
+	},
+	"sans-serif": {
+		upper: 120224,
+		lower: 120250,
+		digit: 120802
+	},
+	"bold-sans-serif": {
+		upper: 120276,
+		lower: 120302,
+		digit: 120812
+	},
+	"sans-serif-italic": {
+		upper: 120328,
+		lower: 120354,
+		digit: 120802
+	},
+	monospace: {
+		upper: 120432,
+		lower: 120458,
+		digit: 120822
+	}
+};
+/** The letters Unicode had before the block: their place in it is empty. */
+var HOLES = {
+	italic: { h: "ℎ" },
+	script: {
+		B: "ℬ",
+		E: "ℰ",
+		F: "ℱ",
+		H: "ℋ",
+		I: "ℐ",
+		L: "ℒ",
+		M: "ℳ",
+		R: "ℛ",
+		e: "ℯ",
+		g: "ℊ",
+		o: "ℴ"
+	},
+	fraktur: {
+		C: "ℭ",
+		H: "ℌ",
+		I: "ℑ",
+		R: "ℜ",
+		Z: "ℨ"
+	},
+	"double-struck": {
+		C: "ℂ",
+		H: "ℍ",
+		N: "ℕ",
+		P: "ℙ",
+		Q: "ℚ",
+		R: "ℝ",
+		Z: "ℤ"
+	}
+};
+/** Bold and bold italic Greek: where capitals Α–Ω and small α–ω start. */
+var GREEK = {
+	bold: {
+		upper: 120488,
+		lower: 120514
+	},
+	"bold-italic": {
+		upper: 120604,
+		lower: 120630
+	}
+};
+/** A text in a letter style: Latin letters and digits mapped, anything else as it is. */
+function styled(text, font) {
+	if (font === "normal") return text;
+	const base = BASES[font];
+	const holes = HOLES[font] ?? {};
+	const greek = GREEK[font];
+	let out = "";
+	for (const ch of text) {
+		const code = ch.codePointAt(0);
+		if (holes[ch]) out += holes[ch];
+		else if (code >= 65 && code <= 90) out += String.fromCodePoint(base.upper + code - 65);
+		else if (code >= 97 && code <= 122) out += String.fromCodePoint(base.lower + code - 97);
+		else if (code >= 48 && code <= 57 && base.digit !== null) out += String.fromCodePoint(base.digit + code - 48);
+		else if (greek && code >= 913 && code <= 937) out += String.fromCodePoint(greek.upper + code - 913);
+		else if (greek && code >= 945 && code <= 969) out += String.fromCodePoint(greek.lower + code - 945);
+		else out += ch;
+	}
+	return out;
+}
+/** The style a command sets. */
+var FONT_COMMANDS = {
+	mathrm: "normal",
+	mathup: "normal",
+	textrm: "normal",
+	mathbf: "bold",
+	textbf: "bold",
+	bf: "bold",
+	mathit: "italic",
+	textit: "italic",
+	mathbb: "double-struck",
+	Bbb: "double-struck",
+	mathcal: "script",
+	mathscr: "script",
+	mathfrak: "fraktur",
+	mathsf: "sans-serif",
+	textsf: "sans-serif",
+	mathtt: "monospace",
+	texttt: "monospace",
+	boldsymbol: "bold-italic",
+	bm: "bold-italic",
+	pmb: "bold-italic",
+	mathbfit: "bold-italic",
+	mathsfit: "sans-serif-italic"
+};
+// src/symbols.ts
+/**
+* What a TeX command is: a letter, an operator, a relation, a big operator,
+* a function name, a delimiter. Each maps to the character it stands for.
+*/
+/** Greek letters and other letter-like symbols: identifiers. */
+var LETTERS = {
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ϵ",
+	varepsilon: "ε",
+	zeta: "ζ",
+	eta: "η",
+	theta: "θ",
+	vartheta: "ϑ",
+	iota: "ι",
+	kappa: "κ",
+	varkappa: "ϰ",
+	lambda: "λ",
+	mu: "μ",
+	nu: "ν",
+	xi: "ξ",
+	omicron: "ο",
+	pi: "π",
+	varpi: "ϖ",
+	rho: "ρ",
+	varrho: "ϱ",
+	sigma: "σ",
+	varsigma: "ς",
+	tau: "τ",
+	upsilon: "υ",
+	phi: "ϕ",
+	varphi: "φ",
+	chi: "χ",
+	psi: "ψ",
+	omega: "ω",
+	digamma: "ϝ",
+	Gamma: "Γ",
+	Delta: "Δ",
+	Theta: "Θ",
+	Lambda: "Λ",
+	Xi: "Ξ",
+	Pi: "Π",
+	Sigma: "Σ",
+	Upsilon: "Υ",
+	Phi: "Φ",
+	Psi: "Ψ",
+	Omega: "Ω",
+	varGamma: "𝛤",
+	varDelta: "𝛥",
+	varTheta: "𝛩",
+	varLambda: "𝛬",
+	varXi: "𝛯",
+	varPi: "𝛱",
+	varSigma: "𝛴",
+	varUpsilon: "𝛶",
+	varPhi: "𝛷",
+	varPsi: "𝛹",
+	varOmega: "𝛺",
+	aleph: "ℵ",
+	beth: "ℶ",
+	gimel: "ℷ",
+	hbar: "ℏ",
+	hslash: "ℏ",
+	ell: "ℓ",
+	wp: "℘",
+	Re: "ℜ",
+	Im: "ℑ",
+	imath: "ı",
+	jmath: "ȷ",
+	partial: "∂",
+	infty: "∞",
+	nabla: "∇",
+	emptyset: "∅",
+	varnothing: "⌀",
+	top: "⊤",
+	bot: "⊥",
+	angle: "∠",
+	measuredangle: "∡",
+	triangle: "△",
+	square: "□",
+	Box: "□",
+	blacksquare: "■",
+	diamond: "⋄",
+	Diamond: "◊",
+	lozenge: "◊",
+	clubsuit: "♣",
+	diamondsuit: "♢",
+	heartsuit: "♡",
+	spadesuit: "♠",
+	flat: "♭",
+	natural: "♮",
+	sharp: "♯",
+	prime: "′",
+	backprime: "‵",
+	degree: "°",
+	checkmark: "✓",
+	dagger: "†",
+	ddagger: "‡",
+	S: "§",
+	P: "¶",
+	copyright: "©",
+	pounds: "£",
+	euro: "€"
+};
+/** Binary operators: spaced as operations. */
+var BINARY = {
+	pm: "±",
+	mp: "∓",
+	times: "×",
+	div: "÷",
+	cdot: "⋅",
+	ast: "∗",
+	star: "⋆",
+	circ: "∘",
+	bullet: "∙",
+	cap: "∩",
+	cup: "∪",
+	uplus: "⊎",
+	sqcap: "⊓",
+	sqcup: "⊔",
+	wedge: "∧",
+	land: "∧",
+	vee: "∨",
+	lor: "∨",
+	setminus: "∖",
+	smallsetminus: "∖",
+	oplus: "⊕",
+	ominus: "⊖",
+	otimes: "⊗",
+	oslash: "⊘",
+	odot: "⊙",
+	dagger: "†",
+	ddagger: "‡",
+	amalg: "⨿",
+	wr: "≀",
+	triangleleft: "◃",
+	triangleright: "▹",
+	bigtriangleup: "△",
+	bigtriangledown: "▽",
+	diamond: "⋄",
+	ltimes: "⋉",
+	rtimes: "⋊",
+	cdotp: "⋅",
+	centerdot: "⋅",
+	dotplus: "∔",
+	boxplus: "⊞",
+	boxminus: "⊟",
+	boxtimes: "⊠"
+};
+/** Relations and arrows. */
+var RELATIONS = {
+	le: "≤",
+	leq: "≤",
+	ge: "≥",
+	geq: "≥",
+	leqslant: "⩽",
+	geqslant: "⩾",
+	ne: "≠",
+	neq: "≠",
+	lt: "<",
+	gt: ">",
+	ll: "≪",
+	gg: "≫",
+	lll: "⋘",
+	ggg: "⋙",
+	approx: "≈",
+	approxeq: "≊",
+	equiv: "≡",
+	sim: "∼",
+	simeq: "≃",
+	cong: "≅",
+	propto: "∝",
+	doteq: "≐",
+	triangleq: "≜",
+	coloneqq: "≔",
+	eqqcolon: "≕",
+	asymp: "≍",
+	prec: "≺",
+	succ: "≻",
+	preceq: "⪯",
+	succeq: "⪰",
+	lesssim: "≲",
+	gtrsim: "≳",
+	in: "∈",
+	notin: "∉",
+	ni: "∋",
+	owns: "∋",
+	subset: "⊂",
+	supset: "⊃",
+	subseteq: "⊆",
+	supseteq: "⊇",
+	subsetneq: "⊊",
+	supsetneq: "⊋",
+	nsubseteq: "⊈",
+	nsupseteq: "⊉",
+	sqsubset: "⊏",
+	sqsupset: "⊐",
+	sqsubseteq: "⊑",
+	sqsupseteq: "⊒",
+	mid: "∣",
+	nmid: "∤",
+	parallel: "∥",
+	nparallel: "∦",
+	perp: "⊥",
+	vdash: "⊢",
+	dashv: "⊣",
+	models: "⊨",
+	vDash: "⊨",
+	Vdash: "⊩",
+	smile: "⌣",
+	frown: "⌢",
+	bowtie: "⋈",
+	nless: "≮",
+	ngtr: "≯",
+	nleq: "≰",
+	ngeq: "≱",
+	nsim: "≁",
+	ncong: "≇",
+	therefore: "∴",
+	because: "∵",
+	to: "→",
+	rightarrow: "→",
+	leftarrow: "←",
+	gets: "←",
+	leftrightarrow: "↔",
+	Rightarrow: "⇒",
+	Leftarrow: "⇐",
+	Leftrightarrow: "⇔",
+	implies: "⟹",
+	impliedby: "⟸",
+	iff: "⟺",
+	mapsto: "↦",
+	longmapsto: "⟼",
+	longrightarrow: "⟶",
+	longleftarrow: "⟵",
+	longleftrightarrow: "⟷",
+	Longrightarrow: "⟹",
+	Longleftarrow: "⟸",
+	Longleftrightarrow: "⟺",
+	uparrow: "↑",
+	downarrow: "↓",
+	updownarrow: "↕",
+	Uparrow: "⇑",
+	Downarrow: "⇓",
+	Updownarrow: "⇕",
+	nearrow: "↗",
+	searrow: "↘",
+	swarrow: "↙",
+	nwarrow: "↖",
+	hookrightarrow: "↪",
+	hookleftarrow: "↩",
+	rightharpoonup: "⇀",
+	rightharpoondown: "⇁",
+	leftharpoonup: "↼",
+	leftharpoondown: "↽",
+	rightleftharpoons: "⇌",
+	leftrightharpoons: "⇋",
+	rightrightarrows: "⇉",
+	leftleftarrows: "⇇",
+	twoheadrightarrow: "↠",
+	rightsquigarrow: "⇝",
+	leadsto: "⇝",
+	nrightarrow: "↛",
+	nleftarrow: "↚",
+	nRightarrow: "⇏",
+	nLeftarrow: "⇍",
+	circlearrowleft: "↺",
+	circlearrowright: "↻"
+};
+/** Punctuation that TeX treats as such, and the dots. */
+var PUNCT = {
+	colon: ":",
+	ldots: "…",
+	dots: "…",
+	dotsc: "…",
+	dotso: "…",
+	cdots: "⋯",
+	dotsb: "⋯",
+	dotsm: "⋯",
+	dotsi: "⋯",
+	vdots: "⋮",
+	ddots: "⋱",
+	iddots: "⋰",
+	forall: "∀",
+	exists: "∃",
+	nexists: "∄",
+	neg: "¬",
+	lnot: "¬",
+	complement: "∁"
+};
+/** Big operators: limits above and below in display, beside inline. */
+var LARGE = {
+	sum: "∑",
+	prod: "∏",
+	coprod: "∐",
+	bigcup: "⋃",
+	bigcap: "⋂",
+	bigsqcup: "⨆",
+	bigvee: "⋁",
+	bigwedge: "⋀",
+	bigoplus: "⨁",
+	bigotimes: "⨂",
+	bigodot: "⨀",
+	biguplus: "⨄"
+};
+/** Integrals: limits beside them unless `\limits`. */
+var INTEGRALS = {
+	int: "∫",
+	iint: "∬",
+	iiint: "∭",
+	iiiint: "⨌",
+	oint: "∮",
+	oiint: "∯",
+	oiiint: "∰",
+	intop: "∫",
+	smallint: "∫"
+};
+/** Function names set upright; the ones with limits take them under in display. */
+var FUNCTIONS = /* @__PURE__ */ new Set([
+	"sin",
+	"cos",
+	"tan",
+	"cot",
+	"sec",
+	"csc",
+	"arcsin",
+	"arccos",
+	"arctan",
+	"arccot",
+	"sinh",
+	"cosh",
+	"tanh",
+	"coth",
+	"sech",
+	"csch",
+	"log",
+	"ln",
+	"lg",
+	"exp",
+	"arg",
+	"deg",
+	"dim",
+	"hom",
+	"ker",
+	"sgn",
+	"tg",
+	"ctg",
+	"arctg",
+	"arcctg",
+	"sh",
+	"ch",
+	"th",
+	"cth"
+]);
+var LIMIT_FUNCTIONS = /* @__PURE__ */ new Set([
+	"lim",
+	"limsup",
+	"liminf",
+	"max",
+	"min",
+	"sup",
+	"inf",
+	"det",
+	"gcd",
+	"lcm",
+	"Pr",
+	"argmax",
+	"argmin",
+	"injlim",
+	"projlim"
+]);
+/** How a function name is written when it differs from the command. */
+var FUNCTION_TEXT = {
+	limsup: "lim sup",
+	liminf: "lim inf",
+	argmax: "arg max",
+	argmin: "arg min",
+	injlim: "inj lim",
+	projlim: "proj lim"
+};
+/** Delimiters, for `\left`, `\right`, `\big` and as they are. */
+var DELIMITERS = {
+	"(": "(",
+	")": ")",
+	"[": "[",
+	"]": "]",
+	"\\{": "{",
+	"\\}": "}",
+	lbrace: "{",
+	rbrace: "}",
+	"|": "|",
+	"\\|": "‖",
+	"/": "/",
+	"\\backslash": "∖",
+	backslash: "∖",
+	langle: "⟨",
+	rangle: "⟩",
+	lfloor: "⌊",
+	rfloor: "⌋",
+	lceil: "⌈",
+	rceil: "⌉",
+	lvert: "|",
+	rvert: "|",
+	vert: "|",
+	lVert: "‖",
+	rVert: "‖",
+	Vert: "‖",
+	lbrack: "[",
+	rbrack: "]",
+	lgroup: "⟮",
+	rgroup: "⟯",
+	lmoustache: "⎰",
+	rmoustache: "⎱",
+	uparrow: "↑",
+	downarrow: "↓",
+	updownarrow: "↕",
+	Uparrow: "⇑",
+	Downarrow: "⇓",
+	Updownarrow: "⇕",
+	"<": "⟨",
+	">": "⟩",
+	".": ""
+};
+/** Opening delimiters among them: the rest close. */
+var OPENING = /* @__PURE__ */ new Set([
+	"(",
+	"[",
+	"{",
+	"⟨",
+	"⌊",
+	"⌈",
+	"⟮",
+	"⎰"
+]);
+/** Accents over (and under) a base: the mark and whether it stretches over a wide base. */
+var ACCENTS = {
+	hat: {
+		mark: "^",
+		stretchy: false
+	},
+	widehat: {
+		mark: "^",
+		stretchy: true
+	},
+	check: {
+		mark: "ˇ",
+		stretchy: false
+	},
+	widecheck: {
+		mark: "ˇ",
+		stretchy: true
+	},
+	tilde: {
+		mark: "~",
+		stretchy: false
+	},
+	widetilde: {
+		mark: "~",
+		stretchy: true
+	},
+	bar: {
+		mark: "¯",
+		stretchy: false
+	},
+	overline: {
+		mark: "‾",
+		stretchy: true
+	},
+	vec: {
+		mark: "→",
+		stretchy: false
+	},
+	overrightarrow: {
+		mark: "→",
+		stretchy: true
+	},
+	overleftarrow: {
+		mark: "←",
+		stretchy: true
+	},
+	overleftrightarrow: {
+		mark: "↔",
+		stretchy: true
+	},
+	dot: {
+		mark: "˙",
+		stretchy: false
+	},
+	ddot: {
+		mark: "¨",
+		stretchy: false
+	},
+	dddot: {
+		mark: "⃛",
+		stretchy: false
+	},
+	acute: {
+		mark: "´",
+		stretchy: false
+	},
+	grave: {
+		mark: "`",
+		stretchy: false
+	},
+	breve: {
+		mark: "˘",
+		stretchy: false
+	},
+	mathring: {
+		mark: "˚",
+		stretchy: false
+	},
+	overbrace: {
+		mark: "⏞",
+		stretchy: true
+	},
+	underbrace: {
+		mark: "⏟",
+		stretchy: true,
+		under: true
+	},
+	underline: {
+		mark: "_",
+		stretchy: true,
+		under: true
+	},
+	underrightarrow: {
+		mark: "→",
+		stretchy: true,
+		under: true
+	},
+	underleftarrow: {
+		mark: "←",
+		stretchy: true,
+		under: true
+	}
+};
+/** Spaces, in em. */
+var SPACES = {
+	",": 3 / 18,
+	thinspace: 3 / 18,
+	":": 4 / 18,
+	">": 4 / 18,
+	medspace: 4 / 18,
+	";": 5 / 18,
+	thickspace: 5 / 18,
+	"!": -3 / 18,
+	negthinspace: -3 / 18,
+	negmedspace: -4 / 18,
+	negthickspace: -5 / 18,
+	quad: 1,
+	qquad: 2,
+	" ": 1 / 3,
+	enspace: .5,
+	enskip: .5
+};
+/** `\big` and its kin: the delimiter's height, in em. */
+var SIZES = {
+	big: 1.2,
+	bigl: 1.2,
+	bigr: 1.2,
+	bigm: 1.2,
+	Big: 1.8,
+	Bigl: 1.8,
+	Bigr: 1.8,
+	Bigm: 1.8,
+	bigg: 2.4,
+	biggl: 2.4,
+	biggr: 2.4,
+	biggm: 2.4,
+	Bigg: 3,
+	Biggl: 3,
+	Biggr: 3,
+	Biggm: 3
+};
+/** A character typed as it is: its kind. */
+function charKind(ch) {
+	if ("+-*".includes(ch)) return "bin";
+	if ("=<>:".includes(ch)) return "rel";
+	if ("([{".includes(ch)) return "open";
+	if (")]}".includes(ch)) return "close";
+	if (",;".includes(ch)) return "punct";
+	return "ord";
+}
+// src/parser.ts
+var MathError = class extends Error {
+	position;
+	constructor(message, position) {
+		super(message);
+		this.position = position;
+		this.name = "MathError";
+	}
+};
+/** How deep groups may nest, how long a formula may be, how many times macros may expand. */
+var MAX_DEPTH = 256;
+var MAX_TOKENS = 2e4;
+var MAX_EXPANSIONS = 2e3;
+function tokenize(tex, offset = 0) {
+	const out = [];
+	let i = 0;
+	while (i < tex.length) {
+		const ch = tex[i];
+		if (ch === "\\") {
+			const name = /^[a-zA-Z]+/.exec(tex.slice(i + 1))?.[0];
+			if (name) {
+				out.push({
+					kind: "command",
+					value: name,
+					pos: offset + i
+				});
+				i += 1 + name.length;
+			} else if (i + 1 < tex.length) {
+				out.push({
+					kind: "command",
+					value: tex[i + 1],
+					pos: offset + i
+				});
+				i += 2;
+			} else throw new MathError("A backslash at the end", offset + i);
+		} else if (ch === "%") {
+			const end = tex.indexOf("\n", i);
+			i = end < 0 ? tex.length : end + 1;
+		} else if (/\s/.test(ch)) {
+			const start = i;
+			while (i < tex.length && /\s/.test(tex[i])) i++;
+			out.push({
+				kind: "space",
+				value: " ",
+				pos: offset + start
+			});
+		} else {
+			const cp = tex.codePointAt(i);
+			const s = String.fromCodePoint(cp);
+			out.push({
+				kind: "char",
+				value: s,
+				pos: offset + i
+			});
+			i += s.length;
+		}
+		if (out.length > MAX_TOKENS) throw new MathError("The formula is too long", offset + i);
+	}
+	return out;
+}
+var NEGATED = {
+	"=": "≠",
+	"<": "≮",
+	">": "≯",
+	"≤": "≰",
+	"≥": "≱",
+	"∈": "∉",
+	"∋": "∌",
+	"⊂": "⊄",
+	"⊃": "⊅",
+	"⊆": "⊈",
+	"⊇": "⊉",
+	"∼": "≁",
+	"≅": "≇",
+	"≈": "≉",
+	"≡": "≢",
+	"∣": "∤",
+	"∥": "∦",
+	"→": "↛",
+	"←": "↚",
+	"⇒": "⇏",
+	"⇐": "⇍",
+	"⇔": "⇎",
+	"↔": "↮"
+};
+var ENVIRONMENTS = {
+	matrix: { align: ["c"] },
+	pmatrix: {
+		align: ["c"],
+		open: "(",
+		close: ")"
+	},
+	bmatrix: {
+		align: ["c"],
+		open: "[",
+		close: "]"
+	},
+	Bmatrix: {
+		align: ["c"],
+		open: "{",
+		close: "}"
+	},
+	vmatrix: {
+		align: ["c"],
+		open: "|",
+		close: "|"
+	},
+	Vmatrix: {
+		align: ["c"],
+		open: "‖",
+		close: "‖"
+	},
+	smallmatrix: {
+		align: ["c"],
+		small: true
+	},
+	cases: {
+		align: ["l", "l"],
+		open: "{"
+	},
+	dcases: {
+		align: ["l", "l"],
+		open: "{",
+		display: true
+	},
+	rcases: {
+		align: ["l", "l"],
+		close: "}"
+	},
+	aligned: {
+		aligned: true,
+		display: true
+	},
+	align: {
+		aligned: true,
+		display: true
+	},
+	"align*": {
+		aligned: true,
+		display: true
+	},
+	alignat: {
+		aligned: true,
+		display: true
+	},
+	"alignat*": {
+		aligned: true,
+		display: true
+	},
+	alignedat: {
+		aligned: true,
+		display: true
+	},
+	split: {
+		aligned: true,
+		display: true
+	},
+	eqnarray: {
+		align: [
+			"r",
+			"c",
+			"l"
+		],
+		display: true
+	},
+	"eqnarray*": {
+		align: [
+			"r",
+			"c",
+			"l"
+		],
+		display: true
+	},
+	gathered: {
+		align: ["c"],
+		display: true
+	},
+	gather: {
+		align: ["c"],
+		display: true
+	},
+	"gather*": {
+		align: ["c"],
+		display: true
+	},
+	multline: {
+		align: ["c"],
+		display: true
+	},
+	"multline*": {
+		align: ["c"],
+		display: true
+	},
+	equation: {
+		align: ["c"],
+		display: true
+	},
+	"equation*": {
+		align: ["c"],
+		display: true
+	},
+	array: {},
+	darray: { display: true },
+	subarray: { small: true }
+};
+/** A colour as CSS takes it safely: a name or a hex value. */
+function safeColor(value, pos) {
+	const v = value.trim();
+	if (/^[a-zA-Z]{1,32}$/.test(v)) return v;
+	if (/^#?[0-9a-fA-F]{3,8}$/.test(v)) return v.startsWith("#") ? v : `#${v}`;
+	throw new MathError(`Not a colour: ${v}`, pos);
+}
+/** A TeX length in em (`1em`, `3mu`, `2pt`, `1ex`, `0.5cm`). */
+function emOf(value, pos) {
+	const m = /^\s*(-?\d*\.?\d+)\s*(em|ex|mu|pt|px|mm|cm|in)\s*$/.exec(value);
+	if (!m) throw new MathError(`Not a length: ${value}`, pos);
+	return Number(m[1]) * {
+		em: 1,
+		ex: .43,
+		mu: 1 / 18,
+		pt: 1 / 10,
+		px: 1 / 16,
+		mm: .284,
+		cm: 2.84,
+		in: 7.23
+	}[m[2]];
+}
+var Parser = class {
+	tex;
+	tokens;
+	i = 0;
+	depth = 0;
+	expansions = 0;
+	font = null;
+	/** In a display formula: big operators take limits under and over. */
+	macros;
+	constructor(tex, options = {}) {
+		this.tex = tex;
+		this.tokens = tokenize(tex);
+		this.macros = options.macros ?? {};
+	}
+	/** The whole formula; rows (`\\`) and columns (`&`) at the top make a table of aligned or gathered lines. */
+	parse() {
+		const rows = this.rows("eof");
+		if (rows.length === 1 && rows[0].length === 1) return rows[0][0];
+		return Math.max(...rows.map((r) => r.length)) > 1 ? {
+			type: "table",
+			rows: rows.map((r) => r.map((c) => this.display(c))),
+			align: ["r", "l"],
+			aligned: true
+		} : {
+			type: "table",
+			rows: rows.map((r) => r.map((c) => this.display(c))),
+			align: ["c"]
+		};
+	}
+	display(node) {
+		return {
+			type: "style",
+			body: node,
+			display: true
+		};
+	}
+	peek(skipSpace = true) {
+		if (skipSpace) while (this.tokens[this.i]?.kind === "space") this.i++;
+		return this.tokens[this.i];
+	}
+	next(skipSpace = true) {
+		const t = this.peek(skipSpace);
+		if (t) this.i++;
+		return t;
+	}
+	pos() {
+		return this.tokens[this.i]?.pos ?? this.tex.length;
+	}
+	isChar(t, ch) {
+		return !!t && t.kind === "char" && t.value === ch;
+	}
+	isCommand(t, name) {
+		return !!t && t.kind === "command" && t.value === name;
+	}
+	expect(ch) {
+		const t = this.next();
+		if (!this.isChar(t, ch)) throw new MathError(`Expected "${ch}"`, t?.pos ?? this.tex.length);
+	}
+	enter() {
+		if (++this.depth > MAX_DEPTH) throw new MathError("Nested too deeply", this.pos());
+	}
+	/** Atoms until the stop; what `\color` and `\displaystyle` change runs to it too. */
+	expression(stop) {
+		const out = [];
+		for (;;) {
+			const t = this.peek();
+			if (!t) {
+				if (stop === "eof" || stop === "cell") return out;
+				throw new MathError(stop === "}" ? "A \"{\" is not closed" : stop === "right" ? "\\left without \\right" : stop === "end" ? "An environment is not ended" : `Expected "${stop}"`, this.tex.length);
+			}
+			if (this.isChar(t, "}")) {
+				if (stop === "}") return out;
+				if (stop === "cell" || stop === "eof") throw new MathError("An unmatched \"}\"", t.pos);
+				throw new MathError("An unmatched \"}\"", t.pos);
+			}
+			if (stop === "]" && this.isChar(t, "]")) return out;
+			if (stop === "right" && (this.isCommand(t, "right") || this.isCommand(t, "middle"))) return out;
+			if ((stop === "cell" || stop === "eof" || stop === "end") && (this.isChar(t, "&") || this.isCommand(t, "\\") || this.isCommand(t, "cr") || this.isCommand(t, "end"))) {
+				if (this.isCommand(t, "end") && stop === "eof") throw new MathError("\\end without \\begin", t.pos);
+				return out;
+			}
+			if (t.kind === "command" && (t.value === "color" || t.value in STYLE_SWITCHES)) {
+				this.i++;
+				const style = t.value === "color" ? { color: safeColor(this.textArgument(), t.pos) } : STYLE_SWITCHES[t.value];
+				out.push({
+					type: "style",
+					body: row(this.expression(stop)),
+					...style
+				});
+				return out;
+			}
+			const atom = this.atomWithScripts();
+			if (atom) out.push(atom);
+		}
+	}
+	/** Rows of cells, up to the stop: for environments and the top. */
+	rows(stop) {
+		const rows = [[]];
+		for (;;) {
+			const cell = row(this.expression(stop === "end" ? "cell" : "eof"));
+			rows[rows.length - 1].push(cell);
+			const t = this.peek();
+			if (this.isChar(t, "&")) {
+				this.i++;
+				continue;
+			}
+			if (this.isCommand(t, "\\") || this.isCommand(t, "cr")) {
+				this.i++;
+				if (this.isChar(this.peek(), "[")) this.textUntil("]");
+				const after = this.peek();
+				if (!after || this.isCommand(after, "end")) continue;
+				rows.push([]);
+				continue;
+			}
+			if (stop === "end") {
+				if (!this.isCommand(t, "end")) throw new MathError("An environment is not ended", this.pos());
+			}
+			return rows.filter((r, i) => i === 0 || r.length > 1 || !isEmpty(r[0]));
+		}
+	}
+	/** One atom and its scripts: `x`, `x_1^2`, `f'`, `\sum_{i=1}^n`. */
+	atomWithScripts() {
+		this.pos();
+		let base = this.atom();
+		let sub;
+		let sup;
+		let primes = "";
+		let limits;
+		for (;;) {
+			const t = this.peek();
+			if (this.isChar(t, "^") || this.isChar(t, "_")) {
+				this.i++;
+				const which = t.value === "^" ? "sup" : "sub";
+				if ((which === "sup" ? sup : sub) !== void 0) throw new MathError(`Double ${which === "sup" ? "superscript" : "subscript"}`, t.pos);
+				const arg = this.argument();
+				if (which === "sup") sup = arg;
+				else sub = arg;
+			} else if (this.isChar(t, "'")) {
+				this.i++;
+				primes += "′";
+			} else if (this.isCommand(t, "limits") || this.isCommand(t, "nolimits")) {
+				this.i++;
+				limits = t.value === "limits";
+			} else break;
+		}
+		if (primes) sup = sup ? row([op(primes, "ord"), sup]) : op(primes, "ord");
+		if (!sub && !sup) return base;
+		base ??= row([]);
+		const over = limits ?? takesLimits(base);
+		if (base.type === "op" && base.kind === "large" && limits === false) base = {
+			...base,
+			movableLimits: false
+		};
+		return {
+			type: "scripts",
+			base,
+			sub,
+			sup,
+			over
+		};
+	}
+	/** A script's or a command's argument: a group, or one token. */
+	argument() {
+		const t = this.peek();
+		if (!t) throw new MathError("An argument is missing", this.tex.length);
+		if (this.isChar(t, "{")) return this.group();
+		if (this.isChar(t, "}") || this.isChar(t, "&") || this.isChar(t, "^") || this.isChar(t, "_")) throw new MathError("An argument is missing", t.pos);
+		const atom = this.atom(true);
+		if (!atom) throw new MathError("An argument is missing", t.pos);
+		return atom;
+	}
+	group() {
+		this.expect("{");
+		this.enter();
+		const font = this.font;
+		const body = this.expression("}");
+		this.font = font;
+		this.depth--;
+		this.expect("}");
+		return row(body);
+	}
+	/** An argument read as plain text (a colour, a name, a length, an environment). */
+	textArgument() {
+		const t = this.peek();
+		if (this.isChar(t, "{")) {
+			this.i++;
+			return this.textUntil("}", false);
+		}
+		const one = this.next();
+		if (!one) throw new MathError("An argument is missing", this.tex.length);
+		return one.value;
+	}
+	/** A length: in braces, or written on (`\\mkern18mu`, `\\kern-1em`). */
+	dimension() {
+		if (this.isChar(this.peek(), "{")) return this.textArgument();
+		let out = "";
+		while (this.tokens[this.i]?.kind === "char" && /^-?\d*\.?\d*[a-z]{0,2}$/.test(out + this.tokens[this.i].value)) out += this.tokens[this.i++].value;
+		return out;
+	}
+	/** The raw text up to a closing character (after its opening one, or the `[` here), groups inside kept balanced. */
+	textUntil(close, opening = true) {
+		if (opening) this.i++;
+		let out = "";
+		let level = 0;
+		for (;;) {
+			const t = this.next(false);
+			if (!t) throw new MathError(`Expected "${close}"`, this.tex.length);
+			if (t.kind === "char" && t.value === "{") level++;
+			if (t.kind === "char" && t.value === "}" && level > 0) level--;
+			else if (t.kind === "char" && t.value === close && level === 0) return out;
+			out += t.kind === "command" ? `\\${t.value}` : t.value;
+		}
+	}
+	/** A single atom (no scripts); null for a token that makes nothing (`\limits` alone, a stray space). */
+	atom(single = false) {
+		const t = this.next();
+		if (!t) return null;
+		this.enter();
+		try {
+			return t.kind === "char" ? this.character(t, single) : this.command(t);
+		} finally {
+			this.depth--;
+		}
+	}
+	character(t, single) {
+		const ch = t.value;
+		if (ch === "{") {
+			this.i--;
+			return this.group();
+		}
+		if (ch === "^" || ch === "_") {
+			this.i--;
+			return row([]);
+		}
+		if (ch === "~") return {
+			type: "space",
+			width: 1 / 3
+		};
+		if (ch === "&") throw new MathError("\"&\" outside a table", t.pos);
+		if (ch === "#") throw new MathError("\"#\" outside a macro", t.pos);
+		if (ch === "$") throw new MathError("\"$\" inside a formula", t.pos);
+		if (/[0-9]/.test(ch)) {
+			let text = ch;
+			while (!single) {
+				const n = this.tokens[this.i];
+				if (n?.kind === "char" && /[0-9]/.test(n.value)) text += n.value;
+				else if (n?.kind === "char" && n.value === "." && /[0-9]/.test(this.tokens[this.i + 1]?.value ?? "") && !text.includes(".")) text += n.value;
+				else break;
+				this.i++;
+			}
+			return {
+				type: "number",
+				text: this.font ? styled(text, this.font) : text
+			};
+		}
+		if (/\p{L}/u.test(ch)) {
+			if (this.font && !single) {
+				let text = ch;
+				while (this.tokens[this.i]?.kind === "char" && /\p{L}/u.test(this.tokens[this.i].value)) text += this.tokens[this.i++].value;
+				return this.font === "normal" ? {
+					type: "ident",
+					text,
+					upright: true
+				} : {
+					type: "ident",
+					text: styled(text, this.font)
+				};
+			}
+			return this.font === "normal" ? {
+				type: "ident",
+				text: ch,
+				upright: true
+			} : {
+				type: "ident",
+				text: this.font ? styled(ch, this.font) : ch
+			};
+		}
+		const kind = charKind(ch);
+		if (ch === "-") return op("−", "bin");
+		if (ch === "*") return op("∗", "bin");
+		if (ch === "|" || ch === "/") return op(ch, "ord");
+		return op(ch, kind);
+	}
+	command(t) {
+		const name = t.value;
+		const macro = this.macros[name];
+		if (macro !== void 0) return this.expand(t, macro);
+		if (name in LETTERS) return {
+			type: "ident",
+			text: this.font && this.font !== "normal" ? styled(LETTERS[name], this.font) : LETTERS[name]
+		};
+		if (name in BINARY) return op(BINARY[name], "bin");
+		if (name in RELATIONS) return op(RELATIONS[name], "rel");
+		if (name in PUNCT) return op(PUNCT[name], name === "colon" ? "punct" : "ord");
+		if (name in LARGE) return {
+			type: "op",
+			text: LARGE[name],
+			kind: "large",
+			movableLimits: true
+		};
+		if (name in INTEGRALS) return {
+			type: "op",
+			text: INTEGRALS[name],
+			kind: "large"
+		};
+		if (FUNCTIONS.has(name)) return {
+			type: "ident",
+			text: name,
+			upright: true
+		};
+		if (LIMIT_FUNCTIONS.has(name)) return {
+			type: "op",
+			text: FUNCTION_TEXT[name] ?? name,
+			kind: "prefix",
+			movableLimits: true
+		};
+		if (name in SPACES) return {
+			type: "space",
+			width: SPACES[name]
+		};
+		if (name.length > 1 && DELIMITERS[name]) {
+			const sign = DELIMITERS[name];
+			return op(sign, OPENING.has(sign) || name.startsWith("l") ? "open" : name === "vert" || name === "Vert" ? "ord" : "close");
+		}
+		if (name in SIZES) return {
+			...this.delimiter(),
+			stretchy: true,
+			size: SIZES[name]
+		};
+		if (name in ACCENTS) {
+			const a = ACCENTS[name];
+			return {
+				type: "accent",
+				base: this.argument(),
+				mark: a.mark,
+				under: a.under,
+				stretchy: a.stretchy
+			};
+		}
+		if (name in FONT_COMMANDS && !name.startsWith("text")) {
+			const font = this.font;
+			this.font = FONT_COMMANDS[name];
+			const body = this.argument();
+			this.font = font;
+			return body;
+		}
+		switch (name) {
+			case "{":
+			case "}": return op(name === "{" ? "{" : "}", name === "{" ? "open" : "close");
+			case "|": return op("‖", "ord");
+			case "#":
+			case "$":
+			case "%":
+			case "&":
+			case "_": return {
+				type: "ident",
+				text: name,
+				upright: true
+			};
+			case " ": return {
+				type: "space",
+				width: 1 / 3
+			};
+			case "\\":
+			case "cr": throw new MathError("A line break outside a table", t.pos);
+			case "frac":
+			case "dfrac":
+			case "tfrac":
+			case "cfrac": return {
+				type: "frac",
+				num: this.argument(),
+				den: this.argument(),
+				style: name === "dfrac" || name === "cfrac" ? "display" : name === "tfrac" ? "text" : void 0
+			};
+			case "binom":
+			case "dbinom":
+			case "tbinom":
+			case "choose": return {
+				type: "fenced",
+				open: "(",
+				close: ")",
+				body: {
+					type: "frac",
+					num: this.argument(),
+					den: this.argument(),
+					thickness: 0,
+					style: name === "dbinom" ? "display" : name === "tbinom" ? "text" : void 0
+				}
+			};
+			case "sqrt": {
+				let index;
+				if (this.isChar(this.peek(), "[")) {
+					this.i++;
+					this.enter();
+					index = row(this.expression("]"));
+					this.depth--;
+					this.expect("]");
+				}
+				return {
+					type: "sqrt",
+					body: this.argument(),
+					index
+				};
+			}
+			case "left": {
+				const open = this.delimiter().text;
+				this.enter();
+				const parts = [];
+				for (;;) {
+					parts.push(...this.expression("right"));
+					const end = this.next();
+					if (this.isCommand(end, "middle")) {
+						parts.push({
+							...this.delimiter(),
+							kind: "rel",
+							stretchy: true
+						});
+						continue;
+					}
+					if (!this.isCommand(end, "right")) throw new MathError("\\left without \\right", t.pos);
+					break;
+				}
+				this.depth--;
+				return {
+					type: "fenced",
+					open,
+					close: this.delimiter().text,
+					body: row(parts)
+				};
+			}
+			case "right": throw new MathError("\\right without \\left", t.pos);
+			case "middle": throw new MathError("\\middle outside \\left … \\right", t.pos);
+			case "text":
+			case "textrm":
+			case "textnormal":
+			case "textup":
+			case "mbox":
+			case "hbox":
+			case "textbf":
+			case "textit":
+			case "textsf":
+			case "texttt":
+			case "textmd": {
+				const text = this.text();
+				const font = FONT_COMMANDS[name];
+				return {
+					type: "text",
+					text: font && font !== "normal" ? styled(text, font) : text
+				};
+			}
+			case "operatorname":
+			case "operatornamewithlimits": {
+				const star = this.isChar(this.tokens[this.i], "*");
+				if (star) this.i++;
+				const text = this.textArgument().replace(/\\,|\\ /g, " ").replace(/[{}\\]/g, "").trim();
+				return star || name === "operatornamewithlimits" ? {
+					type: "op",
+					text,
+					kind: "prefix",
+					movableLimits: true
+				} : {
+					type: "ident",
+					text,
+					upright: true
+				};
+			}
+			case "overset":
+			case "underset":
+			case "stackrel": {
+				const mark = this.argument();
+				const base = this.argument();
+				return name === "underset" ? {
+					type: "scripts",
+					base,
+					sub: mark,
+					over: true
+				} : {
+					type: "scripts",
+					base: { ...base },
+					sup: mark,
+					over: true
+				};
+			}
+			case "not": {
+				const next = this.atom(true);
+				if (next?.type === "op" && NEGATED[next.text]) return {
+					...next,
+					text: NEGATED[next.text],
+					kind: "rel"
+				};
+				if (next?.type === "op" || next?.type === "ident") return {
+					...next,
+					text: next.text + "̸"
+				};
+				return op("/", "rel");
+			}
+			case "mod": return row([
+				{
+					type: "space",
+					width: 1
+				},
+				{
+					type: "ident",
+					text: "mod",
+					upright: true
+				},
+				{
+					type: "space",
+					width: 1 / 3
+				}
+			]);
+			case "bmod": return op("mod", "bin");
+			case "pmod": return row([
+				{
+					type: "space",
+					width: 1
+				},
+				op("(", "open"),
+				{
+					type: "ident",
+					text: "mod",
+					upright: true
+				},
+				{
+					type: "space",
+					width: 1 / 3
+				},
+				this.argument(),
+				op(")", "close")
+			]);
+			case "hspace":
+			case "hskip":
+			case "kern":
+			case "mkern":
+			case "mskip":
+				if (this.isChar(this.tokens[this.i], "*")) this.i++;
+				return {
+					type: "space",
+					width: emOf(this.dimension(), t.pos)
+				};
+			case "textcolor":
+			case "colorbox": {
+				const color = safeColor(this.textArgument(), t.pos);
+				if (name === "colorbox") return {
+					type: "style",
+					color,
+					body: {
+						type: "text",
+						text: this.text()
+					}
+				};
+				return {
+					type: "style",
+					color,
+					body: this.argument()
+				};
+			}
+			case "phantom":
+			case "hphantom":
+			case "vphantom": return {
+				type: "phantom",
+				body: this.argument()
+			};
+			case "boxed": return {
+				type: "boxed",
+				body: this.argument()
+			};
+			case "fbox": return {
+				type: "boxed",
+				body: {
+					type: "text",
+					text: this.text()
+				}
+			};
+			case "begin": return this.environment(t);
+			case "end": throw new MathError("\\end without \\begin", t.pos);
+			case "displaystyle":
+			case "textstyle":
+			case "scriptstyle":
+			case "scriptscriptstyle":
+			case "color": return null;
+			case "label":
+			case "nonumber":
+			case "notag":
+			case "tag":
+			case "hline":
+			case "displaylimits":
+				if (name === "label" || name === "tag") this.textArgument();
+				return null;
+			case "limits":
+			case "nolimits": return null;
+		}
+		throw new MathError(`Unknown command \\${name}`, t.pos);
+	}
+	/** `\text{…}`: the text as written, spaces kept, `\{` and the like as their signs, `$…$` inside as it is. */
+	text() {
+		const t = this.peek();
+		if (!this.isChar(t, "{")) return this.next()?.value ?? "";
+		this.i++;
+		let out = "";
+		let level = 0;
+		for (;;) {
+			const n = this.next(false);
+			if (!n) throw new MathError("A \"{\" is not closed", this.tex.length);
+			if (n.kind === "char" && n.value === "{") {
+				level++;
+				continue;
+			}
+			if (n.kind === "char" && n.value === "}") {
+				if (level === 0) return out.replace(/\s+/g, " ");
+				level--;
+				continue;
+			}
+			if (n.kind === "command") out += n.value === " " || n.value === "," || n.value === ";" || n.value === "quad" ? " " : n.value.length === 1 ? n.value : n.value === "textbackslash" ? "\\" : "";
+			else out += n.value;
+		}
+	}
+	/** A delimiter after `\left`, `\right`, `\big`…: a sign, or a command naming one. */
+	delimiter() {
+		const t = this.next();
+		if (!t) throw new MathError("A delimiter is missing", this.tex.length);
+		const text = DELIMITERS[t.kind === "command" && t.value.length === 1 ? `\\${t.value}` : t.value];
+		if (text === void 0) throw new MathError(`Not a delimiter: ${t.kind === "command" ? "\\" : ""}${t.value}`, t.pos);
+		return {
+			type: "op",
+			text,
+			kind: OPENING.has(text) ? "open" : "close",
+			stretchy: true
+		};
+	}
+	/** `\begin{name} … \end{name}`: a table of the environment's kind. */
+	environment(t) {
+		const name = this.textArgument();
+		const env = ENVIRONMENTS[name];
+		if (!env) throw new MathError(`Unknown environment ${name}`, t.pos);
+		let align = env.align ?? ["c"];
+		let lines;
+		if (name === "array" || name === "darray" || name === "subarray") {
+			const spec = this.textArgument();
+			align = [];
+			lines = [];
+			for (const ch of spec.replace(/@\{[^}]*\}/g, "")) if (ch === "|") {
+				if (align.length > 0) lines[align.length - 1] = "solid";
+			} else if (ch === "l" || ch === "c" || ch === "r") {
+				align.push(ch);
+				lines[align.length - 1] ??= "none";
+			}
+			if (align.length === 0) align = ["c"];
+			lines = lines.slice(0, Math.max(0, align.length - 1)).map((l) => l ?? "none");
+		} else if (name === "alignat" || name === "alignat*" || name === "alignedat") this.textArgument();
+		if (this.isChar(this.peek(), "[")) this.textUntil("]");
+		this.enter();
+		const rows = this.rows("end");
+		this.depth--;
+		const end = this.next();
+		if (!this.isCommand(end, "end")) throw new MathError("An environment is not ended", this.pos());
+		const closing = this.textArgument();
+		if (closing !== name) throw new MathError(`\\begin{${name}} ended by \\end{${closing}}`, end.pos);
+		return {
+			type: "table",
+			rows: env.display ? rows.map((r) => r.map((c) => ({
+				type: "style",
+				body: c,
+				display: true
+			}))) : rows,
+			align,
+			lines: lines && lines.some((l) => l === "solid") ? lines : void 0,
+			aligned: env.aligned,
+			open: env.open,
+			close: env.close,
+			small: env.small
+		};
+	}
+	/** A macro of the writer's: its text, arguments put in, parsed in place. */
+	expand(t, body) {
+		if (++this.expansions > MAX_EXPANSIONS) throw new MathError("Macros expand too many times", t.pos);
+		const count = Math.max(0, ...[...body.matchAll(/#([1-9])/g)].map((m) => Number(m[1])));
+		const args = [];
+		for (let k = 0; k < count; k++) {
+			const a = this.peek();
+			if (!a) throw new MathError(`\\${t.value} takes ${count} arguments`, t.pos);
+			if (this.isChar(a, "{")) {
+				const start = this.i + 1;
+				this.textUntil("}");
+				args.push(this.tokens.slice(start, this.i - 1));
+			} else args.push([this.next()]);
+		}
+		const expanded = [];
+		for (const token of tokenize(body, t.pos)) {
+			expanded.push(token);
+			const last = expanded.length - 2;
+			if (token.kind === "char" && /[1-9]/.test(token.value) && expanded[last]?.kind === "char" && expanded[last].value === "#") expanded.splice(last, 2, {
+				kind: "char",
+				value: "{",
+				pos: t.pos
+			}, ...args[Number(token.value) - 1] ?? [], {
+				kind: "char",
+				value: "}",
+				pos: t.pos
+			});
+		}
+		if (this.tokens.length + expanded.length > MAX_TOKENS) throw new MathError("The formula is too long", t.pos);
+		this.tokens.splice(this.i, 0, {
+			kind: "char",
+			value: "{",
+			pos: t.pos
+		}, ...expanded, {
+			kind: "char",
+			value: "}",
+			pos: t.pos
+		});
+		return this.atom();
+	}
+};
+var STYLE_SWITCHES = {
+	displaystyle: {
+		display: true,
+		scriptLevel: 0
+	},
+	textstyle: {
+		display: false,
+		scriptLevel: 0
+	},
+	scriptstyle: {
+		display: false,
+		scriptLevel: 1
+	},
+	scriptscriptstyle: {
+		display: false,
+		scriptLevel: 2
+	}
+};
+function op(text, kind) {
+	return {
+		type: "op",
+		text,
+		kind
+	};
+}
+/** A list as one node: itself when one, a row otherwise. */
+function row(children) {
+	return children.length === 1 ? children[0] : {
+		type: "row",
+		children
+	};
+}
+function isEmpty(node) {
+	return node.type === "row" && node.children.length === 0;
+}
+/** Whether scripts on a base go under and over it: big operators and limit functions (movable when inline), braces. */
+function takesLimits(base) {
+	if (base.type === "op") return base.movableLimits === true;
+	if (base.type === "accent") return base.mark === "⏞" || base.mark === "⏟";
+	return false;
+}
+// src/index.ts
+/** The formula as a tree. Throws `MathError` for TeX it cannot read. */
+function parseMath(tex, options = {}) {
+	return new Parser(tex, options).parse();
+}
+/**
+* The formula as a `<math>` element: MathML Core, its TeX kept in an
+* annotation (copied with it, read back by `texOf`). TeX it cannot read comes
+* out as a `<span class="dsk-math-error">` with the TeX and the reason in its
+* title — or throws, with `throwOnError`.
+*/
+function renderMath(tex, options = {}) {
+	let body;
+	try {
+		body = toMathML(parseMath(tex, options));
+	} catch (e) {
+		if (options.throwOnError || !(e instanceof MathError)) throw e;
+		return `<span class="dsk-math-error" title="${escape(e.message)}">${escape(tex)}</span>`;
+	}
+	return `<math xmlns="http://www.w3.org/1998/Math/MathML" class="dsk-math"${options.display ? " display=\"block\"" : ""}><semantics><mrow>${body}</mrow><annotation encoding="application/x-tex">${escape(tex)}</annotation></semantics></math>`;
+}
+/** Whether a formula can be read: null when it can, the error (with its place) when not. */
+function checkMath(tex, options = {}) {
+	try {
+		parseMath(tex, options);
+		return null;
+	} catch (e) {
+		if (e instanceof MathError) return e;
+		throw e;
+	}
+}
+/** The TeX a drawn formula was made from (its annotation, or an error's text); null for anything else. */
+function texOf(element) {
+	if (element.localName === "math") return element.querySelector("annotation[encoding=\"application/x-tex\"]")?.textContent ?? null;
+	if (element.classList.contains("dsk-math-error")) return element.textContent;
+	return null;
+}
+/**
+* The page's part: a math font for the formulas (only a font with an OpenType
+* MATH table lets fences, roots and big operators stretch — STIX Two Math on
+* macOS, Cambria Math on Windows; elsewhere one the page provides), a displayed
+* formula's margins, and the look of TeX that could not be read.
+*/
+var MATH_CSS = `math.dsk-math{font-family:"STIX Two Math","Cambria Math","Latin Modern Math","Noto Sans Math",math}
+math.dsk-math[display="block"]{margin:.75em 0}
+.dsk-math-error{color:#d1242f;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;border-bottom:1px dotted}`;
+export { MATH_CSS, MathError, checkMath, parseMath, renderMath, texOf, toMathML };
+
+//# sourceMappingURL=index.mjs.map