reamkit 0.1.0-alpha.0

package/dist/esm/pdf/math-layout.js

@@ -0,0 +1,1138 @@
+//#region src/pdf/math-layout.ts
+var ASCENT = .72;
+var DESCENT = .2;
+var AXIS = .26;
+var BAR_THICK = .045;
+var FRAC_GAP = .15;
+var FRAC_PAD = .12;
+var SCRIPT_SIZE = .7;
+function variantStyle(v) {
+	return {
+		bold: v === "bold" || v === "boldItalic",
+		italic: v === "italic" || v === "boldItalic"
+	};
+}
+var variantOf = (italic, bold) => bold ? italic ? "boldItalic" : "bold" : italic ? "italic" : "regular";
+function isAutoItalic(ch) {
+	return /[A-Za-z]/.test(ch) || ch >= "α" && ch <= "ω" || ch >= "Α" && ch <= "Ω";
+}
+function runCharVariant(ch, run) {
+	const bold = run.bold ?? false;
+	return variantOf(run.nor ? false : run.italic ?? isAutoItalic(ch), bold);
+}
+function layoutMath(node, ctx, measure) {
+	switch (node.type) {
+		case "run": return layoutRun(node, ctx, measure);
+		case "row": return layoutRow(node, ctx, measure);
+		case "fraction": return layoutFraction(node, ctx, measure);
+		case "script": return layoutScript(node, ctx, measure);
+		case "radical": return layoutRadical(node, ctx, measure);
+		case "nary": return layoutNary(node, ctx, measure);
+		case "func": return layoutFunc(node, ctx, measure);
+		case "limit": return layoutLimit(node, ctx, measure);
+		case "delimiter": return layoutDelimiter(node, ctx, measure);
+		case "matrix": return layoutMatrix(node, ctx, measure);
+		case "eqArr": return layoutEqArray(node, ctx, measure);
+		case "accent": return layoutAccent(node, ctx, measure);
+		case "bar": return layoutBar(node, ctx, measure);
+		case "groupChr": return layoutGroupChr(node, ctx, measure);
+		default: return emptyBox();
+	}
+}
+var emptyBox = () => ({
+	width: 0,
+	ascent: 0,
+	descent: 0,
+	items: []
+});
+var MATH_BINARY = new Set([
+	"+",
+	"−",
+	"-",
+	"±",
+	"∓",
+	"×",
+	"÷",
+	"⋅",
+	"∗",
+	"⊕",
+	"⊗",
+	"∘"
+]);
+var MATH_RELATION = new Set([
+	"=",
+	"≠",
+	"<",
+	">",
+	"≤",
+	"≥",
+	"≈",
+	"≡",
+	"≅",
+	"∝",
+	"→",
+	"←",
+	"↔",
+	"∈",
+	"∉",
+	"⊂",
+	"⊃",
+	"⊆",
+	"⊇",
+	"≪",
+	"≫"
+]);
+function isSpacedOp(ch, i, n) {
+	return (MATH_BINARY.has(ch) || MATH_RELATION.has(ch)) && i > 0 && i < n - 1;
+}
+function layoutRun(run, ctx, measure) {
+	const size = ctx.sizePt;
+	const chars = [...run.text];
+	if (chars.length === 0) return emptyBox();
+	const med = .2 * size;
+	const items = [];
+	let x = 0;
+	let i = 0;
+	while (i < chars.length) {
+		const v = runCharVariant(chars[i], run);
+		if (isSpacedOp(chars[i], i, chars.length)) {
+			x += med;
+			items.push({
+				kind: "glyph",
+				x,
+				y: 0,
+				text: chars[i],
+				variant: v,
+				sizePt: size
+			});
+			x += measure(chars[i], size, v) + med;
+			i++;
+			continue;
+		}
+		let seg = "";
+		let j = i;
+		while (j < chars.length && runCharVariant(chars[j], run) === v && !isSpacedOp(chars[j], j, chars.length)) {
+			seg += chars[j];
+			j++;
+		}
+		items.push({
+			kind: "glyph",
+			x,
+			y: 0,
+			text: seg,
+			variant: v,
+			sizePt: size
+		});
+		x += measure(seg, size, v);
+		i = j;
+	}
+	return {
+		width: x,
+		ascent: size * ASCENT,
+		descent: size * DESCENT,
+		items
+	};
+}
+function layoutRow(node, ctx, measure) {
+	let x = 0;
+	let ascent = 0;
+	let descent = 0;
+	const items = [];
+	for (const child of node.children) {
+		const box = layoutMath(child, ctx, measure);
+		for (const it of shiftItems(box.items, x, 0)) items.push(it);
+		x += box.width;
+		ascent = Math.max(ascent, box.ascent);
+		descent = Math.max(descent, box.descent);
+	}
+	return {
+		width: x,
+		ascent,
+		descent,
+		items
+	};
+}
+function layoutFraction(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const numBox = layoutMath(node.num, ctx, measure);
+	const denBox = layoutMath(node.den, ctx, measure);
+	const pad = FRAC_PAD * size;
+	const width = Math.max(numBox.width, denBox.width) + 2 * pad;
+	const barThick = Math.max(BAR_THICK * size, .5);
+	const axis = AXIS * size;
+	const gap = FRAC_GAP * size;
+	const items = [];
+	const numBaseY = axis + barThick / 2 + gap + numBox.descent;
+	const numX = (width - numBox.width) / 2;
+	for (const it of shiftItems(numBox.items, numX, numBaseY)) items.push(it);
+	const denBaseY = axis - barThick / 2 - gap - denBox.ascent;
+	const denX = (width - denBox.width) / 2;
+	for (const it of shiftItems(denBox.items, denX, denBaseY)) items.push(it);
+	if (!node.barless) items.push({
+		kind: "rule",
+		x: pad * .5,
+		y: axis - barThick / 2,
+		w: width - pad,
+		h: barThick
+	});
+	return {
+		width,
+		ascent: numBaseY + numBox.ascent,
+		descent: -(denBaseY - denBox.descent),
+		items
+	};
+}
+function layoutScript(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const scriptSize = size * SCRIPT_SIZE;
+	const baseBox = layoutMath(node.base, ctx, measure);
+	const supBox = node.sup ? layoutMath(node.sup, { sizePt: scriptSize }, measure) : void 0;
+	const subBox = node.sub ? layoutMath(node.sub, { sizePt: scriptSize }, measure) : void 0;
+	const kern = .05 * size;
+	const scriptW = Math.max(supBox?.width ?? 0, subBox?.width ?? 0);
+	const baseX = node.pre ? scriptW + kern : 0;
+	const scriptX = node.pre ? 0 : baseBox.width + kern;
+	const items = [...shiftItems(baseBox.items, baseX, 0)];
+	let ascent = baseBox.ascent;
+	let descent = baseBox.descent;
+	if (supBox) {
+		const supShift = Math.max(baseBox.ascent - .25 * scriptSize, .45 * size);
+		for (const it of shiftItems(supBox.items, scriptX, supShift)) items.push(it);
+		ascent = Math.max(ascent, supShift + supBox.ascent);
+	}
+	if (subBox) {
+		const subShift = Math.max(baseBox.descent + .2 * scriptSize, .18 * size);
+		for (const it of shiftItems(subBox.items, scriptX, -subShift)) items.push(it);
+		descent = Math.max(descent, subShift + subBox.descent);
+	}
+	return {
+		width: baseBox.width + kern + scriptW,
+		ascent,
+		descent,
+		items
+	};
+}
+function layoutRadical(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const radBox = layoutMath(node.radicand, ctx, measure);
+	const rule = Math.max(.05 * size, .6);
+	const gap = .12 * size;
+	const radAsc = radBox.ascent;
+	const radDesc = radBox.descent;
+	const radH = radAsc + radDesc;
+	const barY = radAsc + gap;
+	const surdW = Math.max(.5 * size, radH * .45);
+	const bottom = -radDesc - rule * .5;
+	const pad = .12 * size;
+	const items = [];
+	let degW = 0;
+	if (node.degree) {
+		const degBox = layoutMath(node.degree, { sizePt: size * .5 }, measure);
+		degW = degBox.width;
+		for (const it of shiftItems(degBox.items, 0, barY * .35)) items.push(it);
+	}
+	const surdX = degW;
+	const surd = [
+		{
+			op: "move",
+			x: surdX,
+			y: barY - radH * .5
+		},
+		{
+			op: "line",
+			x: surdX + surdW * .45,
+			y: bottom
+		},
+		{
+			op: "line",
+			x: surdX + surdW * .85,
+			y: barY
+		},
+		{
+			op: "line",
+			x: surdX + surdW + radBox.width + pad,
+			y: barY
+		}
+	];
+	items.push({
+		kind: "path",
+		segments: surd,
+		strokeWidthPt: Math.max(rule, .8)
+	});
+	for (const it of shiftItems(radBox.items, surdX + surdW, 0)) items.push(it);
+	return {
+		width: degW + surdW + radBox.width + pad,
+		ascent: barY + rule,
+		descent: radDesc + rule,
+		items
+	};
+}
+var NARY_AXIS = .28;
+var SUM_LIKE = new Set([
+	"∑",
+	"∏",
+	"∐",
+	"⋃",
+	"⋂",
+	"⋁",
+	"⋀",
+	"⨀",
+	"⨁",
+	"⨂"
+]);
+function layoutBigOp(op, size, measure) {
+	const axisC = NARY_AXIS * size;
+	if (op === "∑") {
+		const half = size * .75;
+		const top = axisC + half;
+		const bot = axisC - half;
+		const w = size * .85;
+		const segs = [
+			{
+				op: "move",
+				x: w,
+				y: top
+			},
+			{
+				op: "line",
+				x: 0,
+				y: top
+			},
+			{
+				op: "line",
+				x: w * .52,
+				y: axisC
+			},
+			{
+				op: "line",
+				x: 0,
+				y: bot
+			},
+			{
+				op: "line",
+				x: w,
+				y: bot
+			}
+		];
+		return bigOpBox(w + size * .08, top, bot, segs, Math.max(size * .075, 1));
+	}
+	if (op === "∏") {
+		const half = size * .75;
+		const top = axisC + half;
+		const bot = axisC - half;
+		const w = size * .9;
+		const segs = [
+			{
+				op: "move",
+				x: 0,
+				y: top
+			},
+			{
+				op: "line",
+				x: w,
+				y: top
+			},
+			{
+				op: "move",
+				x: w * .22,
+				y: top
+			},
+			{
+				op: "line",
+				x: w * .22,
+				y: bot
+			},
+			{
+				op: "move",
+				x: w * .78,
+				y: top
+			},
+			{
+				op: "line",
+				x: w * .78,
+				y: bot
+			}
+		];
+		return bigOpBox(w + size * .08, top, bot, segs, Math.max(size * .08, 1));
+	}
+	if (op === "∫" || op === "∮") {
+		const half = size * .95;
+		const top = axisC + half;
+		const bot = axisC - half;
+		const w = size * .5;
+		const segs = [
+			{
+				op: "move",
+				x: w * .72,
+				y: top
+			},
+			{
+				op: "cubic",
+				x1: w * .2,
+				y1: top,
+				x2: w * .78,
+				y2: axisC,
+				x: w * .42,
+				y: axisC
+			},
+			{
+				op: "cubic",
+				x1: w * .06,
+				y1: axisC,
+				x2: w * .64,
+				y2: bot,
+				x: w * .12,
+				y: bot
+			}
+		];
+		return bigOpBox(w + size * .06, top, bot, segs, Math.max(size * .06, .9));
+	}
+	const opSize = size * 1.4;
+	return {
+		width: measure(op, opSize, "regular"),
+		ascent: opSize * ASCENT,
+		descent: opSize * DESCENT,
+		items: [{
+			kind: "glyph",
+			x: 0,
+			y: 0,
+			text: op,
+			variant: "regular",
+			sizePt: opSize
+		}]
+	};
+}
+function bigOpBox(width, top, bot, segments, strokeWidthPt) {
+	return {
+		width,
+		ascent: top,
+		descent: -bot,
+		items: [{
+			kind: "path",
+			segments,
+			strokeWidthPt
+		}]
+	};
+}
+function layoutNary(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const opBox = layoutBigOp(node.op, size, measure);
+	const scriptSize = size * SCRIPT_SIZE;
+	const subBox = node.sub ? layoutMath(node.sub, { sizePt: scriptSize }, measure) : void 0;
+	const supBox = node.sup ? layoutMath(node.sup, { sizePt: scriptSize }, measure) : void 0;
+	const bodyBox = layoutMath(node.body, ctx, measure);
+	const undOvr = node.limLoc === "undOvr" || node.limLoc === void 0 && SUM_LIKE.has(node.op);
+	const items = [];
+	let ascent = opBox.ascent;
+	let descent = opBox.descent;
+	let opGroupW;
+	if (undOvr) {
+		const stackW = Math.max(opBox.width, subBox?.width ?? 0, supBox?.width ?? 0);
+		for (const it of shiftItems(opBox.items, (stackW - opBox.width) / 2, 0)) items.push(it);
+		const gap = .06 * size;
+		if (supBox) {
+			const supY = opBox.ascent + gap + supBox.descent;
+			for (const it of shiftItems(supBox.items, (stackW - supBox.width) / 2, supY)) items.push(it);
+			ascent = Math.max(ascent, supY + supBox.ascent);
+		}
+		if (subBox) {
+			const subY = -(opBox.descent + gap + subBox.ascent);
+			for (const it of shiftItems(subBox.items, (stackW - subBox.width) / 2, subY)) items.push(it);
+			descent = Math.max(descent, -(subY - subBox.descent));
+		}
+		opGroupW = stackW;
+	} else {
+		for (const it of opBox.items) items.push(it);
+		const scriptX = opBox.width + .02 * size;
+		let scriptW = 0;
+		if (supBox) {
+			const supY = opBox.ascent - .4 * scriptSize;
+			for (const it of shiftItems(supBox.items, scriptX, supY)) items.push(it);
+			ascent = Math.max(ascent, supY + supBox.ascent);
+			scriptW = Math.max(scriptW, supBox.width);
+		}
+		if (subBox) {
+			const subY = -opBox.descent + .2 * scriptSize - subBox.ascent;
+			for (const it of shiftItems(subBox.items, scriptX, subY)) items.push(it);
+			descent = Math.max(descent, -(subY - subBox.descent));
+			scriptW = Math.max(scriptW, subBox.width);
+		}
+		opGroupW = opBox.width + .02 * size + scriptW;
+	}
+	const bodyX = opGroupW + .12 * size;
+	for (const it of shiftItems(bodyBox.items, bodyX, 0)) items.push(it);
+	return {
+		width: bodyX + bodyBox.width,
+		ascent: Math.max(ascent, bodyBox.ascent),
+		descent: Math.max(descent, bodyBox.descent),
+		items
+	};
+}
+function layoutFunc(node, ctx, measure) {
+	const nameBox = layoutMath(node.name, ctx, measure);
+	const bodyBox = layoutMath(node.body, ctx, measure);
+	const sp = .16 * ctx.sizePt;
+	const items = [...nameBox.items, ...shiftItems(bodyBox.items, nameBox.width + sp, 0)];
+	return {
+		width: nameBox.width + sp + bodyBox.width,
+		ascent: Math.max(nameBox.ascent, bodyBox.ascent),
+		descent: Math.max(nameBox.descent, bodyBox.descent),
+		items
+	};
+}
+function layoutLimit(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const baseBox = layoutMath(node.base, ctx, measure);
+	const limBox = layoutMath(node.lim, { sizePt: size * SCRIPT_SIZE }, measure);
+	const w = Math.max(baseBox.width, limBox.width);
+	const items = [...shiftItems(baseBox.items, (w - baseBox.width) / 2, 0)];
+	const gap = .08 * size;
+	let ascent = baseBox.ascent;
+	let descent = baseBox.descent;
+	if (node.pos === "low") {
+		const limY = -(baseBox.descent + gap + limBox.ascent);
+		for (const it of shiftItems(limBox.items, (w - limBox.width) / 2, limY)) items.push(it);
+		descent = -(limY - limBox.descent);
+	} else {
+		const limY = baseBox.ascent + gap + limBox.descent;
+		for (const it of shiftItems(limBox.items, (w - limBox.width) / 2, limY)) items.push(it);
+		ascent = limY + limBox.ascent;
+	}
+	return {
+		width: w,
+		ascent,
+		descent,
+		items
+	};
+}
+function bracketGlyph(chr, asc, desc, size) {
+	if (chr === "") return {
+		width: 0,
+		items: []
+	};
+	const margin = .1 * size;
+	const top = asc + margin;
+	const bot = -desc - margin;
+	const mid = (top + bot) / 2;
+	const stroke = Math.max(.06 * size, .8);
+	const isOpen = "([{⟨〈⌊⌈".includes(chr);
+	const path = (segments, width) => ({
+		width,
+		items: [{
+			kind: "path",
+			segments,
+			strokeWidthPt: stroke
+		}]
+	});
+	if (chr === "(" || chr === ")") {
+		const w = .32 * size;
+		const bulge = w * .85;
+		const x0 = isOpen ? w : 0;
+		const dir = isOpen ? -1 : 1;
+		return path([{
+			op: "move",
+			x: x0,
+			y: top
+		}, {
+			op: "cubic",
+			x1: x0 + dir * bulge,
+			y1: mid + .45 * (top - mid),
+			x2: x0 + dir * bulge,
+			y2: mid - .45 * (top - mid),
+			x: x0,
+			y: bot
+		}], w);
+	}
+	if (chr === "[" || chr === "]") {
+		const w = .26 * size;
+		const xV = isOpen ? 0 : w;
+		const xA = isOpen ? w : 0;
+		return path([
+			{
+				op: "move",
+				x: xA,
+				y: top
+			},
+			{
+				op: "line",
+				x: xV,
+				y: top
+			},
+			{
+				op: "line",
+				x: xV,
+				y: bot
+			},
+			{
+				op: "line",
+				x: xA,
+				y: bot
+			}
+		], w);
+	}
+	if (chr === "{" || chr === "}") {
+		const w = .4 * size;
+		const dir = isOpen ? 1 : -1;
+		const xb = isOpen ? w : 0;
+		const tip = xb - dir * w;
+		return path([
+			{
+				op: "move",
+				x: xb,
+				y: top
+			},
+			{
+				op: "cubic",
+				x1: xb - dir * w * .5,
+				y1: top,
+				x2: xb - dir * w * .5,
+				y2: mid + .25 * (top - mid),
+				x: tip,
+				y: mid
+			},
+			{
+				op: "cubic",
+				x1: xb - dir * w * .5,
+				y1: mid - .25 * (top - mid),
+				x2: xb - dir * w * .5,
+				y2: bot,
+				x: xb,
+				y: bot
+			}
+		], w);
+	}
+	if (chr === "⟨" || chr === "⟩" || chr === "〈" || chr === "〉") {
+		const w = .3 * size;
+		const xPoint = isOpen ? 0 : w;
+		const xOpen = isOpen ? w : 0;
+		return path([
+			{
+				op: "move",
+				x: xOpen,
+				y: top
+			},
+			{
+				op: "line",
+				x: xPoint,
+				y: mid
+			},
+			{
+				op: "line",
+				x: xOpen,
+				y: bot
+			}
+		], w);
+	}
+	if (chr === "‖") {
+		const w = .3 * size;
+		return path([
+			{
+				op: "move",
+				x: w * .3,
+				y: top
+			},
+			{
+				op: "line",
+				x: w * .3,
+				y: bot
+			},
+			{
+				op: "move",
+				x: w * .7,
+				y: top
+			},
+			{
+				op: "line",
+				x: w * .7,
+				y: bot
+			}
+		], w);
+	}
+	const w = .18 * size;
+	return path([{
+		op: "move",
+		x: w / 2,
+		y: top
+	}, {
+		op: "line",
+		x: w / 2,
+		y: bot
+	}], w);
+}
+function layoutDelimiter(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const inner = [];
+	let innerW = 0;
+	let innerAsc = 0;
+	let innerDesc = 0;
+	node.children.forEach((child, i) => {
+		if (i > 0 && node.sepChr) {
+			const sepBox = layoutMath({
+				type: "run",
+				text: node.sepChr,
+				nor: true
+			}, ctx, measure);
+			for (const it of shiftItems(sepBox.items, innerW, 0)) inner.push(it);
+			innerW += sepBox.width;
+			innerAsc = Math.max(innerAsc, sepBox.ascent);
+			innerDesc = Math.max(innerDesc, sepBox.descent);
+		}
+		const box = layoutMath(child, ctx, measure);
+		for (const it of shiftItems(box.items, innerW, 0)) inner.push(it);
+		innerW += box.width;
+		innerAsc = Math.max(innerAsc, box.ascent);
+		innerDesc = Math.max(innerDesc, box.descent);
+	});
+	innerAsc = Math.max(innerAsc, size * .6);
+	innerDesc = Math.max(innerDesc, size * .2);
+	const open = bracketGlyph(node.begChr, innerAsc, innerDesc, size);
+	const close = bracketGlyph(node.endChr, innerAsc, innerDesc, size);
+	const items = [...open.items];
+	for (const it of shiftItems(inner, open.width, 0)) items.push(it);
+	for (const it of shiftItems(close.items, open.width + innerW, 0)) items.push(it);
+	const margin = .1 * size;
+	return {
+		width: open.width + innerW + close.width,
+		ascent: innerAsc + margin,
+		descent: innerDesc + margin,
+		items
+	};
+}
+function layoutMatrix(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const cells = node.rows.map((row) => row.map((cell) => layoutMath(cell, ctx, measure)));
+	const nCols = Math.max(0, ...cells.map((r) => r.length));
+	const colW = new Array(nCols).fill(0);
+	const rowAsc = [];
+	const rowDesc = [];
+	cells.forEach((row, ri) => {
+		let a = 0;
+		let d = 0;
+		row.forEach((cb, ci) => {
+			colW[ci] = Math.max(colW[ci], cb.width);
+			a = Math.max(a, cb.ascent);
+			d = Math.max(d, cb.descent);
+		});
+		rowAsc[ri] = a;
+		rowDesc[ri] = d;
+	});
+	const colGap = .7 * size;
+	const rowGap = .35 * size;
+	const totalW = colW.reduce((s, w) => s + w, 0) + colGap * Math.max(0, nCols - 1);
+	const rowH = rowAsc.map((a, i) => a + rowDesc[i]);
+	const totalH = rowH.reduce((s, h) => s + h, 0) + rowGap * Math.max(0, cells.length - 1);
+	const axis = AXIS * size;
+	const items = [];
+	let y = totalH / 2 + axis;
+	cells.forEach((row, ri) => {
+		const baseline = y - rowAsc[ri];
+		let x = 0;
+		row.forEach((cb, ci) => {
+			const cellX = x + (colW[ci] - cb.width) / 2;
+			for (const it of shiftItems(cb.items, cellX, baseline)) items.push(it);
+			x += colW[ci] + colGap;
+		});
+		y -= rowH[ri] + rowGap;
+	});
+	return {
+		width: totalW,
+		ascent: totalH / 2 + axis,
+		descent: totalH / 2 - axis,
+		items
+	};
+}
+function layoutEqArray(node, ctx, measure) {
+	const size = ctx.sizePt;
+	const boxes = node.rows.map((r) => layoutMath(r, ctx, measure));
+	const width = Math.max(0, ...boxes.map((b) => b.width));
+	const rowGap = .5 * size;
+	const rowH = boxes.map((b) => b.ascent + b.descent);
+	const totalH = rowH.reduce((s, h) => s + h, 0) + rowGap * Math.max(0, boxes.length - 1);
+	const axis = AXIS * size;
+	const items = [];
+	let y = totalH / 2 + axis;
+	boxes.forEach((b, i) => {
+		const baseline = y - b.ascent;
+		for (const it of shiftItems(b.items, 0, baseline)) items.push(it);
+		y -= rowH[i] + rowGap;
+	});
+	return {
+		width,
+		ascent: totalH / 2 + axis,
+		descent: totalH / 2 - axis,
+		items
+	};
+}
+function layoutAccent(node, ctx, measure) {
+	const baseBox = layoutMath(node.base, ctx, measure);
+	const size = ctx.sizePt;
+	const y = baseBox.ascent + .04 * size;
+	const cx = baseBox.width / 2;
+	const items = [...baseBox.items];
+	const accH = drawAccent(node.char, cx, y, baseBox.width, size, items);
+	return {
+		width: baseBox.width,
+		ascent: y + accH,
+		descent: baseBox.descent,
+		items
+	};
+}
+function drawAccent(char, cx, y, baseW, size, items) {
+	const aw = Math.min(baseW * .85, .7 * size);
+	const stroke = Math.max(.05 * size, .7);
+	const cp = char.codePointAt(0) ?? 0;
+	if (char === "^" || char === "ˆ" || cp === 770) {
+		const h = .18 * size;
+		items.push({
+			kind: "path",
+			segments: [
+				{
+					op: "move",
+					x: cx - aw / 2,
+					y
+				},
+				{
+					op: "line",
+					x: cx,
+					y: y + h
+				},
+				{
+					op: "line",
+					x: cx + aw / 2,
+					y
+				}
+			],
+			strokeWidthPt: stroke
+		});
+		return h;
+	}
+	if (char === "~" || char === "˜" || cp === 771) {
+		const h = .12 * size;
+		items.push({
+			kind: "path",
+			segments: [
+				{
+					op: "move",
+					x: cx - aw / 2,
+					y
+				},
+				{
+					op: "cubic",
+					x1: cx - aw * .25,
+					y1: y + h,
+					x2: cx - aw * .1,
+					y2: y - h * .4,
+					x: cx,
+					y: y + h * .3
+				},
+				{
+					op: "cubic",
+					x1: cx + aw * .1,
+					y1: y + h,
+					x2: cx + aw * .25,
+					y2: y - h * .4,
+					x: cx + aw / 2,
+					y
+				}
+			],
+			strokeWidthPt: stroke
+		});
+		return h;
+	}
+	if (char === "→" || cp === 8407) {
+		const sh = y + .06 * size;
+		const head = .06 * size;
+		items.push({
+			kind: "path",
+			segments: [
+				{
+					op: "move",
+					x: cx - aw / 2,
+					y: sh
+				},
+				{
+					op: "line",
+					x: cx + aw / 2,
+					y: sh
+				},
+				{
+					op: "move",
+					x: cx + aw / 2 - head,
+					y: sh + head
+				},
+				{
+					op: "line",
+					x: cx + aw / 2,
+					y: sh
+				},
+				{
+					op: "line",
+					x: cx + aw / 2 - head,
+					y: sh - head
+				}
+			],
+			strokeWidthPt: stroke
+		});
+		return .14 * size;
+	}
+	if (char === "." || cp === 775) {
+		const d = Math.max(.07 * size, 1);
+		items.push({
+			kind: "rule",
+			x: cx - d / 2,
+			y,
+			w: d,
+			h: d
+		});
+		return .1 * size + d;
+	}
+	if (cp === 776) {
+		const d = Math.max(.07 * size, 1);
+		const off = .12 * size;
+		items.push({
+			kind: "rule",
+			x: cx - off - d / 2,
+			y,
+			w: d,
+			h: d
+		});
+		items.push({
+			kind: "rule",
+			x: cx + off - d / 2,
+			y,
+			w: d,
+			h: d
+		});
+		return .1 * size + d;
+	}
+	items.push({
+		kind: "rule",
+		x: cx - aw / 2,
+		y,
+		w: aw,
+		h: stroke
+	});
+	return .08 * size;
+}
+function layoutBar(node, ctx, measure) {
+	const baseBox = layoutMath(node.base, ctx, measure);
+	const size = ctx.sizePt;
+	const rule = Math.max(.05 * size, .6);
+	const gap = .08 * size;
+	const items = [...baseBox.items];
+	if (node.pos === "top") {
+		const y = baseBox.ascent + gap;
+		items.push({
+			kind: "rule",
+			x: 0,
+			y,
+			w: baseBox.width,
+			h: rule
+		});
+		return {
+			width: baseBox.width,
+			ascent: y + rule,
+			descent: baseBox.descent,
+			items
+		};
+	}
+	const y = -baseBox.descent - gap - rule;
+	items.push({
+		kind: "rule",
+		x: 0,
+		y,
+		w: baseBox.width,
+		h: rule
+	});
+	return {
+		width: baseBox.width,
+		ascent: baseBox.ascent,
+		descent: -y,
+		items
+	};
+}
+function layoutGroupChr(node, ctx, measure) {
+	const baseBox = layoutMath(node.base, ctx, measure);
+	const size = ctx.sizePt;
+	const gap = .06 * size;
+	const braceH = .18 * size;
+	const stroke = Math.max(.05 * size, .7);
+	const w = baseBox.width;
+	const items = [...baseBox.items];
+	const hbrace = (yBase, dir) => [
+		{
+			op: "move",
+			x: 0,
+			y: yBase
+		},
+		{
+			op: "cubic",
+			x1: w * .1,
+			y1: yBase,
+			x2: w * .4,
+			y2: yBase,
+			x: w / 2 - .02 * size,
+			y: yBase + dir * braceH
+		},
+		{
+			op: "move",
+			x: w,
+			y: yBase
+		},
+		{
+			op: "cubic",
+			x1: w * .9,
+			y1: yBase,
+			x2: w * .6,
+			y2: yBase,
+			x: w / 2 + .02 * size,
+			y: yBase + dir * braceH
+		}
+	];
+	if (node.pos === "top") {
+		const yBase = baseBox.ascent + gap + braceH;
+		items.push({
+			kind: "path",
+			segments: hbrace(yBase, -1),
+			strokeWidthPt: stroke
+		});
+		return {
+			width: w,
+			ascent: yBase,
+			descent: baseBox.descent,
+			items
+		};
+	}
+	const yBase = -baseBox.descent - gap - braceH;
+	items.push({
+		kind: "path",
+		segments: hbrace(yBase, 1),
+		strokeWidthPt: stroke
+	});
+	return {
+		width: w,
+		ascent: baseBox.ascent,
+		descent: -yBase,
+		items
+	};
+}
+function shiftItems(items, dx, dy) {
+	return items.map((it) => {
+		if (it.kind === "glyph") return {
+			...it,
+			x: it.x + dx,
+			y: it.y + dy
+		};
+		if (it.kind === "rule") return {
+			...it,
+			x: it.x + dx,
+			y: it.y + dy
+		};
+		return {
+			...it,
+			segments: it.segments.map((s) => shiftSegment(s, dx, dy))
+		};
+	});
+}
+function shiftSegment(s, dx, dy) {
+	switch (s.op) {
+		case "move":
+		case "line": return {
+			...s,
+			x: s.x + dx,
+			y: s.y + dy
+		};
+		case "cubic": return {
+			...s,
+			x1: s.x1 + dx,
+			y1: s.y1 + dy,
+			x2: s.x2 + dx,
+			y2: s.y2 + dy,
+			x: s.x + dx,
+			y: s.y + dy
+		};
+		case "close": return s;
+	}
+}
+function mathGlyphSegments(node) {
+	const out = [];
+	const visit = (n) => {
+		switch (n.type) {
+			case "run": {
+				const chars = [...n.text];
+				let i = 0;
+				while (i < chars.length) {
+					const v = runCharVariant(chars[i], n);
+					let seg = "";
+					let j = i;
+					while (j < chars.length && runCharVariant(chars[j], n) === v) {
+						seg += chars[j];
+						j++;
+					}
+					out.push({
+						variant: v,
+						text: seg
+					});
+					i = j;
+				}
+				break;
+			}
+			case "row":
+				n.children.forEach(visit);
+				break;
+			case "fraction":
+				visit(n.num);
+				visit(n.den);
+				break;
+			case "script":
+				visit(n.base);
+				if (n.sub) visit(n.sub);
+				if (n.sup) visit(n.sup);
+				break;
+			case "radical":
+				visit(n.radicand);
+				if (n.degree) visit(n.degree);
+				break;
+			case "nary":
+				out.push({
+					variant: "regular",
+					text: n.op
+				});
+				visit(n.body);
+				if (n.sub) visit(n.sub);
+				if (n.sup) visit(n.sup);
+				break;
+			case "func":
+				visit(n.name);
+				visit(n.body);
+				break;
+			case "limit":
+				visit(n.base);
+				visit(n.lim);
+				break;
+			case "delimiter":
+				if (n.sepChr) out.push({
+					variant: "regular",
+					text: n.sepChr
+				});
+				n.children.forEach(visit);
+				break;
+			case "matrix":
+				n.rows.forEach((row) => row.forEach(visit));
+				break;
+			case "eqArr":
+				n.rows.forEach(visit);
+				break;
+			case "accent":
+			case "bar":
+			case "groupChr":
+				visit(n.base);
+				break;
+			default: break;
+		}
+	};
+	visit(node);
+	return out;
+}
+//#endregion
+export { layoutMath, mathGlyphSegments, variantStyle };