js.documents 14.4.56 → 14.4.57

package/dist/layout-DIJzJk4x.js

@@ -0,0 +1,526 @@
+import { parseMathLength } from "./mathml/length.js";
+import { attrValue, elementChildren, elementLocalName, isMathMlElement, textContent } from "./mathml/nodes.js";
+import { operatorProperties } from "./mathml/operators.js";
+import { applyMathVariant, isMathVariant } from "./mathml/variant.js";
+import { EMPTY_BOX, concatBoxesHorizontally, placeChild, shiftItems } from "./mathml/compose.js";
+import { buildRadicalSign } from "./mathml/radical.js";
+//#region src/mathml/layout-stretch.ts
+function isStretchyOperator(element) {
+	if (elementLocalName(element) !== "mo") return false;
+	if (attrValue(element, "stretchy") === "false") return false;
+	return operatorProperties(textContent(element).trim()).stretchy;
+}
+function singleCodePoint(text) {
+	const codePoints = [...text];
+	return codePoints.length === 1 ? codePoints[0]?.codePointAt(0) : void 0;
+}
+function stretchedBox(result, text, ctx) {
+	const axisPt = ctx.metrics.axisHeightPt;
+	const inkHeightPt = result.inkAscentPt + result.inkDescentPt;
+	const originAboveBaselinePt = axisPt - (result.inkAscentPt - result.inkDescentPt) / 2;
+	const ascentPt = axisPt + inkHeightPt / 2;
+	const descentPt = inkHeightPt / 2 - axisPt;
+	const items = [{
+		kind: "assembled-glyphs",
+		placements: result.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			xPt: 0,
+			yPt: ascentPt - originAboveBaselinePt - placement.offsetPt
+		})),
+		text,
+		sizePt: ctx.sizePt,
+		color: ctx.color
+	}];
+	return {
+		widthPt: result.advanceWidthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function stretchOperator(element, targetSizePt, ctx) {
+	const text = textContent(element).trim();
+	const codePoint = singleCodePoint(text);
+	if (codePoint === void 0) return;
+	const result = ctx.metrics.stretch(codePoint, "vertical", targetSizePt, ctx.sizePt);
+	if (result === void 0 || result.kind === "base") return;
+	return stretchedBox(result, text, ctx);
+}
+function horizontallyStretchedBox(result, text, ctx) {
+	const ascentPt = result.inkAscentPt;
+	const descentPt = result.inkDescentPt;
+	const items = [{
+		kind: "assembled-glyphs",
+		placements: result.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			xPt: placement.offsetPt,
+			yPt: ascentPt
+		})),
+		text,
+		sizePt: ctx.sizePt,
+		color: ctx.color
+	}];
+	return {
+		widthPt: result.sizePt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function stretchHorizontalOperator(element, targetWidthPt, ctx) {
+	const text = textContent(element).trim();
+	const codePoint = singleCodePoint(text);
+	if (codePoint === void 0) return;
+	const result = ctx.metrics.stretch(codePoint, "horizontal", targetWidthPt, ctx.sizePt);
+	if (result === void 0 || result.kind === "base") return;
+	return horizontallyStretchedBox(result, text, ctx);
+}
+function layoutUnderOverChild(childElement, targetWidthPt, scriptCtx) {
+	if (isStretchyOperator(childElement)) {
+		const stretched = stretchHorizontalOperator(childElement, targetWidthPt, scriptCtx);
+		if (stretched !== void 0) return stretched;
+	}
+	return layoutNode(childElement, scriptCtx);
+}
+function stretchRowOperators(children, boxes, ctx) {
+	const stretchy = children.map(isStretchyOperator);
+	const others = boxes.filter((_, index) => stretchy[index] !== true);
+	if (others.length === 0) return boxes;
+	const axisPt = ctx.metrics.axisHeightPt;
+	const maxAscentPt = others.reduce((max, box) => Math.max(max, box.ascentPt), 0);
+	const maxDescentPt = others.reduce((max, box) => Math.max(max, box.descentPt), 0);
+	const targetSizePt = 2 * Math.max(maxAscentPt - axisPt, maxDescentPt + axisPt);
+	return boxes.map((box, index) => {
+		if (stretchy[index] !== true) return box;
+		const element = children[index];
+		return (element === void 0 ? void 0 : stretchOperator(element, targetSizePt, ctx)) ?? box;
+	});
+}
+function layoutRowChildren(children, ctx) {
+	const boxes = stretchRowOperators(children, children.map((child) => layoutNode(child, ctx)), ctx);
+	const gapsPt = [];
+	let carriedRspaceEm = 0;
+	for (const [index, child] of children.entries()) {
+		const properties = elementLocalName(child) === "mo" ? operatorProperties(textContent(child).trim()) : void 0;
+		const gapEm = index === 0 ? 0 : carriedRspaceEm + (properties?.lspaceEm ?? 0);
+		gapsPt.push(gapEm * ctx.sizePt);
+		carriedRspaceEm = properties?.rspaceEm ?? 0;
+	}
+	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;
+	const initialSupShiftUpPt = Math.max(ctx.cramped ? metrics.superscriptShiftUpCrampedPt : metrics.superscriptShiftUpPt, base.ascentPt - metrics.superscriptBaselineDropMaxPt);
+	const initialSubShiftDownPt = Math.max(metrics.subscriptShiftDownPt, base.descentPt + metrics.subscriptBaselineDropMinPt);
+	let correctionPt = 0;
+	if (superscript !== void 0 && subscript !== void 0) {
+		const gapPt = initialSupShiftUpPt - superscript.descentPt + (initialSubShiftDownPt - subscript.ascentPt);
+		correctionPt = Math.max(0, metrics.subSuperscriptGapMinPt - gapPt) / 2;
+	}
+	const supShiftUpPt = initialSupShiftUpPt + correctionPt;
+	const subShiftDownPt = initialSubShiftDownPt + correctionPt;
+	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, accentAttachment = {}) {
+	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 baseXPt = (widthPt - base.widthPt) / 2;
+	const items = [...placeChild(base, baseXPt, 0, ascentPt)];
+	if (over !== void 0) {
+		const overXPt = accentAttachment.overXPt === void 0 ? (widthPt - over.widthPt) / 2 : baseXPt + accentAttachment.overXPt - over.widthPt / 2;
+		items.push(...placeChild(over, overXPt, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
+	}
+	if (under !== void 0) {
+		const underXPt = accentAttachment.underXPt === void 0 ? (widthPt - under.widthPt) / 2 : baseXPt + accentAttachment.underXPt - under.widthPt / 2;
+		items.push(...placeChild(under, underXPt, 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;
+}
+//#endregion
+//#region src/mathml/layout.ts
+const HEX_RADIX = 16;
+const UNICODE_HEX_DIGITS = 4;
+const PERCENT_SCALE = 100;
+const RADICAL_SIGN = 8730;
+const TABLE_COLUMN_GAP_EM = .8;
+const TABLE_ROW_GAP_EM = .5;
+function rootContext(options, diagnostics) {
+	return {
+		metrics: options.metrics,
+		sizePt: options.sizePt,
+		color: options.color,
+		inheritedVariant: void 0,
+		displayStyle: true,
+		cramped: false,
+		firstScriptLevel: true,
+		diagnostics
+	};
+}
+function scriptContext(ctx, cramped) {
+	const scale = ctx.firstScriptLevel ? ctx.metrics.scriptPercentScaleDown : ctx.metrics.scriptScriptPercentScaleDown;
+	return {
+		...ctx,
+		sizePt: ctx.sizePt * scale,
+		displayStyle: false,
+		cramped,
+		firstScriptLevel: false
+	};
+}
+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);
+	const nominalAscentPt = ctx.metrics.ascentPerEm * ctx.sizePt;
+	const nominalDescentPt = ctx.metrics.descentPerEm * ctx.sizePt;
+	let widthPt = 0;
+	let ascentPt = 0;
+	let descentPt = 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(HEX_RADIX).toUpperCase().padStart(UNICODE_HEX_DIGITS, "0")}`
+			});
+			continue;
+		}
+		text += ch;
+		widthPt += glyph.advanceWidthPt;
+		ascentPt = Math.max(ascentPt, glyph.inkAscentPt ?? nominalAscentPt);
+		descentPt = Math.max(descentPt, glyph.inkDescentPt ?? nominalDescentPt);
+	}
+	if (text.length === 0) return EMPTY_BOX;
+	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 resolveTopAccentXPt(baseElement, ctx) {
+	const name = elementLocalName(baseElement);
+	let rawText;
+	let intrinsicDefault;
+	if (name === "mi") {
+		rawText = textContent(baseElement);
+		intrinsicDefault = miIntrinsicDefault(rawText);
+	} else if (name === "mn" || name === "mtext") {
+		rawText = textContent(baseElement);
+		intrinsicDefault = "normal";
+	} else if (name === "mo") {
+		rawText = textContent(baseElement).trim();
+		intrinsicDefault = "normal";
+	} else return;
+	const codePoint = singleCodePoint(applyMathVariant(rawText, tokenVariant(baseElement, intrinsicDefault, ctx)));
+	if (codePoint === void 0) return;
+	return ctx.metrics.glyph(codePoint, ctx.sizePt)?.topAccentXPt;
+}
+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 === "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);
+	const isAccent = attrValue(element, "accent") === "true";
+	const isAccentUnder = attrValue(element, "accentunder") === "true";
+	const accentAttachment = {
+		overXPt: isAccent ? resolveTopAccentXPt(baseElement, ctx) : void 0,
+		underXPt: isAccentUnder ? resolveTopAccentXPt(baseElement, ctx) : void 0
+	};
+	if (kind === "mover") return layoutUnderOver(base, void 0, children[1] === void 0 ? void 0 : layoutUnderOverChild(children[1], base.widthPt, scriptCtx), ctx, accentAttachment);
+	return layoutUnderOver(base, children[1] === void 0 ? void 0 : layoutUnderOverChild(children[1], base.widthPt, scriptCtx), children[2] === void 0 ? void 0 : layoutUnderOverChild(children[2], base.widthPt, scriptCtx), ctx, accentAttachment);
+}
+function layoutFraction(element, ctx) {
+	const children = elementChildren(element);
+	const numeratorElement = children[0];
+	const denominatorElement = children[1];
+	if (numeratorElement === void 0) return EMPTY_BOX;
+	if (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 ascentPt = metrics.radicalExtraAscenderPt + ruleThicknessPt + gapPt + radicand.ascentPt;
+	const descentPt = radicand.descentPt;
+	const items = [];
+	const stretched = ctx.metrics.stretch(RADICAL_SIGN, "vertical", signHeightPt - metrics.radicalExtraAscenderPt, ctx.sizePt);
+	let signWidthPt;
+	if (stretched !== void 0) {
+		const placements = stretched.placements.map((placement) => ({
+			glyphId: placement.glyphId,
+			xPt: signOriginXPt,
+			yPt: metrics.radicalExtraAscenderPt + stretched.inkAscentPt - placement.offsetPt
+		}));
+		items.push({
+			kind: "assembled-glyphs",
+			placements,
+			text: "√",
+			sizePt: ctx.sizePt,
+			color: ctx.color
+		});
+		items.push({
+			kind: "rule",
+			xPt: signOriginXPt,
+			yPt: metrics.radicalExtraAscenderPt,
+			widthPt: stretched.advanceWidthPt + radicand.widthPt,
+			heightPt: ruleThicknessPt,
+			color: ctx.color
+		});
+		signWidthPt = stretched.advanceWidthPt;
+	} else {
+		const sign = buildRadicalSign(signOriginXPt, 0, signHeightPt, radicand.widthPt, ruleThicknessPt, ctx.color);
+		items.push(sign.hook, sign.vinculum);
+		signWidthPt = sign.widthPt;
+	}
+	items.push(...placeChild(radicand, signOriginXPt + signWidthPt, 0, ascentPt));
+	if (index !== void 0) {
+		const raisePt = (ascentPt + descentPt) * metrics.radicalDegreeBottomRaisePercent / PERCENT_SCALE;
+		const degreeBaselineFromTopPt = ascentPt + descentPt - raisePt - index.descentPt;
+		items.push(...shiftItems(index.items, metrics.radicalKernBeforeDegreePt, degreeBaselineFromTopPt - index.ascentPt));
+	}
+	return {
+		widthPt: signOriginXPt + signWidthPt + radicand.widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function layoutTable(element, ctx) {
+	const rows = elementChildren(element).filter((child) => elementLocalName(child) === "mtr");
+	const columnAlignAttr = attrValue(element, "columnalign");
+	const columnAligns = columnAlignAttr === void 0 ? [] : columnAlignAttr.match(/\S+/g) ?? [];
+	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 = Array.from({ length: columnCount }, (_, column) => rowCells.reduce((max, row) => Math.max(max, row[column]?.widthPt ?? 0), 0));
+	const columnGapPt = TABLE_COLUMN_GAP_EM * ctx.sizePt;
+	const rowGapPt = TABLE_ROW_GAP_EM * 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];
+			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 { isStretchyOperator as a, layoutSemantics as c, mstyleContext as d, singleCodePoint as f, stretchedBox as g, stretchRowOperators as h, isMovableLimitsOperator as i, layoutUnderOver as l, stretchOperator as m, layoutNode as n, layoutRowChildren as o, stretchHorizontalOperator as p, horizontallyStretchedBox as r, layoutScripts as s, layoutFormula as t, layoutUnderOverChild as u };