documents.js 1.57.0 → 1.58.0

package/dist/mathml/layout.js

@@ -0,0 +1,371 @@
+import { EMPTY_BOX, concatBoxesHorizontally, placeChild, shiftItems } from "./compose.js";
+import { parseMathLength } from "./length.js";
+import { attrValue, elementChildren, elementLocalName, isMathMlElement, textContent } from "./nodes.js";
+import { operatorProperties } from "./operators.js";
+import { buildRadicalSign } from "./radical.js";
+import { applyMathVariant, isMathVariant } from "./variant.js";
+//#region src/mathml/layout.ts
+function rootContext(options, diagnostics) {
+	return {
+		metrics: options.metrics,
+		sizePt: options.sizePt,
+		color: options.color,
+		inheritedVariant: void 0,
+		displayStyle: true,
+		cramped: false,
+		scriptLevel: 0,
+		diagnostics
+	};
+}
+function scriptContext(ctx, cramped) {
+	const scale = ctx.scriptLevel === 0 ? ctx.metrics.scriptPercentScaleDown : ctx.metrics.scriptScriptPercentScaleDown;
+	return {
+		...ctx,
+		sizePt: ctx.sizePt * scale,
+		displayStyle: false,
+		cramped,
+		scriptLevel: ctx.scriptLevel + 1
+	};
+}
+function unsupported(ctx, element) {
+	ctx.diagnostics.push({
+		kind: "unsupported-element",
+		detail: elementLocalName(element)
+	});
+	return layoutToken(textContent(element), "normal", ctx);
+}
+function layoutToken(rawText, variant, ctx) {
+	const styled = applyMathVariant(rawText, variant);
+	let widthPt = 0;
+	let text = "";
+	for (const ch of styled) {
+		const codePoint = ch.codePointAt(0);
+		if (codePoint === void 0) continue;
+		const glyph = ctx.metrics.glyph(codePoint, ctx.sizePt);
+		if (glyph === void 0) {
+			ctx.diagnostics.push({
+				kind: "missing-glyph",
+				detail: `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`
+			});
+			continue;
+		}
+		text += ch;
+		widthPt += glyph.advanceWidthPt;
+	}
+	if (text.length === 0) return EMPTY_BOX;
+	const ascentPt = ctx.metrics.ascentPerEm * ctx.sizePt;
+	const descentPt = ctx.metrics.descentPerEm * ctx.sizePt;
+	const items = [{
+		kind: "glyphs",
+		xPt: 0,
+		yPt: ascentPt,
+		text,
+		sizePt: ctx.sizePt,
+		color: ctx.color
+	}];
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function tokenVariant(element, intrinsicDefault, ctx) {
+	const attr = attrValue(element, "mathvariant");
+	if (attr !== void 0 && isMathVariant(attr)) return attr;
+	return ctx.inheritedVariant ?? intrinsicDefault;
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+function layoutRowChildren(children, ctx) {
+	const boxes = children.map((child) => layoutNode(child, ctx));
+	const gapsPt = children.map((child, index) => {
+		if (index === 0) return 0;
+		const previous = children[index - 1];
+		let gapEm = 0;
+		if (previous !== void 0 && elementLocalName(previous) === "mo") gapEm += operatorProperties(textContent(previous).trim()).rspaceEm;
+		if (elementLocalName(child) === "mo") gapEm += operatorProperties(textContent(child).trim()).lspaceEm;
+		return gapEm * ctx.sizePt;
+	});
+	return concatBoxesHorizontally(boxes, gapsPt);
+}
+function layoutSemantics(element, ctx) {
+	const content = elementChildren(element).find((child) => {
+		const name = elementLocalName(child);
+		return name !== "annotation" && name !== "annotation-xml";
+	});
+	return content === void 0 ? EMPTY_BOX : layoutNode(content, ctx);
+}
+function mstyleContext(element, ctx) {
+	let next = ctx;
+	const displayAttr = attrValue(element, "displaystyle");
+	if (displayAttr === "true" || displayAttr === "false") next = {
+		...next,
+		displayStyle: displayAttr === "true"
+	};
+	const variantAttr = attrValue(element, "mathvariant");
+	if (variantAttr !== void 0 && isMathVariant(variantAttr)) next = {
+		...next,
+		inheritedVariant: variantAttr
+	};
+	return next;
+}
+function layoutScripts(base, subscript, superscript, ctx) {
+	const metrics = ctx.metrics;
+	let supShiftUpPt = 0;
+	let subShiftDownPt = 0;
+	if (superscript !== void 0) supShiftUpPt = Math.max(ctx.cramped ? metrics.superscriptShiftUpCrampedPt : metrics.superscriptShiftUpPt, base.ascentPt - metrics.superscriptBaselineDropMaxPt);
+	if (subscript !== void 0) subShiftDownPt = Math.max(metrics.subscriptShiftDownPt, base.descentPt + metrics.subscriptBaselineDropMinPt);
+	if (superscript !== void 0 && subscript !== void 0) {
+		const gapPt = supShiftUpPt - superscript.descentPt + (subShiftDownPt - subscript.ascentPt);
+		const deficitPt = metrics.subSuperscriptGapMinPt - gapPt;
+		if (deficitPt > 0) {
+			supShiftUpPt += deficitPt / 2;
+			subShiftDownPt += deficitPt / 2;
+		}
+	}
+	const ascentPt = Math.max(base.ascentPt, superscript === void 0 ? 0 : supShiftUpPt + superscript.ascentPt);
+	const descentPt = Math.max(base.descentPt, subscript === void 0 ? 0 : subShiftDownPt + subscript.descentPt);
+	const scriptWidthPt = Math.max(superscript?.widthPt ?? 0, subscript?.widthPt ?? 0);
+	const widthPt = base.widthPt + (scriptWidthPt > 0 ? scriptWidthPt + metrics.spaceAfterScriptPt : 0);
+	const items = [...placeChild(base, 0, 0, ascentPt)];
+	if (superscript !== void 0) items.push(...placeChild(superscript, base.widthPt, -supShiftUpPt, ascentPt));
+	if (subscript !== void 0) items.push(...placeChild(subscript, base.widthPt, subShiftDownPt, ascentPt));
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function layoutUnderOver(base, under, over, ctx) {
+	const gapPt = ctx.metrics.stackGapMinPt;
+	const overHeightPt = over === void 0 ? 0 : gapPt + over.heightPt;
+	const underHeightPt = under === void 0 ? 0 : gapPt + under.heightPt;
+	const ascentPt = base.ascentPt + overHeightPt;
+	const descentPt = base.descentPt + underHeightPt;
+	const widthPt = Math.max(base.widthPt, under?.widthPt ?? 0, over?.widthPt ?? 0);
+	const items = [...placeChild(base, (widthPt - base.widthPt) / 2, 0, ascentPt)];
+	if (over !== void 0) items.push(...placeChild(over, (widthPt - over.widthPt) / 2, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
+	if (under !== void 0) items.push(...placeChild(under, (widthPt - under.widthPt) / 2, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function isMovableLimitsOperator(element) {
+	return elementLocalName(element) === "mo" && operatorProperties(textContent(element).trim()).movablelimits;
+}
+function layoutUnderOverElement(element, kind, ctx) {
+	const children = elementChildren(element);
+	const baseElement = children[0];
+	if (baseElement === void 0) return EMPTY_BOX;
+	if (!ctx.displayStyle && isMovableLimitsOperator(baseElement)) {
+		const base = layoutNode(baseElement, ctx);
+		const scriptCtx = scriptContext(ctx, ctx.cramped);
+		if (kind === "munder") return layoutScripts(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx);
+		if (kind === "mover") return layoutScripts(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx);
+		return layoutScripts(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx);
+	}
+	const base = layoutNode(baseElement, ctx);
+	const scriptCtx = scriptContext(ctx, false);
+	if (kind === "munder") return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), void 0, ctx);
+	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), ctx);
+	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx);
+}
+function layoutFraction(element, ctx) {
+	const children = elementChildren(element);
+	const numeratorElement = children[0];
+	const denominatorElement = children[1];
+	if (numeratorElement === void 0 || denominatorElement === void 0) return EMPTY_BOX;
+	const fracCtx = {
+		...ctx,
+		displayStyle: false,
+		cramped: false
+	};
+	const numerator = layoutNode(numeratorElement, fracCtx);
+	const denominator = layoutNode(denominatorElement, {
+		...fracCtx,
+		cramped: true
+	});
+	const metrics = ctx.metrics;
+	const lineThicknessAttr = attrValue(element, "linethickness");
+	const ruleThicknessPt = (lineThicknessAttr === void 0 ? void 0 : parseMathLength(lineThicknessAttr, ctx.sizePt)) ?? metrics.fractionRuleThicknessPt;
+	const axisPt = metrics.axisHeightPt;
+	const numShiftUpPt = Math.max(ctx.displayStyle ? metrics.fractionNumeratorDisplayShiftUpPt : metrics.fractionNumeratorShiftUpPt, axisPt + ruleThicknessPt / 2 + metrics.fractionNumeratorGapMinPt + numerator.descentPt);
+	const denShiftDownPt = Math.max(ctx.displayStyle ? metrics.fractionDenominatorDisplayShiftDownPt : metrics.fractionDenominatorShiftDownPt, ruleThicknessPt / 2 + metrics.fractionDenominatorGapMinPt + denominator.ascentPt - axisPt);
+	const widthPt = Math.max(numerator.widthPt, denominator.widthPt);
+	const ascentPt = numShiftUpPt + numerator.ascentPt;
+	const descentPt = denShiftDownPt + denominator.descentPt;
+	const items = [
+		...placeChild(numerator, (widthPt - numerator.widthPt) / 2, -numShiftUpPt, ascentPt),
+		...placeChild(denominator, (widthPt - denominator.widthPt) / 2, denShiftDownPt, ascentPt),
+		{
+			kind: "rule",
+			xPt: 0,
+			yPt: ascentPt - axisPt - ruleThicknessPt / 2,
+			widthPt,
+			heightPt: ruleThicknessPt,
+			color: ctx.color
+		}
+	];
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function layoutRadical(element, kind, ctx) {
+	const children = elementChildren(element);
+	if (kind === "msqrt") return wrapRadical(layoutRowChildren(children, {
+		...ctx,
+		cramped: true
+	}), void 0, ctx);
+	const radicandElement = children[0];
+	const indexElement = children[1];
+	if (radicandElement === void 0) return EMPTY_BOX;
+	return wrapRadical(layoutNode(radicandElement, {
+		...ctx,
+		cramped: true
+	}), indexElement === void 0 ? void 0 : layoutNode(indexElement, scriptContext(scriptContext(ctx, false), false)), ctx);
+}
+function wrapRadical(radicand, index, ctx) {
+	const metrics = ctx.metrics;
+	const ruleThicknessPt = metrics.radicalRuleThicknessPt;
+	const gapPt = metrics.radicalVerticalGapPt;
+	const signHeightPt = metrics.radicalExtraAscenderPt + ruleThicknessPt + gapPt + radicand.heightPt;
+	const degreeWidthPt = index === void 0 ? 0 : metrics.radicalKernBeforeDegreePt + index.widthPt + metrics.radicalKernAfterDegreePt;
+	const signOriginXPt = Math.max(0, degreeWidthPt);
+	const sign = buildRadicalSign(signOriginXPt, 0, signHeightPt, radicand.widthPt, ruleThicknessPt, ctx.color);
+	const ascentPt = metrics.radicalExtraAscenderPt + ruleThicknessPt + gapPt + radicand.ascentPt;
+	const descentPt = radicand.descentPt;
+	const widthPt = signOriginXPt + sign.widthPt + radicand.widthPt;
+	const items = [
+		sign.hook,
+		sign.vinculum,
+		...placeChild(radicand, signOriginXPt + sign.widthPt, 0, ascentPt)
+	];
+	if (index !== void 0) {
+		const raisePt = (ascentPt + descentPt) * metrics.radicalDegreeBottomRaisePercent / 100;
+		const degreeBaselineFromTopPt = ascentPt + descentPt - raisePt - index.descentPt;
+		items.push(...shiftItems(index.items, metrics.radicalKernBeforeDegreePt, degreeBaselineFromTopPt - index.ascentPt));
+	}
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function layoutTable(element, ctx) {
+	const rows = elementChildren(element).filter((child) => elementLocalName(child) === "mtr");
+	if (rows.length === 0) return EMPTY_BOX;
+	const columnAligns = (attrValue(element, "columnalign") ?? "").trim().split(/\s+/).filter((s) => s.length > 0);
+	const rowCells = rows.map((row) => elementChildren(row).filter((child) => elementLocalName(child) === "mtd").map((cell) => layoutRowChildren(elementChildren(cell), ctx)));
+	const columnCount = rowCells.reduce((max, row) => Math.max(max, row.length), 0);
+	if (columnCount === 0) return EMPTY_BOX;
+	const columnWidthsPt = [];
+	for (let column = 0; column < columnCount; column++) columnWidthsPt.push(rowCells.reduce((max, row) => Math.max(max, row[column]?.widthPt ?? 0), 0));
+	const columnGapPt = .8 * ctx.sizePt;
+	const rowGapPt = .5 * ctx.sizePt;
+	const items = [];
+	let cursorYTopPt = 0;
+	rowCells.forEach((row, rowIndex) => {
+		const rowAscentPt = row.reduce((max, cell) => Math.max(max, cell.ascentPt), 0);
+		const rowDescentPt = row.reduce((max, cell) => Math.max(max, cell.descentPt), 0);
+		let cursorXPt = 0;
+		row.forEach((cell, columnIndex) => {
+			const columnWidthPt = columnWidthsPt[columnIndex] ?? cell.widthPt;
+			const align = columnAligns[columnIndex] ?? columnAligns[columnAligns.length - 1] ?? "center";
+			const extraPt = columnWidthPt - cell.widthPt;
+			const dxPt = align === "left" ? 0 : align === "right" ? extraPt : extraPt / 2;
+			items.push(...placeChild(cell, cursorXPt + dxPt, 0, cursorYTopPt + rowAscentPt));
+			cursorXPt += columnWidthPt + columnGapPt;
+		});
+		cursorYTopPt += rowAscentPt + rowDescentPt + (rowIndex < rowCells.length - 1 ? rowGapPt : 0);
+	});
+	const widthPt = columnWidthsPt.reduce((sum, w) => sum + w, 0) + columnGapPt * Math.max(0, columnCount - 1);
+	let descentPt = cursorYTopPt - (cursorYTopPt / 2 + ctx.metrics.axisHeightPt);
+	if (descentPt < 0) descentPt = 0;
+	return {
+		widthPt,
+		ascentPt: cursorYTopPt - descentPt,
+		descentPt,
+		heightPt: cursorYTopPt,
+		items
+	};
+}
+function layoutSpace(element, ctx) {
+	const widthAttr = attrValue(element, "width");
+	const heightAttr = attrValue(element, "height");
+	const depthAttr = attrValue(element, "depth");
+	const widthPt = Math.max(0, (widthAttr === void 0 ? void 0 : parseMathLength(widthAttr, ctx.sizePt)) ?? 0);
+	const ascentPt = Math.max(0, (heightAttr === void 0 ? void 0 : parseMathLength(heightAttr, ctx.sizePt)) ?? 0);
+	const descentPt = Math.max(0, (depthAttr === void 0 ? void 0 : parseMathLength(depthAttr, ctx.sizePt)) ?? 0);
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items: []
+	};
+}
+function layoutNode(node, ctx) {
+	if (!isMathMlElement(node)) return EMPTY_BOX;
+	switch (elementLocalName(node)) {
+		case "mrow": return layoutRowChildren(elementChildren(node), ctx);
+		case "semantics": return layoutSemantics(node, ctx);
+		case "mstyle": return layoutRowChildren(elementChildren(node), mstyleContext(node, ctx));
+		case "mi": {
+			const text = textContent(node);
+			return layoutToken(text, tokenVariant(node, miIntrinsicDefault(text), ctx), ctx);
+		}
+		case "mn": return layoutToken(textContent(node), tokenVariant(node, "normal", ctx), ctx);
+		case "mo": return layoutToken(textContent(node).trim(), tokenVariant(node, "normal", ctx), ctx);
+		case "mtext": return layoutToken(textContent(node), tokenVariant(node, "normal", ctx), ctx);
+		case "mspace": return layoutSpace(node, ctx);
+		case "msub": {
+			const children = elementChildren(node);
+			return layoutScripts(children[0] === void 0 ? EMPTY_BOX : layoutNode(children[0], ctx), children[1] === void 0 ? void 0 : layoutNode(children[1], scriptContext(ctx, ctx.cramped)), void 0, ctx);
+		}
+		case "msup": {
+			const children = elementChildren(node);
+			return layoutScripts(children[0] === void 0 ? EMPTY_BOX : layoutNode(children[0], ctx), void 0, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptContext(ctx, ctx.cramped)), ctx);
+		}
+		case "msubsup": {
+			const children = elementChildren(node);
+			const base = children[0] === void 0 ? EMPTY_BOX : layoutNode(children[0], ctx);
+			const scriptCtx = scriptContext(ctx, ctx.cramped);
+			return layoutScripts(base, children[1] === void 0 ? void 0 : layoutNode(children[1], scriptCtx), children[2] === void 0 ? void 0 : layoutNode(children[2], scriptCtx), ctx);
+		}
+		case "munder": return layoutUnderOverElement(node, "munder", ctx);
+		case "mover": return layoutUnderOverElement(node, "mover", ctx);
+		case "munderover": return layoutUnderOverElement(node, "munderover", ctx);
+		case "mfrac": return layoutFraction(node, ctx);
+		case "msqrt": return layoutRadical(node, "msqrt", ctx);
+		case "mroot": return layoutRadical(node, "mroot", ctx);
+		case "mtable": return layoutTable(node, ctx);
+		case "mtr":
+		case "mtd": return layoutRowChildren(elementChildren(node), ctx);
+		default: return unsupported(ctx, node);
+	}
+}
+function layoutFormula(mathml, options) {
+	const diagnostics = [];
+	const ctx = rootContext(options, diagnostics);
+	return {
+		box: layoutRowChildren(mathml.filter(isMathMlElement), ctx),
+		diagnostics
+	};
+}
+//#endregion
+export { layoutFormula, layoutNode };

package/dist/mathml/length.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/mathml/length.ts
+const NAMED_MATH_SPACES = /* @__PURE__ */ new Map([
+	["veryverythinmathspace", 1 / 18],
+	["verythinmathspace", 2 / 18],
+	["thinmathspace", 3 / 18],
+	["mediummathspace", 4 / 18],
+	["thickmathspace", 5 / 18],
+	["verythickmathspace", 6 / 18],
+	["veryverythickmathspace", 7 / 18]
+]);
+const EX_APPROXIMATION_OF_EM = .5;
+const LENGTH_PATTERN = /^([+-]?[0-9]*\.?[0-9]+)\s*(em|ex|px|in|cm|mm|pt|pc|%)?$/;
+const PX_PER_INCH = 96;
+const PT_PER_INCH = 72;
+const CM_PER_INCH = 2.54;
+const MM_PER_INCH = 25.4;
+const PC_PER_INCH = 6;
+function parseMathLength(value, fontSizePt) {
+	const trimmed = value.trim();
+	const named = NAMED_MATH_SPACES.get(trimmed);
+	if (named !== void 0) return named * fontSizePt;
+	const match = LENGTH_PATTERN.exec(trimmed);
+	if (match === null) return;
+	const amount = Number(match[1]);
+	if (!Number.isFinite(amount)) return;
+	switch (match[2] ?? "em") {
+		case "em": return amount * fontSizePt;
+		case "ex": return amount * fontSizePt * EX_APPROXIMATION_OF_EM;
+		case "%": return amount / 100 * fontSizePt;
+		case "pt": return amount;
+		case "px": return amount / PX_PER_INCH * PT_PER_INCH;
+		case "in": return amount * PT_PER_INCH;
+		case "cm": return amount / CM_PER_INCH * PT_PER_INCH;
+		case "mm": return amount / MM_PER_INCH * PT_PER_INCH;
+		case "pc": return amount / PC_PER_INCH * PT_PER_INCH;
+		default: return;
+	}
+}
+//#endregion
+exports.parseMathLength = parseMathLength;

package/dist/mathml/length.d.cts

@@ -0,0 +1,4 @@
+//#region src/mathml/length.d.ts
+declare function parseMathLength(value: string, fontSizePt: number): number | undefined;
+//#endregion
+export { parseMathLength };

package/dist/mathml/length.d.ts

@@ -0,0 +1,4 @@
+//#region src/mathml/length.d.ts
+declare function parseMathLength(value: string, fontSizePt: number): number | undefined;
+//#endregion
+export { parseMathLength };

package/dist/mathml/length.js

@@ -0,0 +1,40 @@
+//#region src/mathml/length.ts
+const NAMED_MATH_SPACES = /* @__PURE__ */ new Map([
+	["veryverythinmathspace", 1 / 18],
+	["verythinmathspace", 2 / 18],
+	["thinmathspace", 3 / 18],
+	["mediummathspace", 4 / 18],
+	["thickmathspace", 5 / 18],
+	["verythickmathspace", 6 / 18],
+	["veryverythickmathspace", 7 / 18]
+]);
+const EX_APPROXIMATION_OF_EM = .5;
+const LENGTH_PATTERN = /^([+-]?[0-9]*\.?[0-9]+)\s*(em|ex|px|in|cm|mm|pt|pc|%)?$/;
+const PX_PER_INCH = 96;
+const PT_PER_INCH = 72;
+const CM_PER_INCH = 2.54;
+const MM_PER_INCH = 25.4;
+const PC_PER_INCH = 6;
+function parseMathLength(value, fontSizePt) {
+	const trimmed = value.trim();
+	const named = NAMED_MATH_SPACES.get(trimmed);
+	if (named !== void 0) return named * fontSizePt;
+	const match = LENGTH_PATTERN.exec(trimmed);
+	if (match === null) return;
+	const amount = Number(match[1]);
+	if (!Number.isFinite(amount)) return;
+	switch (match[2] ?? "em") {
+		case "em": return amount * fontSizePt;
+		case "ex": return amount * fontSizePt * EX_APPROXIMATION_OF_EM;
+		case "%": return amount / 100 * fontSizePt;
+		case "pt": return amount;
+		case "px": return amount / PX_PER_INCH * PT_PER_INCH;
+		case "in": return amount * PT_PER_INCH;
+		case "cm": return amount / CM_PER_INCH * PT_PER_INCH;
+		case "mm": return amount / MM_PER_INCH * PT_PER_INCH;
+		case "pc": return amount / PC_PER_INCH * PT_PER_INCH;
+		default: return;
+	}
+}
+//#endregion
+export { parseMathLength };

package/dist/mathml/metrics.d.cts

@@ -0,0 +1,44 @@
+//#region src/mathml/metrics.d.ts
+interface MathGlyphMetrics {
+  readonly advanceWidthPt: number;
+  readonly italicCorrectionPt: number;
+  readonly topAccentXPt?: number;
+}
+interface MathFontMetrics {
+  readonly ascentPerEm: number;
+  readonly descentPerEm: number;
+  readonly axisHeightPt: number;
+  readonly fractionRuleThicknessPt: number;
+  readonly fractionNumeratorShiftUpPt: number;
+  readonly fractionNumeratorDisplayShiftUpPt: number;
+  readonly fractionDenominatorShiftDownPt: number;
+  readonly fractionDenominatorDisplayShiftDownPt: number;
+  readonly fractionNumeratorGapMinPt: number;
+  readonly fractionDenominatorGapMinPt: number;
+  readonly radicalRuleThicknessPt: number;
+  readonly radicalExtraAscenderPt: number;
+  readonly radicalVerticalGapPt: number;
+  readonly radicalKernBeforeDegreePt: number;
+  readonly radicalKernAfterDegreePt: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+  readonly subscriptShiftDownPt: number;
+  readonly superscriptShiftUpPt: number;
+  readonly superscriptShiftUpCrampedPt: number;
+  readonly subSuperscriptGapMinPt: number;
+  readonly superscriptBaselineDropMaxPt: number;
+  readonly subscriptBaselineDropMinPt: number;
+  readonly spaceAfterScriptPt: number;
+  readonly upperLimitGapMinPt: number;
+  readonly upperLimitBaselineRiseMinPt: number;
+  readonly lowerLimitGapMinPt: number;
+  readonly lowerLimitBaselineDropMinPt: number;
+  readonly stackTopShiftUpPt: number;
+  readonly stackBottomShiftDownPt: number;
+  readonly stackGapMinPt: number;
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly defaultRuleThicknessPt: number;
+  glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+}
+//#endregion
+export { MathFontMetrics, MathGlyphMetrics };

package/dist/mathml/metrics.d.ts

@@ -0,0 +1,44 @@
+//#region src/mathml/metrics.d.ts
+interface MathGlyphMetrics {
+  readonly advanceWidthPt: number;
+  readonly italicCorrectionPt: number;
+  readonly topAccentXPt?: number;
+}
+interface MathFontMetrics {
+  readonly ascentPerEm: number;
+  readonly descentPerEm: number;
+  readonly axisHeightPt: number;
+  readonly fractionRuleThicknessPt: number;
+  readonly fractionNumeratorShiftUpPt: number;
+  readonly fractionNumeratorDisplayShiftUpPt: number;
+  readonly fractionDenominatorShiftDownPt: number;
+  readonly fractionDenominatorDisplayShiftDownPt: number;
+  readonly fractionNumeratorGapMinPt: number;
+  readonly fractionDenominatorGapMinPt: number;
+  readonly radicalRuleThicknessPt: number;
+  readonly radicalExtraAscenderPt: number;
+  readonly radicalVerticalGapPt: number;
+  readonly radicalKernBeforeDegreePt: number;
+  readonly radicalKernAfterDegreePt: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+  readonly subscriptShiftDownPt: number;
+  readonly superscriptShiftUpPt: number;
+  readonly superscriptShiftUpCrampedPt: number;
+  readonly subSuperscriptGapMinPt: number;
+  readonly superscriptBaselineDropMaxPt: number;
+  readonly subscriptBaselineDropMinPt: number;
+  readonly spaceAfterScriptPt: number;
+  readonly upperLimitGapMinPt: number;
+  readonly upperLimitBaselineRiseMinPt: number;
+  readonly lowerLimitGapMinPt: number;
+  readonly lowerLimitBaselineDropMinPt: number;
+  readonly stackTopShiftUpPt: number;
+  readonly stackBottomShiftDownPt: number;
+  readonly stackGapMinPt: number;
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly defaultRuleThicknessPt: number;
+  glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+}
+//#endregion
+export { MathFontMetrics, MathGlyphMetrics };

package/dist/mathml/nodes.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/mathml/nodes.ts
+function isMathMlElement(node) {
+	return node.type === "element";
+}
+function isMathMlText(node) {
+	return node.type === "text";
+}
+function localName(tag) {
+	const colonIndex = tag.indexOf(":");
+	return colonIndex === -1 ? tag : tag.slice(colonIndex + 1);
+}
+function elementLocalName(element) {
+	return localName(element.tag);
+}
+function attrValue(element, name) {
+	return element.attributes.find((attribute) => attribute.name === name)?.value;
+}
+function elementChildren(node) {
+	return node.children.filter(isMathMlElement);
+}
+function firstChildByLocalName(node, name) {
+	return elementChildren(node).find((child) => elementLocalName(child) === name);
+}
+function textContent(node) {
+	if (isMathMlText(node)) return node.value;
+	if (!isMathMlElement(node)) return "";
+	let out = "";
+	for (const child of node.children) out += textContent(child);
+	return out;
+}
+//#endregion
+exports.attrValue = attrValue;
+exports.elementChildren = elementChildren;
+exports.elementLocalName = elementLocalName;
+exports.firstChildByLocalName = firstChildByLocalName;
+exports.isMathMlElement = isMathMlElement;
+exports.localName = localName;
+exports.textContent = textContent;

package/dist/mathml/nodes.d.cts

@@ -0,0 +1,2 @@
+import { a as attrValue, c as firstChildByLocalName, d as textContent, i as MathMlText, l as isMathMlElement, n as MathMlElement, o as elementChildren, r as MathMlNode, s as elementLocalName, t as MathMlAttribute, u as localName } from "../nodes-pArN9ilm.cjs";
+export { MathMlAttribute, MathMlElement, MathMlNode, MathMlText, attrValue, elementChildren, elementLocalName, firstChildByLocalName, isMathMlElement, localName, textContent };

package/dist/mathml/nodes.d.ts

@@ -0,0 +1,2 @@
+import { a as attrValue, c as firstChildByLocalName, d as textContent, i as MathMlText, l as isMathMlElement, n as MathMlElement, o as elementChildren, r as MathMlNode, s as elementLocalName, t as MathMlAttribute, u as localName } from "../nodes-pArN9ilm.js";
+export { MathMlAttribute, MathMlElement, MathMlNode, MathMlText, attrValue, elementChildren, elementLocalName, firstChildByLocalName, isMathMlElement, localName, textContent };

package/dist/mathml/nodes.js

@@ -0,0 +1,32 @@
+//#region src/mathml/nodes.ts
+function isMathMlElement(node) {
+	return node.type === "element";
+}
+function isMathMlText(node) {
+	return node.type === "text";
+}
+function localName(tag) {
+	const colonIndex = tag.indexOf(":");
+	return colonIndex === -1 ? tag : tag.slice(colonIndex + 1);
+}
+function elementLocalName(element) {
+	return localName(element.tag);
+}
+function attrValue(element, name) {
+	return element.attributes.find((attribute) => attribute.name === name)?.value;
+}
+function elementChildren(node) {
+	return node.children.filter(isMathMlElement);
+}
+function firstChildByLocalName(node, name) {
+	return elementChildren(node).find((child) => elementLocalName(child) === name);
+}
+function textContent(node) {
+	if (isMathMlText(node)) return node.value;
+	if (!isMathMlElement(node)) return "";
+	let out = "";
+	for (const child of node.children) out += textContent(child);
+	return out;
+}
+//#endregion
+export { attrValue, elementChildren, elementLocalName, firstChildByLocalName, isMathMlElement, localName, textContent };