documents.js 1.57.1 → 1.59.0

package/dist/mathml/layout.cjs

@@ -0,0 +1,373 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_mathml_compose = require("./compose.cjs");
+const require_mathml_length = require("./length.cjs");
+const require_mathml_nodes = require("./nodes.cjs");
+const require_mathml_operators = require("./operators.cjs");
+const require_mathml_radical = require("./radical.cjs");
+const require_mathml_variant = require("./variant.cjs");
+//#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: 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);
+	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 require_mathml_compose.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 = 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 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 && require_mathml_nodes.elementLocalName(previous) === "mo") gapEm += require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(previous).trim()).rspaceEm;
+		if (require_mathml_nodes.elementLocalName(child) === "mo") gapEm += require_mathml_operators.operatorProperties(require_mathml_nodes.textContent(child).trim()).lspaceEm;
+		return gapEm * ctx.sizePt;
+	});
+	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;
+	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 = [...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) {
+	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 = [...require_mathml_compose.placeChild(base, (widthPt - base.widthPt) / 2, 0, ascentPt)];
+	if (over !== void 0) items.push(...require_mathml_compose.placeChild(over, (widthPt - over.widthPt) / 2, -(base.ascentPt + gapPt + over.descentPt), ascentPt));
+	if (under !== void 0) items.push(...require_mathml_compose.placeChild(under, (widthPt - under.widthPt) / 2, 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;
+}
+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 === "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 = require_mathml_nodes.elementChildren(element);
+	const numeratorElement = children[0];
+	const denominatorElement = children[1];
+	if (numeratorElement === void 0 || 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 sign = require_mathml_radical.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,
+		...require_mathml_compose.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(...require_mathml_compose.shiftItems(index.items, metrics.radicalKernBeforeDegreePt, degreeBaselineFromTopPt - index.ascentPt));
+	}
+	return {
+		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");
+	if (rows.length === 0) return require_mathml_compose.EMPTY_BOX;
+	const columnAligns = (require_mathml_nodes.attrValue(element, "columnalign") ?? "").trim().split(/\s+/).filter((s) => s.length > 0);
+	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 = [];
+	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(...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
+exports.layoutFormula = layoutFormula;
+exports.layoutNode = layoutNode;

package/dist/mathml/layout.d.cts

@@ -0,0 +1,24 @@
+import { MathBox, MathColor, MathDiagnostic, MathLayoutResult } from "./layout-types.cjs";
+import { MathFontMetrics } from "./metrics.cjs";
+import { r as MathMlNode } from "../nodes-pArN9ilm.cjs";
+import { MathVariant } from "./variant.cjs";
+//#region src/mathml/layout.d.ts
+interface LayoutFormulaOptions {
+  readonly metrics: MathFontMetrics;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface LayoutContext {
+  readonly metrics: MathFontMetrics;
+  readonly sizePt: number;
+  readonly color: MathColor;
+  readonly inheritedVariant: MathVariant | undefined;
+  readonly displayStyle: boolean;
+  readonly cramped: boolean;
+  readonly scriptLevel: number;
+  readonly diagnostics: MathDiagnostic[];
+}
+declare function layoutNode(node: MathMlNode, ctx: LayoutContext): MathBox;
+declare function layoutFormula(mathml: readonly MathMlNode[], options: LayoutFormulaOptions): MathLayoutResult;
+//#endregion
+export { LayoutFormulaOptions, layoutFormula, layoutNode };

package/dist/mathml/layout.d.ts

@@ -0,0 +1,24 @@
+import { MathBox, MathColor, MathDiagnostic, MathLayoutResult } from "./layout-types.js";
+import { MathFontMetrics } from "./metrics.js";
+import { r as MathMlNode } from "../nodes-pArN9ilm.js";
+import { MathVariant } from "./variant.js";
+//#region src/mathml/layout.d.ts
+interface LayoutFormulaOptions {
+  readonly metrics: MathFontMetrics;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface LayoutContext {
+  readonly metrics: MathFontMetrics;
+  readonly sizePt: number;
+  readonly color: MathColor;
+  readonly inheritedVariant: MathVariant | undefined;
+  readonly displayStyle: boolean;
+  readonly cramped: boolean;
+  readonly scriptLevel: number;
+  readonly diagnostics: MathDiagnostic[];
+}
+declare function layoutNode(node: MathMlNode, ctx: LayoutContext): MathBox;
+declare function layoutFormula(mathml: readonly MathMlNode[], options: LayoutFormulaOptions): MathLayoutResult;
+//#endregion
+export { LayoutFormulaOptions, layoutFormula, layoutNode };