js.documents 14.4.56 → 14.4.57

package/dist/layout-iuiyl_Fk.cjs

@@ -0,0 +1,621 @@
+const require_mathml_length = require("./mathml/length.cjs");
+const require_mathml_nodes = require("./mathml/nodes.cjs");
+const require_mathml_operators = require("./mathml/operators.cjs");
+const require_mathml_variant = require("./mathml/variant.cjs");
+const require_mathml_compose = require("./mathml/compose.cjs");
+const require_mathml_radical = require("./mathml/radical.cjs");
+//#region src/mathml/layout-stretch.ts
+function isStretchyOperator(element) {
+	if (require_mathml_nodes.elementLocalName(element) !== "mo") return false;
+	if (require_mathml_nodes.attrValue(element, "stretchy") === "false") return false;
+	return require_mathml_operators.operatorProperties(require_mathml_nodes.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 = require_mathml_nodes.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 = require_mathml_nodes.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 = require_mathml_nodes.elementLocalName(child) === "mo" ? require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(child).trim()) : void 0;
+		const gapEm = index === 0 ? 0 : carriedRspaceEm + (properties?.lspaceEm ?? 0);
+		gapsPt.push(gapEm * ctx.sizePt);
+		carriedRspaceEm = properties?.rspaceEm ?? 0;
+	}
+	return require_mathml_compose.concatBoxesHorizontally(boxes, gapsPt);
+}
+function layoutSemantics(element, ctx) {
+	const content = require_mathml_nodes.elementChildren(element).find((child) => {
+		const name = require_mathml_nodes.elementLocalName(child);
+		return name !== "annotation" && name !== "annotation-xml";
+	});
+	return content === void 0 ? require_mathml_compose.EMPTY_BOX : layoutNode(content, ctx);
+}
+function mstyleContext(element, ctx) {
+	let next = ctx;
+	const displayAttr = require_mathml_nodes.attrValue(element, "displaystyle");
+	if (displayAttr === "true" || displayAttr === "false") next = {
+		...next,
+		displayStyle: displayAttr === "true"
+	};
+	const variantAttr = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (variantAttr !== void 0 && require_mathml_variant.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 = [...require_mathml_compose.placeChild(base, 0, 0, ascentPt)];
+	if (superscript !== void 0) items.push(...require_mathml_compose.placeChild(superscript, base.widthPt, -supShiftUpPt, ascentPt));
+	if (subscript !== void 0) items.push(...require_mathml_compose.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 = [...require_mathml_compose.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(...require_mathml_compose.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(...require_mathml_compose.placeChild(under, underXPt, base.descentPt + gapPt + under.ascentPt, ascentPt));
+	}
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items
+	};
+}
+function isMovableLimitsOperator(element) {
+	return require_mathml_nodes.elementLocalName(element) === "mo" && require_mathml_operators.operatorProperties(require_mathml_nodes.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: require_mathml_nodes.elementLocalName(element)
+	});
+	return layoutToken(require_mathml_nodes.textContent(element), "normal", ctx);
+}
+function layoutToken(rawText, variant, ctx) {
+	const styled = require_mathml_variant.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 require_mathml_compose.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 = require_mathml_nodes.attrValue(element, "mathvariant");
+	if (attr !== void 0 && require_mathml_variant.isMathVariant(attr)) return attr;
+	return ctx.inheritedVariant ?? intrinsicDefault;
+}
+function miIntrinsicDefault(content) {
+	return [...content].length === 1 ? "italic" : "normal";
+}
+function resolveTopAccentXPt(baseElement, ctx) {
+	const name = require_mathml_nodes.elementLocalName(baseElement);
+	let rawText;
+	let intrinsicDefault;
+	if (name === "mi") {
+		rawText = require_mathml_nodes.textContent(baseElement);
+		intrinsicDefault = miIntrinsicDefault(rawText);
+	} else if (name === "mn" || name === "mtext") {
+		rawText = require_mathml_nodes.textContent(baseElement);
+		intrinsicDefault = "normal";
+	} else if (name === "mo") {
+		rawText = require_mathml_nodes.textContent(baseElement).trim();
+		intrinsicDefault = "normal";
+	} else return;
+	const codePoint = singleCodePoint(require_mathml_variant.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 = require_mathml_nodes.elementChildren(element);
+	const baseElement = children[0];
+	if (baseElement === void 0) return require_mathml_compose.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 = require_mathml_nodes.attrValue(element, "accent") === "true";
+	const isAccentUnder = require_mathml_nodes.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 = require_mathml_nodes.elementChildren(element);
+	const numeratorElement = children[0];
+	const denominatorElement = children[1];
+	if (numeratorElement === void 0) return require_mathml_compose.EMPTY_BOX;
+	if (denominatorElement === void 0) return require_mathml_compose.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 = require_mathml_nodes.attrValue(element, "linethickness");
+	const ruleThicknessPt = (lineThicknessAttr === void 0 ? void 0 : require_mathml_length.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 = [
+		...require_mathml_compose.placeChild(numerator, (widthPt - numerator.widthPt) / 2, -numShiftUpPt, ascentPt),
+		...require_mathml_compose.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 = require_mathml_nodes.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 require_mathml_compose.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 = require_mathml_radical.buildRadicalSign(signOriginXPt, 0, signHeightPt, radicand.widthPt, ruleThicknessPt, ctx.color);
+		items.push(sign.hook, sign.vinculum);
+		signWidthPt = sign.widthPt;
+	}
+	items.push(...require_mathml_compose.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(...require_mathml_compose.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 = require_mathml_nodes.elementChildren(element).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtr");
+	const columnAlignAttr = require_mathml_nodes.attrValue(element, "columnalign");
+	const columnAligns = columnAlignAttr === void 0 ? [] : columnAlignAttr.match(/\S+/g) ?? [];
+	const rowCells = rows.map((row) => require_mathml_nodes.elementChildren(row).filter((child) => require_mathml_nodes.elementLocalName(child) === "mtd").map((cell) => layoutRowChildren(require_mathml_nodes.elementChildren(cell), ctx)));
+	const columnCount = rowCells.reduce((max, row) => Math.max(max, row.length), 0);
+	if (columnCount === 0) return require_mathml_compose.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(...require_mathml_compose.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 = require_mathml_nodes.attrValue(element, "width");
+	const heightAttr = require_mathml_nodes.attrValue(element, "height");
+	const depthAttr = require_mathml_nodes.attrValue(element, "depth");
+	const widthPt = Math.max(0, (widthAttr === void 0 ? void 0 : require_mathml_length.parseMathLength(widthAttr, ctx.sizePt)) ?? 0);
+	const ascentPt = Math.max(0, (heightAttr === void 0 ? void 0 : require_mathml_length.parseMathLength(heightAttr, ctx.sizePt)) ?? 0);
+	const descentPt = Math.max(0, (depthAttr === void 0 ? void 0 : require_mathml_length.parseMathLength(depthAttr, ctx.sizePt)) ?? 0);
+	return {
+		widthPt,
+		ascentPt,
+		descentPt,
+		heightPt: ascentPt + descentPt,
+		items: []
+	};
+}
+function layoutNode(node, ctx) {
+	if (!require_mathml_nodes.isMathMlElement(node)) return require_mathml_compose.EMPTY_BOX;
+	switch (require_mathml_nodes.elementLocalName(node)) {
+		case "mrow": return layoutRowChildren(require_mathml_nodes.elementChildren(node), ctx);
+		case "semantics": return layoutSemantics(node, ctx);
+		case "mstyle": return layoutRowChildren(require_mathml_nodes.elementChildren(node), mstyleContext(node, ctx));
+		case "mi": {
+			const text = require_mathml_nodes.textContent(node);
+			return layoutToken(text, tokenVariant(node, miIntrinsicDefault(text), ctx), ctx);
+		}
+		case "mn": return layoutToken(require_mathml_nodes.textContent(node), tokenVariant(node, "normal", ctx), ctx);
+		case "mo": return layoutToken(require_mathml_nodes.textContent(node).trim(), tokenVariant(node, "normal", ctx), ctx);
+		case "mtext": return layoutToken(require_mathml_nodes.textContent(node), tokenVariant(node, "normal", ctx), ctx);
+		case "mspace": return layoutSpace(node, ctx);
+		case "msub": {
+			const children = require_mathml_nodes.elementChildren(node);
+			return layoutScripts(children[0] === void 0 ? require_mathml_compose.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 = require_mathml_nodes.elementChildren(node);
+			return layoutScripts(children[0] === void 0 ? require_mathml_compose.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 = require_mathml_nodes.elementChildren(node);
+			const base = children[0] === void 0 ? require_mathml_compose.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(require_mathml_nodes.elementChildren(node), ctx);
+		default: return unsupported(ctx, node);
+	}
+}
+function layoutFormula(mathml, options) {
+	const diagnostics = [];
+	const ctx = rootContext(options, diagnostics);
+	return {
+		box: layoutRowChildren(mathml.filter(require_mathml_nodes.isMathMlElement), ctx),
+		diagnostics
+	};
+}
+//#endregion
+Object.defineProperty(exports, "horizontallyStretchedBox", {
+	enumerable: true,
+	get: function() {
+		return horizontallyStretchedBox;
+	}
+});
+Object.defineProperty(exports, "isMovableLimitsOperator", {
+	enumerable: true,
+	get: function() {
+		return isMovableLimitsOperator;
+	}
+});
+Object.defineProperty(exports, "isStretchyOperator", {
+	enumerable: true,
+	get: function() {
+		return isStretchyOperator;
+	}
+});
+Object.defineProperty(exports, "layoutFormula", {
+	enumerable: true,
+	get: function() {
+		return layoutFormula;
+	}
+});
+Object.defineProperty(exports, "layoutNode", {
+	enumerable: true,
+	get: function() {
+		return layoutNode;
+	}
+});
+Object.defineProperty(exports, "layoutRowChildren", {
+	enumerable: true,
+	get: function() {
+		return layoutRowChildren;
+	}
+});
+Object.defineProperty(exports, "layoutScripts", {
+	enumerable: true,
+	get: function() {
+		return layoutScripts;
+	}
+});
+Object.defineProperty(exports, "layoutSemantics", {
+	enumerable: true,
+	get: function() {
+		return layoutSemantics;
+	}
+});
+Object.defineProperty(exports, "layoutUnderOver", {
+	enumerable: true,
+	get: function() {
+		return layoutUnderOver;
+	}
+});
+Object.defineProperty(exports, "layoutUnderOverChild", {
+	enumerable: true,
+	get: function() {
+		return layoutUnderOverChild;
+	}
+});
+Object.defineProperty(exports, "mstyleContext", {
+	enumerable: true,
+	get: function() {
+		return mstyleContext;
+	}
+});
+Object.defineProperty(exports, "singleCodePoint", {
+	enumerable: true,
+	get: function() {
+		return singleCodePoint;
+	}
+});
+Object.defineProperty(exports, "stretchHorizontalOperator", {
+	enumerable: true,
+	get: function() {
+		return stretchHorizontalOperator;
+	}
+});
+Object.defineProperty(exports, "stretchOperator", {
+	enumerable: true,
+	get: function() {
+		return stretchOperator;
+	}
+});
+Object.defineProperty(exports, "stretchRowOperators", {
+	enumerable: true,
+	get: function() {
+		return stretchRowOperators;
+	}
+});
+Object.defineProperty(exports, "stretchedBox", {
+	enumerable: true,
+	get: function() {
+		return stretchedBox;
+	}
+});

package/dist/layout-types-oSbHvZid.d.cts

@@ -0,0 +1,13 @@
+import { MathBox } from "document-schema.js";
+//#region src/mathml/layout-types.d.ts
+type MathDiagnosticKind = "unsupported-element" | "missing-glyph";
+interface MathDiagnostic {
+  readonly kind: MathDiagnosticKind;
+  readonly detail: string;
+}
+interface MathLayoutResult {
+  readonly box: MathBox;
+  readonly diagnostics: readonly MathDiagnostic[];
+}
+//#endregion
+export { MathDiagnosticKind as n, MathLayoutResult as r, MathDiagnostic as t };

package/dist/layout-types-oSbHvZid.d.ts

@@ -0,0 +1,13 @@
+import { MathBox } from "document-schema.js";
+//#region src/mathml/layout-types.d.ts
+type MathDiagnosticKind = "unsupported-element" | "missing-glyph";
+interface MathDiagnostic {
+  readonly kind: MathDiagnosticKind;
+  readonly detail: string;
+}
+interface MathLayoutResult {
+  readonly box: MathBox;
+  readonly diagnostics: readonly MathDiagnostic[];
+}
+//#endregion
+export { MathDiagnosticKind as n, MathLayoutResult as r, MathDiagnostic as t };