reamkit 1.32.1 → 1.33.0

package/dist/esm/core/drawingml/chart-geometry.js

@@ -3,6 +3,24 @@ var AXIS_COLOR = "595959";
 var GRID_COLOR = "D9D9D9";
 var LABEL_COLOR = "595959";
 var TITLE_COLOR = "404040";
+/**
+* The face one role of the chart's text is set in: the chart's own
+* ({@link Chart.text}) where the reader resolved it, and otherwise the sizes
+* and greys this module has always drawn in, in the document's face.
+*/
+function faceOf(chart, role) {
+	const own = chart.text?.[role];
+	const title = role === "title";
+	return {
+		sizePt: own?.sizePt ?? (title ? 13 : 9),
+		colorHex: own?.colorHex ?? (title ? TITLE_COLOR : LABEL_COLOR),
+		...own?.family ? { family: own.family } : {},
+		...own?.bold ? { bold: true } : {},
+		...own?.italic ? { italic: true } : {}
+	};
+}
+/** The width of `text` set in `face`. */
+var widthIn = (measure, text, face) => measure(text, face.sizePt, face);
 /** The Office accent cycle (RRGGBB) for series without an explicit colour. */
 var SERIES_COLORS = [
 	"4472C4",
@@ -61,33 +79,38 @@ function niceScale(dataMin, dataMax, maxIntervals = 10) {
 }
 /**
 * The ends {@link niceScale} rounds out to its step: the data's, padded as
-* Excel pads them. Never past the largest double, which the padding of values
+* Excel pads them — by `pad` of their reach, 5%, which a 3-D chart's axis
+* does without: Excel's PDF runs 3-D columns of 70…96 on 0…100 by 10 and of
+* −5…15 on −6…16 by 2, where flat ones run 0…120 by 20 and −10…20 by 5
+* (2026-10-02). Never past the largest double, which the padding of values
 * out at ±1.7E+308 would run them to.
 */
-function paddedEnds(dataMin, dataMax) {
+function paddedEnds(dataMin, dataMax, pad = .05) {
 	let lo = Math.min(dataMin, dataMax);
 	let hi = Math.max(dataMin, dataMax);
-	if (lo === hi) if (hi > 0) lo = 0;
-	else if (lo < 0) hi = 0;
-	else hi = 1;
+	if (lo === hi) {
+		if (hi > 0) lo = 0;
+		else if (lo < 0) hi = 0;
+		else hi = 1;
+	}
 	const spread = hi - lo;
 	if (lo >= 0) {
 		const from = spread < hi / 6 ? lo - spread / 2 : 0;
 		return {
 			lo: from,
-			hi: finite(hi + (hi - from) * .05)
+			hi: finite(hi + (hi - from) * pad)
 		};
 	}
 	if (hi <= 0) {
 		const to = spread < -lo / 6 ? hi + spread / 2 : 0;
 		return {
-			lo: finite(lo - (to - lo) * .05),
+			lo: finite(lo - (to - lo) * pad),
 			hi: to
 		};
 	}
 	return {
-		lo: finite(lo - spread * .05),
-		hi: finite(hi + spread * .05)
+		lo: finite(lo - spread * pad),
+		hi: finite(hi + spread * pad)
 	};
 }
 /** `v`, or the largest double of its sign where it ran past it. */
@@ -113,7 +136,7 @@ function stepFor(lo, hi, maxIntervals) {
 			1,
 			2,
 			5
-		]) if (share <= m * base * 1.000000001) return Math.min(m * base, Number.MAX_VALUE);
+		]) if (share <= m * base * (1 + 1e-9)) return Math.min(m * base, Number.MAX_VALUE);
 		base *= 10;
 	}
 }
@@ -166,7 +189,7 @@ function formatTick(v) {
 * the ends out to a widened step can add that one.
 */
 var ticks = (s) => {
-	const count = Math.min(Math.floor(intervalsOf(s) + 1e-9), MOST_INTERVALS + 1);
+	const count = Math.min(Math.floor(intervalsOf(s) + 1e-9), 501);
 	const out = [];
 	for (let i = 0; i <= count; i++) {
 		const sum = s.min + i * s.step;
@@ -181,7 +204,7 @@ var ticks = (s) => {
 * {@link niceScale} pads them, where they did not. A fixed end is exact —
 * nice-rounding it would move a number the author chose.
 *
-* The step is the author's (§21.2.2.98 `c:majorUnit`), else the 1-2-5 step
+* The step is the author's (§21.2.2.103 `c:majorUnit`), else the 1-2-5 step
 * of the span between the ends — with both fixed, of the span they fix:
 * −1E+300…1E+300 runs by 2E+299 in Excel, where padding the ends first
 * stepped it by 5E+299. The automatic ends round out to an author's step
@@ -198,12 +221,14 @@ var ticks = (s) => {
 * @param extentPt   The axis's length — how many ticks fit is a question
 *                   about the plot, not about the numbers.
 * @param horizontal Whether the axis lies along the foot.
+* @param pad        How far past the data the automatic ends reach, as a
+*                   share of its reach ({@link paddedEnds}).
 * @returns The axis min/max and tick step.
 */
-function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false) {
+function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false, pad = .05) {
 	const fixedMin = chart.valAxisMin;
 	const fixedMax = chart.valAxisMax;
-	const padded = paddedEnds(fixedMin ?? dataMin, fixedMax ?? dataMax);
+	const padded = paddedEnds(fixedMin ?? dataMin, fixedMax ?? dataMax, pad);
 	const lo = fixedMin ?? padded.lo;
 	const hi = fixedMax ?? padded.hi;
 	const rounded = (step) => ({
@@ -217,6 +242,43 @@ function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false) {
 	return rounded(Number.isFinite(span) ? span / MOST_INTERVALS : hi / MOST_INTERVALS - lo / MOST_INTERVALS);
 }
 /**
+* §21.2.2.104 — the plot's own rectangle where its author sized it (an
+* `inner` manual layout), in the scene's y-up frame: the axes' labels and
+* titles stand outside it, where the chart sets them.
+*/
+function innerPlot(chart, wPt, hPt) {
+	const box = chart.plotBox;
+	if (!box?.inner) return void 0;
+	return {
+		x0: box.x * wPt,
+		y0: hPt - (box.y + box.h) * hPt,
+		plotW: Math.max(1, box.w * wPt),
+		plotH: Math.max(1, box.h * hPt)
+	};
+}
+/**
+* A scatter axis's {@link Scale}: {@link niceScale}'s where its author fixed
+* nothing, and where they did, their ends exactly and their step, the ends
+* they left to the data rounded out to it — never cut into more than
+* {@link MOST_INTERVALS}, as a frame chart's value axis is not.
+*/
+function scatterScale(lo, hi, maxIntervals, fix) {
+	if (fix.min === void 0 && fix.max === void 0 && fix.unit === void 0) return niceScale(lo, hi, maxIntervals);
+	const auto = niceScale(fix.min ?? lo, fix.max ?? hi, maxIntervals);
+	const step = fix.unit ?? (fix.min !== void 0 && fix.max !== void 0 ? stepFor(fix.min, fix.max, maxIntervals) : auto.step);
+	const scale = {
+		min: fix.min ?? below(auto.min, step),
+		max: fix.max ?? above(auto.max, step),
+		step
+	};
+	if (intervalsOf(scale) <= MOST_INTERVALS) return scale;
+	const span = scale.max - scale.min;
+	return {
+		...scale,
+		step: Number.isFinite(span) ? span / MOST_INTERVALS : scale.max / MOST_INTERVALS - scale.min / MOST_INTERVALS
+	};
+}
+/**
 * The chart title's lines. A title longer than the chart is wide wraps at its
 * spaces, as Excel's and Calc's do, rather than running out past both sides
 * of the frame: dataValidationTableRange.xlsx's "Ranking of Washington
@@ -230,12 +292,13 @@ function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false) {
 */
 function titleLines(chart, wPt, measure) {
 	if (!chart.title) return [];
+	const face = faceOf(chart, "title");
 	const room = wPt * .8;
 	const lines = [];
 	let line = "";
 	for (const word of chart.title.split(/\s+/).filter((w) => w.length > 0)) {
 		const longer = line ? `${line} ${word}` : word;
-		if (line && measure(longer, 13) > room) {
+		if (line && widthIn(measure, longer, face) > room) {
 			lines.push(line);
 			line = word;
 		} else line = longer;
@@ -244,15 +307,15 @@ function titleLines(chart, wPt, measure) {
 	return lines;
 }
 /** The band a title of `lines` takes at the top of the chart. */
-var titleHeight = (lines) => lines.length === 0 ? 0 : 13 * (1.6 + 1.2 * (lines.length - 1));
-function pushChartTitle(labels, lines, wPt, hPt) {
+var titleHeight = (lines, chart) => lines.length === 0 ? 0 : faceOf(chart, "title").sizePt * (1.6 + 1.2 * (lines.length - 1));
+function pushChartTitle(labels, lines, wPt, hPt, chart) {
+	const face = faceOf(chart, "title");
 	lines.forEach((text, i) => {
 		labels.push({
 			text,
 			x: wPt / 2,
-			y: hPt - 4 - 13 * (1 + 1.2 * i),
-			sizePt: 13,
-			colorHex: TITLE_COLOR,
+			y: hPt - 4 - face.sizePt * (1 + 1.2 * i),
+			...face,
 			align: "center"
 		});
 	});
@@ -264,37 +327,37 @@ function buildLegendBlock(chart, wPt, hPt, measure) {
 		...s.line?.none ? { marker: "box" } : isLineLike(s) ? { marker: "line" } : {}
 	}));
 	const marker = chart.type === "line" || chart.type === "scatter" ? "line" : "box";
-	return layoutLegend(legendEntries, chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure, marker);
+	return layoutLegend(legendEntries, chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure, faceOf(chart, "legend"), marker);
 }
-function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid, atEnd = false) {
+function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid, face, atEnd = false, labelled = true) {
+	const rule = grid?.none ? void 0 : {
+		strokeHex: grid?.colorHex ?? GRID_COLOR,
+		widthPt: grid?.widthPt ?? .75
+	};
 	for (const v of tickVals) if (axis === "x") {
 		const gx = at(v);
-		gridlines.push({
+		if (rule) gridlines.push({
 			points: [[gx, y0], [gx, y0 + plotH]],
-			strokeHex: grid?.colorHex ?? GRID_COLOR,
-			widthPt: .75
+			...rule
 		});
-		labels.push({
+		if (labelled) labels.push({
 			text: fmt(v),
 			x: gx,
-			y: atEnd ? y0 + plotH + 9 * .4 : y0 - 9,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			y: atEnd ? y0 + plotH + face.sizePt * .4 : y0 - face.sizePt,
+			...face,
 			align: "center"
 		});
 	} else {
 		const gy = at(v);
-		gridlines.push({
+		if (rule) gridlines.push({
 			points: [[x0, gy], [x0 + plotW, gy]],
-			strokeHex: grid?.colorHex ?? GRID_COLOR,
-			widthPt: .75
+			...rule
 		});
-		labels.push({
+		if (labelled) labels.push({
 			text: fmt(v),
 			x: atEnd ? x0 + plotW + 3 : x0 - 3,
-			y: gy - 9 / 3,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			y: gy - face.sizePt / 3,
+			...face,
 			align: atEnd ? "left" : "right"
 		});
 	}
@@ -318,12 +381,16 @@ function axisStroke(style) {
 * the value axis — `cross.y` up a column chart, `cross.x` along a bar chart —
 * and the other stands at the plot's edge.
 */
-function pushAxisLines(polylines, x0, y0, plotW, plotH, chart, cross = {}) {
+function pushAxisLines(polylines, x0, y0, plotW, plotH, chart, cross = {}, shift = {}) {
+	const up = shift.upright ?? {
+		dx: 0,
+		dy: 0
+	};
 	const val = axisStroke(chart.valAxisLine);
-	const x = x0 + (cross.x ?? 0);
+	const x = x0 + (cross.x ?? 0) + up.dx;
 	const y = y0 + (cross.y ?? 0);
 	if (val) polylines.push({
-		points: [[x, y0], [x, y0 + plotH]],
+		points: [[x, y0 + up.dy], [x, y0 + plotH + up.dy]],
 		strokeHex: val.hex,
 		widthPt: val.widthPt
 	});
@@ -334,6 +401,126 @@ function pushAxisLines(polylines, x0, y0, plotW, plotH, chart, cross = {}) {
 		widthPt: cat.widthPt
 	});
 }
+/**
+* Where a 3-D box's back stands from its front. Each point of depth moves
+* `sin rotY` across and `sin rotX` up — Excel's PDF of its own 3-D columns,
+* at four views and three depths (2026-10-02) — and the box is as deep as a
+* share of one category slot, the slot a share of the front plane the depth
+* leaves: solved for, so box and front fill the plot between them. Never so
+* deep that the front plane is left with no height (or width) across.
+*
+* @returns The offset from the front plane's corner to the back wall's.
+*/
+function boxDepth(d, boxW, boxH, nCats, horizontal) {
+	const k = d.perSlot / Math.max(1, nCats);
+	const along = horizontal ? boxH / (1 + k * Math.abs(d.sinX)) : boxW / (1 + k * Math.abs(d.sinY));
+	const across = Math.abs(horizontal ? d.sinY : d.sinX);
+	const room = (horizontal ? boxW : boxH) * .9;
+	const t = across > 0 ? Math.min(k * along, room / across) : k * along;
+	return {
+		dx: t * d.sinY,
+		dy: t * d.sinX
+	};
+}
+/** The light grey Excel rules a 3-D chart's floor in where it states none. */
+var FLOOR_RULE = {
+	colorHex: GRID_COLOR,
+	widthPt: .75
+};
+/**
+* §21.2.2.69/§21.2.2.11/§21.2.2.191 — a 3-D box's floor, back wall and side
+* wall, as the chart fills and rules them; the floor ruled in light grey
+* unless the chart says otherwise, the walls drawn only as stated. Which wall
+* is which is as Excel's PDF draws them (2026-10-02): columns stand on the
+* bottom, which a view from below does not show, and their side wall is the
+* one the view looks into — the left, turned right; bars stand on the side
+* the view looks into — the left, turned right — and their side wall is the
+* bottom, whatever the view.
+*/
+function pushBoxWalls(walls, chart, f, d, horizontal) {
+	const back = sideOf(f, d, "back");
+	const turnedRight = d.dx >= 0;
+	const floor = horizontal ? sideOf(f, d, turnedRight ? "left" : "right") : d.dy >= 0 ? sideOf(f, d, "bottom") : void 0;
+	const side = horizontal ? sideOf(f, d, "bottom") : sideOf(f, d, turnedRight ? "left" : "right");
+	const surface = (points, fillHex, rule) => {
+		const stroke = rule && !rule.none && rule.colorHex ? rule : void 0;
+		if (!points || !fillHex && !stroke) return;
+		walls.push({
+			points,
+			...fillHex ? { fillHex } : {},
+			...stroke ? {
+				strokeHex: stroke.colorHex,
+				widthPt: stroke.widthPt ?? .75
+			} : {}
+		});
+	};
+	surface(back, chart.backWall?.fillHex, chart.backWall?.line);
+	surface(side, chart.sideWall?.fillHex, chart.sideWall?.line);
+	surface(floor, chart.floor?.fillHex, chart.floor ? chart.floor.line : FLOOR_RULE);
+}
+/** One face of a 3-D box: its back wall, or the wall along one side of its front. */
+function sideOf(f, d, which) {
+	const { x0, y0, plotW, plotH } = f;
+	if (which === "back") return [
+		[x0 + d.dx, y0 + d.dy],
+		[x0 + plotW + d.dx, y0 + d.dy],
+		[x0 + plotW + d.dx, y0 + plotH + d.dy],
+		[x0 + d.dx, y0 + plotH + d.dy]
+	];
+	if (which === "bottom") return [
+		[x0, y0],
+		[x0 + plotW, y0],
+		[x0 + plotW + d.dx, y0 + d.dy],
+		[x0 + d.dx, y0 + d.dy]
+	];
+	const x = which === "left" ? x0 : x0 + plotW;
+	return [
+		[x, y0],
+		[x + d.dx, y0 + d.dy],
+		[x + d.dx, y0 + plotH + d.dy],
+		[x, y0 + plotH]
+	];
+}
+/**
+* A 3-D box's major gridlines: each value's line across the side wall from
+* the front plane and on along the back wall, as Excel rules them — a bar
+* chart's across its bottom whatever the view.
+*
+* @param offsets Each tick's distance along the value axis from its start.
+*/
+function pushBoxGridlines(gridlines, grid, offsets, f, d, horizontal) {
+	if (grid?.none) return;
+	const rule = {
+		strokeHex: grid?.colorHex ?? GRID_COLOR,
+		widthPt: grid?.widthPt ?? .75
+	};
+	const { x0, y0, plotW, plotH } = f;
+	for (const off of offsets) if (horizontal) {
+		const gx = x0 + off;
+		gridlines.push({
+			points: [
+				[gx, y0],
+				[gx + d.dx, y0 + d.dy],
+				[gx + d.dx, y0 + plotH + d.dy]
+			],
+			...rule
+		});
+	} else {
+		const gy = y0 + off;
+		gridlines.push({
+			points: d.dx >= 0 ? [
+				[x0, gy],
+				[x0 + d.dx, gy + d.dy],
+				[x0 + plotW + d.dx, gy + d.dy]
+			] : [
+				[x0 + d.dx, gy + d.dy],
+				[x0 + plotW + d.dx, gy + d.dy],
+				[x0 + plotW, gy]
+			],
+			...rule
+		});
+	}
+}
 function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	const rects = [];
 	const polylines = [];
@@ -347,7 +534,7 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		min: dataMin,
 		max: dataMax,
 		step: niceScale(dataMin, dataMax, intervalsThatFit(horizontal ? wPt : hPt, horizontal)).step
-	} : axisScale(chart, dataMin, dataMax, horizontal ? wPt : hPt, horizontal);
+	} : axisScale(chart, dataMin, dataMax, horizontal ? wPt : hPt, horizontal, opts.unpadded ? 0 : .05);
 	const fmtVal = opts.formatValue ?? formatTick;
 	const tickVals = ticks(scale);
 	const range2 = extentOf(onSecondary.flatMap((s) => s.values.slice(0, nCats)));
@@ -355,36 +542,56 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	const tickVals2 = scale2 ? ticks(scale2) : [];
 	const crosses = chart.catAxisCrosses;
 	const crossValue = Math.min(Math.max(crosses === "min" ? scale.min : crosses === "max" ? scale.max : crosses ?? 0, scale.min), scale.max);
-	const labelsAt = chart.catTickLabelPos === "none" ? "none" : chart.catTickLabelPos === "low" ? "start" : chart.catTickLabelPos === "high" ? "end" : crossValue <= scale.min ? "start" : crossValue >= scale.max ? "end" : "cross";
+	const fromBelow = (opts.depth?.sinX ?? 0) < 0;
+	const labelsAt = chart.catAxisDeleted === true || chart.catTickLabelPos === "none" || fromBelow && !horizontal ? "none" : chart.catTickLabelPos === "low" ? "start" : chart.catTickLabelPos === "high" ? "end" : crossValue <= scale.min ? "start" : crossValue >= scale.max ? "end" : "cross";
 	const catText = (c) => chart.categories[c] ?? String(c + 1);
+	const catFace = faceOf(chart, "catAxis");
+	const valFace = faceOf(chart, "valAxis");
+	const val2Face = faceOf(chart, "secondaryValAxis");
 	let widestCat = 0;
-	for (let c = 0; c < nCats; c++) widestCat = Math.max(widestCat, measure(catText(c), 9));
-	const catBand = 9 * 1.6;
+	for (let c = 0; c < nCats; c++) widestCat = Math.max(widestCat, widthIn(measure, catText(c), catFace));
+	const catBand = catFace.sizePt * 1.6;
 	const groupLevels = horizontal ? [] : chart.categoryGroups ?? [];
 	const valAtEnd = chart.catAxisReversed === true ? chart.valAxisCrosses !== "max" : chart.valAxisCrosses === "max";
+	const valLabelled = chart.valAxisDeleted !== true && !(fromBelow && horizontal);
 	const title = titleLines(chart, wPt, measure);
-	const top = 4 + titleHeight(title) + (!horizontal && labelsAt === "end" ? catBand : 0) + (horizontal && valAtEnd ? catBand : 0);
+	const top = 4 + titleHeight(title, chart) + (!horizontal && labelsAt === "end" ? catBand : 0) + (horizontal && valAtEnd && valLabelled ? catBand : 0);
 	const legend = buildLegendBlock(chart, wPt, hPt, measure);
-	const tick2W = scale2 && !horizontal ? Math.max(0, ...tickVals2.map((v) => measure(formatTick(v), 9))) + 4 + (chart.secondaryValAxisTitle ? 9 * 1.5 : 0) : 0;
-	const tickHalf = (v) => horizontal && v !== void 0 ? measure(fmtVal(v), 9) / 2 : 0;
+	const tick2W = scale2 && !horizontal ? Math.max(0, ...tickVals2.map((v) => widthIn(measure, formatTick(v), val2Face))) + 4 + (chart.secondaryValAxisTitle ? faceOf(chart, "secondaryValAxisTitle").sizePt * 1.5 : 0) : 0;
+	const tickHalf = (v) => horizontal && valLabelled && v !== void 0 ? widthIn(measure, fmtVal(v), valFace) / 2 : 0;
 	const lastTickHalf = tickHalf(tickVals[tickVals.length - 1]);
 	const catLabelW = Math.min(wPt * .4, widestCat + 6);
-	const tickLabelW = Math.max(0, ...tickVals.map((v) => measure(fmtVal(v), 9))) + 4;
+	const tickLabelW = valLabelled ? Math.max(0, ...tickVals.map((v) => widthIn(measure, fmtVal(v), valFace))) + 4 : 0;
 	const plotRight = wPt - 4 - legend.rightWidth - tick2W - (horizontal && labelsAt === "end" ? catLabelW : lastTickHalf) - (!horizontal && valAtEnd ? tickLabelW : 0);
-	const axisTitleBand = 9 * 1.5;
 	const leftTitle = horizontal ? chart.catAxisTitle : chart.valAxisTitle;
 	const footTitle = horizontal ? chart.valAxisTitle : chart.catAxisTitle;
-	const x0 = 4 + (leftTitle ? axisTitleBand : 0) + (horizontal ? labelsAt === "start" ? catLabelW : tickHalf(tickVals[0]) : valAtEnd ? 0 : tickLabelW);
-	const y0 = 4 + legend.bottomHeight + (footTitle ? axisTitleBand : 0) + ((horizontal ? !valAtEnd : labelsAt === "start") ? catBand : 0) + (!horizontal && labelsAt === "start" ? groupLevels.length * catBand : 0);
-	const plotW = Math.max(1, plotRight - x0);
-	const plotH = Math.max(1, hPt - top - y0);
+	const leftTitleFace = faceOf(chart, horizontal ? "catAxisTitle" : "valAxisTitle");
+	const footTitleFace = faceOf(chart, horizontal ? "valAxisTitle" : "catAxisTitle");
+	const own = innerPlot(chart, wPt, hPt);
+	const boxX0 = own?.x0 ?? 4 + (leftTitle ? leftTitleFace.sizePt * 1.5 : 0) + (horizontal ? labelsAt === "start" ? catLabelW : tickHalf(tickVals[0]) : valAtEnd ? 0 : tickLabelW);
+	const boxY0 = own?.y0 ?? 4 + legend.bottomHeight + (footTitle ? footTitleFace.sizePt * 1.5 : 0) + ((horizontal ? !valAtEnd && valLabelled : labelsAt === "start") ? catBand : 0) + (!horizontal && labelsAt === "start" ? groupLevels.length * catBand : 0);
+	const boxW = own?.plotW ?? Math.max(1, plotRight - boxX0);
+	const boxH = own?.plotH ?? Math.max(1, hPt - top - boxY0);
+	const depth = opts.depth ? boxDepth(opts.depth, boxW, boxH, nCats, horizontal) : void 0;
+	const x0 = boxX0 + Math.max(0, -(depth?.dx ?? 0));
+	const y0 = boxY0 + Math.max(0, -(depth?.dy ?? 0));
+	const plotW = Math.max(1, boxW - Math.abs(depth?.dx ?? 0));
+	const plotH = Math.max(1, boxH - Math.abs(depth?.dy ?? 0));
+	const upright = depth && depth.dx < 0 ? depth : {
+		dx: 0,
+		dy: 0
+	};
+	const edge = horizontal ? {
+		dx: 0,
+		dy: 0
+	} : upright;
 	const valueOffset = (v) => fractionOf(v, scale) * (horizontal ? plotW : plotH);
 	const zeroOffset = valueOffset(crossValue);
 	const plotBackground = chart.plotFillHex ?? chart.plotLine?.colorHex ? {
-		x: x0,
-		y: y0,
-		w: plotW,
-		h: plotH,
+		x: boxX0,
+		y: boxY0,
+		w: boxW,
+		h: boxH,
 		...chart.plotFillHex ? { fillHex: chart.plotFillHex } : {},
 		...chart.plotLine?.colorHex ? {
 			strokeHex: chart.plotLine.colorHex,
@@ -392,13 +599,12 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 			...chart.plotLine.dash ? { strokeDash: chart.plotLine.dash } : {}
 		} : {}
 	} : void 0;
-	pushChartTitle(labels, title, wPt, hPt);
+	pushChartTitle(labels, title, wPt, hPt, chart);
 	if (leftTitle) labels.push({
 		text: leftTitle,
-		x: 12.1,
+		x: 4 + leftTitleFace.sizePt * .9,
 		y: y0 + plotH / 2,
-		sizePt: 9,
-		colorHex: LABEL_COLOR,
+		...leftTitleFace,
 		align: "center",
 		rotationDeg: 90
 	});
@@ -406,20 +612,30 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		text: footTitle,
 		x: x0 + plotW / 2,
 		y: legend.bottomHeight + 2,
-		sizePt: 9,
-		colorHex: LABEL_COLOR,
+		...footTitleFace,
 		align: "center"
 	});
-	if (horizontal) pushGridTicks(gridlines, labels, tickVals, fmtVal, "x", (v) => x0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine, valAtEnd);
-	else pushGridTicks(gridlines, labels, tickVals, fmtVal, "y", (v) => y0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine, valAtEnd);
+	const flatGrid = depth ? { none: true } : chart.gridLine;
+	if (horizontal) pushGridTicks(gridlines, labels, tickVals, fmtVal, "x", (v) => x0 + edge.dx + valueOffset(v), x0 + edge.dx, y0 + edge.dy, plotW, plotH, flatGrid, valFace, valAtEnd, valLabelled);
+	else pushGridTicks(gridlines, labels, tickVals, fmtVal, "y", (v) => y0 + edge.dy + valueOffset(v), x0 + edge.dx, y0 + edge.dy, plotW, plotH, flatGrid, valFace, valAtEnd, valLabelled);
+	const walls = [];
+	if (depth) {
+		const front = {
+			x0,
+			y0,
+			plotW,
+			plotH
+		};
+		pushBoxWalls(walls, chart, front, depth, horizontal);
+		pushBoxGridlines(gridlines, chart.gridLine, tickVals.map((v) => valueOffset(v)), front, depth, horizontal);
+	}
 	const valueOffset2 = scale2 && !horizontal ? (v) => fractionOf(v, scale2) * plotH : void 0;
 	if (scale2 && valueOffset2) {
 		for (const v of tickVals2) labels.push({
 			text: formatTick(v),
 			x: x0 + plotW + 3,
-			y: y0 + valueOffset2(v) - 9 / 3,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			y: y0 + valueOffset2(v) - val2Face.sizePt / 3,
+			...val2Face,
 			align: "left"
 		});
 		const sec = axisStroke(chart.secondaryValAxisLine);
@@ -432,42 +648,41 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 			text: chart.secondaryValAxisTitle,
 			x: wPt - 4,
 			y: y0 + plotH / 2,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			...faceOf(chart, "secondaryValAxisTitle"),
 			align: "center",
 			rotationDeg: 90
 		});
 	}
 	const slot = (horizontal ? plotH : plotW) / nCats;
-	const need = horizontal ? 9 * 1.4 : widestCat + 4;
+	const need = horizontal ? catFace.sizePt * 1.4 : widestCat + 4;
 	const step = Math.max(1, Math.ceil(need / Math.max(slot, .01)));
 	const across = labelsAt === "start" ? 0 : labelsAt === "end" ? horizontal ? plotW : plotH : zeroOffset;
 	const labelled = [];
-	if (labelsAt !== "none") if (chart.catAxisReversed === true) for (let c = nCats - 1; c >= 0; c -= step) labelled.push(c);
-	else for (let c = 0; c < nCats; c += step) labelled.push(c);
+	if (labelsAt !== "none") {
+		if (chart.catAxisReversed === true) for (let c = nCats - 1; c >= 0; c -= step) labelled.push(c);
+		else for (let c = 0; c < nCats; c += step) labelled.push(c);
+	}
 	for (const c of labelled) {
 		const cat = catText(c);
 		if (!cat) continue;
 		const center = (horizontal ? y0 : x0) + c * slot + slot / 2;
 		if (horizontal) labels.push({
 			text: cat,
-			x: labelsAt === "end" ? x0 + across + 3 : x0 + across - 3,
-			y: center - 9 / 3,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			x: (labelsAt === "end" ? x0 + across + 3 : x0 + across - 3) + upright.dx,
+			y: center - catFace.sizePt / 3 + upright.dy,
+			...catFace,
 			align: labelsAt === "end" ? "left" : "right"
 		});
 		else labels.push({
 			text: cat,
 			x: center,
-			y: labelsAt === "end" ? y0 + across + 9 * .4 : y0 + across - 9,
-			sizePt: 9,
-			colorHex: LABEL_COLOR,
+			y: labelsAt === "end" ? y0 + across + catFace.sizePt * .4 : y0 + across - catFace.sizePt,
+			...catFace,
 			align: "center"
 		});
 	}
 	if (labelsAt !== "none" && labelsAt !== "end") groupLevels.forEach((groups, level) => {
-		const rowY = y0 + across - 9 - (level + 1) * catBand;
+		const rowY = y0 + across - catFace.sizePt - (level + 1) * catBand;
 		groups.forEach((group, i) => {
 			const end = Math.min(nCats, groups[i + 1]?.start ?? nCats);
 			if (end <= group.start) return;
@@ -475,24 +690,26 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 				text: group.label,
 				x: x0 + (group.start + end) / 2 * slot,
 				y: rowY,
-				sizePt: 9,
-				colorHex: LABEL_COLOR,
+				...catFace,
 				align: "center"
 			});
 			if (i > 0) polylines.push({
-				points: [[x0 + group.start * slot, y0 + across], [x0 + group.start * slot, rowY - 9 * .4]],
+				points: [[x0 + group.start * slot, y0 + across], [x0 + group.start * slot, rowY - catFace.sizePt * .4]],
 				strokeHex: GRID_COLOR,
 				widthPt: .75
 			});
 		});
 	});
-	pushAxisLines(polylines, x0, y0, plotW, plotH, chart, horizontal ? {
+	pushAxisLines(polylines, x0, y0, plotW, plotH, fromBelow ? {
+		...chart,
+		catAxisLine: { none: true }
+	} : chart, horizontal ? {
 		x: zeroOffset,
 		...valAtEnd ? { y: plotH } : {}
 	} : {
 		y: zeroOffset,
 		...valAtEnd ? { x: plotW } : {}
-	});
+	}, { upright });
 	legend.emit(rects, labels);
 	return {
 		x0,
@@ -509,7 +726,11 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		polylines,
 		gridlines,
 		...plotBackground ? { plotBackground } : {},
-		labels
+		labels,
+		...depth ? {
+			depth,
+			walls
+		} : {}
 	};
 }
 var pctLabel = (v) => `${Math.round(v * 100)}%`;
@@ -576,15 +797,72 @@ function groupingFrameOpts(chart, nCats) {
 }
 var CHART_FORMAT_ID = 1e6;
 var formatterCache = /* @__PURE__ */ new WeakMap();
+/**
+* A tick formatter for a number format code — made per scene and not kept: a
+* cache by code would grow with every code every document ever named.
+*/
+function formatterOf(code) {
+	if (code === void 0) return void 0;
+	const formats = /* @__PURE__ */ new Map([[CHART_FORMAT_ID, code]]);
+	return (v) => applyNumberFormat(String(v), CHART_FORMAT_ID, formats);
+}
 function chartValueFormatter(chart) {
 	const hit = formatterCache.get(chart);
 	if (hit !== void 0) return hit ?? void 0;
 	const code = chart.numberFormat;
-	const made = code === void 0 ? null : ((formats) => (v) => applyNumberFormat(String(v), CHART_FORMAT_ID, formats))(new Map([[CHART_FORMAT_ID, code]]));
+	const made = code === void 0 ? null : ((formats) => (v) => applyNumberFormat(String(v), CHART_FORMAT_ID, formats))(/* @__PURE__ */ new Map([[CHART_FORMAT_ID, code]]));
 	formatterCache.set(chart, made);
 	return made ?? void 0;
 }
 /**
+* Whole percentages that add up to a hundred, as Excel labels a pie's slices:
+* each share's floor, and the points still missing given to the slices with
+* the largest remainders — 10, 20 and 15 of 45 read 22%, 45% and 33% in
+* Excel's PDF, where rounding each one reads 22, 44 and 33.
+*
+* @param values The slices' values, a slice that is not positive drawing none.
+* @param total  Their sum.
+* @returns Each slice's whole percentage.
+*/
+function wholePercents(values, total) {
+	const exact = values.map((v) => v > 0 && total > 0 ? v / total * 100 : 0);
+	const out = exact.map((e) => Math.floor(e));
+	let missing = 100 - out.reduce((a, b) => a + b, 0);
+	const byRemainder = exact.map((e, i) => ({
+		i,
+		rest: e - (out[i] ?? 0)
+	})).filter(({ i }) => (values[i] ?? 0) > 0).sort((a, b) => b.rest - a.rest || a.i - b.i);
+	for (const { i } of byRemainder) {
+		if (missing <= 0) break;
+		out[i] = (out[i] ?? 0) + 1;
+		missing--;
+	}
+	return out;
+}
+/**
+* §21.2.2.49 — the text a slice's data label shows: the parts the chart's
+* switches turn on, in Excel's order — series name, category name, value,
+* percentage — joined by its separator, ", " where it states none. The
+* labels' own number format is the value's where the value is shown, and the
+* percentage's where only that is; a percentage is otherwise whole.
+* LIBRE_OFFICE-100610-0.pptx's five pies show the 4, 6, 3 and 6 they ask for,
+* 45540_classic_Footer.xlsx its functions' names over their shares, and a pie
+* whose labels show nothing — or that has none — shows nothing, as Excel's.
+*
+* @returns The label, or undefined when the chart labels nothing.
+*/
+function sliceLabel(chart, series, i, v, total, percent) {
+	const dl = chart.dataLabels;
+	if (!dl) return void 0;
+	const own = formatterOf(dl.numberFormat);
+	const parts = [];
+	if (dl.showSerName) parts.push(series.name ?? legendSeriesName(series, 0));
+	if (dl.showCatName) parts.push(chart.categories[i] ?? String(i + 1));
+	if (dl.showVal) parts.push(own ? own(v) : fmtDataLabel(chart, v));
+	if (dl.showPercent) parts.push(own && !dl.showVal ? own(v / total) : `${String(percent)}%`);
+	return parts.length > 0 ? parts.join(dl.separator ?? ", ") : void 0;
+}
+/**
 * Lay out a bar/column {@link Chart} into a {@link ChartScene}. Honours
 * `chart.grouping` (clustered / stacked / percentStacked) and `chart.barDir`
 * (column vs horizontal bar), over the shared cartesian frame.
@@ -618,13 +896,39 @@ function buildBarScene(chart, wPt, hPt, measure) {
 	const stacked = g === "stacked" || g === "percentStacked";
 	const percent = g === "percentStacked";
 	const horizontal = chart.barDir === "bar";
-	const f = buildFrame(chart, wPt, hPt, measure, horizontal, groupingFrameOpts(chart, catCount(chart)));
+	const nCats = catCount(chart);
 	const barIdx = [];
 	const lineIdx = [];
 	chart.series.forEach((s, i) => (isLineLike(s) ? lineIdx : barIdx).push(i));
+	const nSer = Math.max(1, barIdx.length);
+	const gap = (chart.gapPercent ?? 150) / 100;
+	const overlap = (chart.overlapPercent ?? 0) / 100;
+	const barShare = 1 / (stacked ? 1 + gap : nSer - (nSer - 1) * overlap + gap);
+	const view = chart.bar3D;
+	const sinX = view ? Math.sin(view.rotX * Math.PI / 180) : 0;
+	const sinY = view ? Math.sin(view.rotY * Math.PI / 180) : 0;
+	const seen = view !== void 0 && (Math.abs(sinX) > 1e-9 || Math.abs(sinY) > 1e-9);
+	const f = buildFrame(chart, wPt, hPt, measure, horizontal, {
+		...groupingFrameOpts(chart, nCats),
+		...view ? { unpadded: true } : {},
+		...view && seen ? { depth: {
+			perSlot: barShare * (view.depthPercent / 100) * (1 + view.gapDepth / 100),
+			sinX,
+			sinY
+		} } : {}
+	});
+	const barW = f.slot * barShare;
+	const boxes = [];
+	const put = (rect, lift = [0, 0]) => {
+		if (f.depth) boxes.push({
+			rect,
+			lift
+		});
+		else f.rects.push(rect);
+	};
+	const values = [];
 	if (stacked) {
-		const groupPad = f.slot * .15;
-		const barW = f.slot - 2 * groupPad;
+		const groupPad = (f.slot - barW) / 2;
 		for (let c = 0; c < f.nCats; c++) {
 			const along = (horizontal ? f.y0 : f.x0) + c * f.slot + groupPad;
 			const denom = percent ? barIdx.reduce((a, i) => a + Math.abs(chart.series[i].values[c] ?? 0), 0) || 1 : 1;
@@ -641,7 +945,7 @@ function buildBarScene(chart, wPt, hPt, measure) {
 				const span = Math.abs(o1 - o0);
 				const color = pointColor(series, c) ?? seriesColor(series, s, chart.seriesColorCycle);
 				const outline = barOutline(series);
-				if (horizontal) f.rects.push({
+				if (horizontal) put({
 					x: f.x0 + lo,
 					y: along,
 					w: span,
@@ -649,7 +953,7 @@ function buildBarScene(chart, wPt, hPt, measure) {
 					fillHex: color,
 					...outline
 				});
-				else f.rects.push({
+				else put({
 					x: along,
 					y: f.y0 + lo,
 					w: barW,
@@ -657,90 +961,170 @@ function buildBarScene(chart, wPt, hPt, measure) {
 					fillHex: color,
 					...outline
 				});
-				if (chart.showValues && span > 9) {
+				if (chart.showValues && span > faceOf(chart, "dataLabels").sizePt) {
 					const raw = series.values[c] ?? 0;
-					if (horizontal) f.labels.push(centeredLabel(fmtDataLabel(chart, raw), f.x0 + lo + span / 2, along + barW * .3));
-					else f.labels.push(centeredLabel(fmtDataLabel(chart, raw), along + barW / 2, f.y0 + lo + span / 2 - 3));
+					const face = faceOf(chart, "dataLabels");
+					values.push({
+						label: horizontal ? centeredLabel(fmtDataLabel(chart, raw), f.x0 + lo + span / 2, f.depth ? along + barW / 2 - face.sizePt * .35 : along + barW * .3, face) : centeredLabel(fmtDataLabel(chart, raw), along + barW / 2, f.y0 + lo + span / 2 - 3, face),
+						lift: [0, 0]
+					});
 				}
 				if (v >= 0) cumPos = top;
 				else cumNeg = top;
 			}
 		}
-		pushComboLines(chart, f, lineIdx);
-		return {
-			rects: f.rects,
-			polylines: f.polylines,
-			gridlines: f.gridlines,
-			...f.plotBackground ? { plotBackground: f.plotBackground } : {},
-			...f.plotBackground ? { plotBackground: f.plotBackground } : {},
-			wedges: [],
-			labels: f.labels
-		};
-	}
-	const nSer = Math.max(1, barIdx.length);
-	const gap = (chart.gapPercent ?? 150) / 100;
-	const barW = f.slot / (nSer + gap);
-	const groupPad = (f.slot - barW * nSer) / 2;
-	for (let c = 0; c < f.nCats; c++) {
-		const slotStart = (horizontal ? f.y0 : f.x0) + c * f.slot + groupPad;
-		for (let b = 0; b < barIdx.length; b++) {
-			const s = barIdx[b];
-			const series = chart.series[s];
-			const len = f.valueOffset(series.values[c] ?? 0) - f.zeroOffset;
-			const color = pointColor(series, c) ?? seriesColor(series, s, chart.seriesColorCycle);
-			const along = slotStart + b * barW;
-			const outline = barOutline(series);
-			if (horizontal) {
-				const bx = f.x0 + f.zeroOffset + Math.min(0, len);
-				f.rects.push({
-					x: bx,
+	} else {
+		const pitch = barW * (1 - overlap);
+		const groupPad = (f.slot - barW - (nSer - 1) * pitch) / 2;
+		for (let c = 0; c < f.nCats; c++) {
+			const slotStart = (horizontal ? f.y0 : f.x0) + c * f.slot + groupPad;
+			for (let b = 0; b < barIdx.length; b++) {
+				const s = barIdx[b];
+				const series = chart.series[s];
+				const len = f.valueOffset(series.values[c] ?? 0) - f.zeroOffset;
+				const color = pointColor(series, c) ?? seriesColor(series, s, chart.seriesColorCycle);
+				const along = slotStart + b * pitch;
+				const outline = barOutline(series);
+				if (horizontal) put({
+					x: f.x0 + f.zeroOffset + Math.min(0, len),
 					y: along,
 					w: Math.abs(len),
 					h: barW,
 					fillHex: color,
 					...outline
 				});
-			} else {
-				const by = f.y0 + f.zeroOffset + Math.min(0, len);
-				f.rects.push({
+				else put({
 					x: along,
-					y: by,
+					y: f.y0 + f.zeroOffset + Math.min(0, len),
 					w: barW,
 					h: Math.abs(len),
 					fillHex: color,
 					...outline
 				});
-			}
-			if (chart.showValues) {
-				const txt = fmtDataLabel(chart, series.values[c] ?? 0);
-				if (horizontal) {
-					const end = f.x0 + f.zeroOffset + len;
-					f.labels.push({
-						text: txt,
-						x: end + (len >= 0 ? 3 : -3),
-						y: along + barW * .25,
-						sizePt: 9,
-						colorHex: LABEL_COLOR,
-						align: len >= 0 ? "left" : "right"
-					});
-				} else {
-					const end = f.y0 + f.zeroOffset + len;
-					f.labels.push(centeredLabel(txt, along + barW * .45, len >= 0 ? end + 2 : end - 9));
+				if (chart.showValues) {
+					const txt = fmtDataLabel(chart, series.values[c] ?? 0);
+					const face = faceOf(chart, "dataLabels");
+					if (horizontal) {
+						const end = f.x0 + f.zeroOffset + len;
+						values.push({
+							label: {
+								text: txt,
+								x: end + (len >= 0 ? 3 : -3),
+								y: f.depth ? along + barW / 2 - face.sizePt * .35 : along + barW * .25,
+								...face,
+								align: len >= 0 ? "left" : "right"
+							},
+							lift: [len >= 0 ? .5 : 0, 0]
+						});
+					} else {
+						const end = f.y0 + f.zeroOffset + len;
+						const above = f.depth ? end - face.sizePt * .35 : end + 2;
+						values.push({
+							label: centeredLabel(txt, along + barW * .45, len >= 0 ? above : end - face.sizePt, face),
+							lift: [0, len >= 0 ? 1 : 0]
+						});
+					}
 				}
 			}
 		}
 	}
+	const polygons = [];
+	let shift = {
+		dx: 0,
+		dy: 0
+	};
+	let own = {
+		dx: 0,
+		dy: 0
+	};
+	if (f.depth && view) {
+		const share = 1 / (1 + view.gapDepth / 100);
+		own = {
+			dx: f.depth.dx * share,
+			dy: f.depth.dy * share
+		};
+		const back = view.gapDepth / 200;
+		shift = {
+			dx: own.dx * back,
+			dy: own.dy * back
+		};
+		const across = (r) => horizontal ? r.y + r.h / 2 : r.x + r.w / 2;
+		const up = (r) => horizontal ? r.x + r.w / 2 : r.y + r.h / 2;
+		const first = Math.sign(horizontal ? sinX : sinY) || 1;
+		const then = Math.sign(horizontal ? sinY : sinX) || 1;
+		boxes.sort((a, b) => first * (across(a.rect) - across(b.rect)) || then * (up(a.rect) - up(b.rect)));
+		for (const { rect } of boxes) {
+			const front = {
+				...rect,
+				x: rect.x + shift.dx,
+				y: rect.y + shift.dy
+			};
+			pushBarFaces(polygons, front, own);
+			f.rects.push(front);
+		}
+	}
+	for (const { label, lift } of values) f.labels.push(f.depth ? {
+		...label,
+		x: label.x + shift.dx + lift[0] * own.dx,
+		y: label.y + shift.dy + lift[1] * own.dy
+	} : label);
 	pushComboLines(chart, f, lineIdx);
 	return {
 		rects: f.rects,
 		polylines: f.polylines,
 		gridlines: f.gridlines,
 		...f.plotBackground ? { plotBackground: f.plotBackground } : {},
+		...f.walls && f.walls.length > 0 ? { walls: f.walls } : {},
+		...polygons.length > 0 ? { polygons } : {},
 		wedges: [],
 		labels: f.labels
 	};
 }
 /**
+* The faces of one 3-D bar a viewer sees beside its front: its top when the
+* view looks down on it (its bottom when up at it), its right side when the
+* view is turned to the right (its left when to the left) — each shaded as
+* Excel's own PDF shades them: a top 0.76 of the bar's colour, a right side
+* 0.635, a bottom or a left side 0.4 (2026-10-02).
+*
+* @param r The bar's front.
+* @param d Its depth, as an offset from the front.
+*/
+function pushBarFaces(polygons, r, d) {
+	const fill = r.fillHex ?? "000000";
+	const stroke = r.strokeHex ? {
+		strokeHex: r.strokeHex,
+		widthPt: r.strokeWidthPt ?? .75
+	} : {};
+	const { x, y, w, h } = r;
+	if (d.dy !== 0) {
+		const at = d.dy > 0 ? y + h : y;
+		polygons.push({
+			points: [
+				[x, at],
+				[x + w, at],
+				[x + w + d.dx, at + d.dy],
+				[x + d.dx, at + d.dy]
+			],
+			fillHex: shadeHex(fill, d.dy > 0 ? .76 : .4),
+			...stroke
+		});
+	}
+	if (d.dx !== 0) {
+		const at = d.dx > 0 ? x + w : x;
+		polygons.push({
+			points: [
+				[at, y],
+				[at + d.dx, y + d.dy],
+				[at + d.dx, y + h + d.dy],
+				[at, y + h]
+			],
+			fillHex: shadeHex(fill, d.dx > 0 ? .635 : .4),
+			...stroke
+		});
+	}
+}
+/**
 * The name a series shows in the legend: its own `c:tx`, or Excel's positional
 * `SeriesN` when it has none. Exported because the SUBSET has to know it too —
 * a name invented at draw time is a name no glyph collector ever saw, and
@@ -786,13 +1170,12 @@ function pushComboLines(chart, f, lineIdx) {
 		}
 	}
 }
-function centeredLabel(text, x, y) {
+function centeredLabel(text, x, y, face) {
 	return {
 		text,
 		x,
 		y,
-		sizePt: 9,
-		colorHex: LABEL_COLOR,
+		...face,
 		align: "center"
 	};
 }
@@ -887,22 +1270,53 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 	};
 	const [xLo, xHi] = extentOf(xs) ?? [0, 1];
 	const [yLo, yHi] = extentOf(ys) ?? [0, 1];
-	const xScale = niceScale(xLo, xHi, intervalsThatFit(wPt, true));
-	const yScale = niceScale(yLo, yHi, intervalsThatFit(hPt, false));
+	const xScale = scatterScale(xLo, xHi, intervalsThatFit(wPt, true), {
+		min: chart.xAxisMin,
+		max: chart.xAxisMax,
+		unit: chart.xAxisMajorUnit
+	});
+	const yScale = scatterScale(yLo, yHi, intervalsThatFit(hPt, false), {
+		min: chart.valAxisMin,
+		max: chart.valAxisMax,
+		unit: chart.valAxisMajorUnit
+	});
 	const xTicks = ticks(xScale);
 	const yTicks = ticks(yScale);
+	const fmtX = formatterOf(chart.xNumberFormat) ?? formatTick;
+	const fmtY = formatterOf(chart.numberFormat) ?? formatTick;
 	const title = titleLines(chart, wPt, measure);
-	const top = 4 + titleHeight(title);
+	const top = 4 + titleHeight(title, chart);
 	const legend = buildLegendBlock(chart, wPt, hPt, measure);
-	const x0 = 4 + (Math.max(0, ...yTicks.map((v) => measure(formatTick(v), 9))) + 4);
-	const y0 = 4 + legend.bottomHeight + 9 * 1.6;
-	const plotW = Math.max(1, wPt - 4 - legend.rightWidth - x0);
-	const plotH = Math.max(1, hPt - top - y0);
+	const xFace = faceOf(chart, "catAxis");
+	const yFace = faceOf(chart, "valAxis");
+	const yTitleFace = faceOf(chart, "valAxisTitle");
+	const xTitleFace = faceOf(chart, "catAxisTitle");
+	const tickLabelW = chart.valAxisDeleted === true ? 0 : Math.max(0, ...yTicks.map((v) => widthIn(measure, fmtY(v), yFace))) + 4;
+	const own = innerPlot(chart, wPt, hPt);
+	const x0 = own?.x0 ?? 4 + (chart.valAxisTitle ? yTitleFace.sizePt * 1.5 : 0) + tickLabelW;
+	const y0 = own?.y0 ?? 4 + legend.bottomHeight + (chart.catAxisTitle ? xTitleFace.sizePt * 1.5 : 0) + (chart.catAxisDeleted === true ? 0 : xFace.sizePt * 1.6);
+	const plotW = own?.plotW ?? Math.max(1, wPt - 4 - legend.rightWidth - x0);
+	const plotH = own?.plotH ?? Math.max(1, hPt - top - y0);
 	const xAt = (v) => x0 + fractionOf(v, xScale) * plotW;
 	const yAt = (v) => y0 + fractionOf(v, yScale) * plotH;
-	pushChartTitle(labels, title, wPt, hPt);
-	pushGridTicks(gridlines, labels, yTicks, formatTick, "y", yAt, x0, y0, plotW, plotH, chart.gridLine);
-	pushGridTicks(gridlines, labels, xTicks, formatTick, "x", xAt, x0, y0, plotW, plotH, chart.gridLine);
+	pushChartTitle(labels, title, wPt, hPt, chart);
+	if (chart.valAxisTitle) labels.push({
+		text: chart.valAxisTitle,
+		x: 4 + yTitleFace.sizePt * .9,
+		y: y0 + plotH / 2,
+		...yTitleFace,
+		align: "center",
+		rotationDeg: 90
+	});
+	if (chart.catAxisTitle) labels.push({
+		text: chart.catAxisTitle,
+		x: x0 + plotW / 2,
+		y: legend.bottomHeight + 2,
+		...xTitleFace,
+		align: "center"
+	});
+	pushGridTicks(gridlines, labels, yTicks, fmtY, "y", yAt, x0, y0, plotW, plotH, chart.gridLine, yFace, false, chart.valAxisDeleted !== true);
+	pushGridTicks(gridlines, labels, xTicks, fmtX, "x", xAt, x0, y0, plotW, plotH, chart.xGridLine, xFace, false, chart.catAxisDeleted !== true);
 	pushAxisLines(polylines, x0, y0, plotW, plotH, chart);
 	const style = chart.scatterStyle ?? "marker";
 	const joins = style === "line" || style === "lineMarker" || style.startsWith("smooth");
@@ -1006,7 +1420,7 @@ function buildLineScene(chart, wPt, hPt, measure) {
 			const y = f.y0 + f.valueOffset(series.values[c] ?? 0);
 			pts.push([x, y]);
 			if (chart.lineMarkers) pushMarker(f.rects, wedges, series.marker, x, y, color);
-			if (chart.showValues) f.labels.push(centeredLabel(fmtDataLabel(chart, series.values[c] ?? 0), x, y + 3));
+			if (chart.showValues) f.labels.push(centeredLabel(fmtDataLabel(chart, series.values[c] ?? 0), x, y + 3, faceOf(chart, "dataLabels")));
 		}
 		if (pts.length >= 2) f.polylines.push({
 			points: pts,
@@ -1062,63 +1476,344 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		labels
 	};
 	const title = titleLines(chart, wPt, measure);
-	const top = 4 + titleHeight(title);
+	const top = 4 + titleHeight(title, chart);
 	const legend = layoutLegend(values.map((_, i) => ({
 		name: chart.categories[i] ?? String(i + 1),
 		colorHex: sliceColor(series, i, chart.seriesColorCycle)
-	})), chart.hasLegend, chart.legendPos ?? "r", wPt, hPt, measure);
-	const availW = Math.max(1, wPt - 8 - legend.rightWidth);
-	const availH = Math.max(1, hPt - top - 4 - legend.bottomHeight);
-	const r = Math.max(1, Math.min(availW, availH) / 2 * .95);
-	const cx = 4 + availW / 2;
-	const cy = 4 + legend.bottomHeight + availH / 2;
+	})), chart.hasLegend, chart.legendPos ?? "r", wPt, hPt, measure, faceOf(chart, "legend"));
+	const plotBox = chart.plotBox;
+	const availW = plotBox ? plotBox.w * wPt : Math.max(1, wPt - 8 - legend.rightWidth);
+	const availH = plotBox ? plotBox.h * hPt : Math.max(1, hPt - top - 4 - legend.bottomHeight);
+	const cx = plotBox ? (plotBox.x + plotBox.w / 2) * wPt : 4 + availW / 2;
+	const cy = plotBox ? hPt - (plotBox.y + plotBox.h / 2) * hPt : 4 + legend.bottomHeight + availH / 2;
+	const disc = chart.pie3D;
+	const elevation = disc ? Math.min(90, Math.max(0, disc.rotX)) * Math.PI / 180 : Math.PI / 2;
+	const tilt = Math.max(Math.sin(elevation), .02);
+	const thickF = disc ? .25 * Math.cos(elevation) ** 2 : 0;
+	const explosionOfSlice = (i) => (atPoint(series.pointExplosions, i)?.percent ?? series.explosion ?? 0) / 100;
+	let maxOut = 0;
+	for (let i = 0; i < values.length; i++) if ((values[i] ?? 0) > 0) maxOut = Math.max(maxOut, explosionOfSlice(i));
+	const fullR = Math.max(1, Math.min(availW / 2 / (1 + maxOut), availH / (2 * tilt * (1 + maxOut) + thickF)) * (plotBox ? 1 : .95));
+	const turn = (disc ? disc.rotY : chart.firstSliceAngle ?? 0) * Math.PI / 180;
+	const sweeps = values.map((v) => v > 0 ? -(v / total) * 2 * Math.PI : 0);
+	const starts = [];
+	let ang = Math.PI / 2 - turn;
+	for (const sweep of sweeps) {
+		starts.push(ang);
+		ang += sweep;
+	}
+	const midOf = (i) => (starts[i] ?? 0) + (sweeps[i] ?? 0) / 2;
+	const boxes = pieLabelBoxes(chart, series, values, total, sweeps, starts, fullR, wPt, measure);
+	let room = fullR;
+	for (const b of plotBox ? [] : boxes) {
+		if (b.where !== "out" || b.placement) continue;
+		const c = Math.abs(Math.cos(b.mid));
+		const sn = Math.abs(Math.sin(b.mid)) * tilt;
+		if (c > .05) room = Math.min(room, (availW / 2 - PIE_LABEL_GAP - b.width) / c);
+		if (sn > .05) room = Math.min(room, (availH / 2 - PIE_LABEL_GAP - b.height) / sn);
+	}
+	const discOf = (rr) => {
+		const thickness = thickF * rr;
+		const cyTop = cy + thickness / 2;
+		const centre = (i) => {
+			const out = explosionOfSlice(i) * rr;
+			const mid = midOf(i);
+			return [cx + Math.cos(mid) * out, cyTop + Math.sin(mid) * out * tilt];
+		};
+		const point = (i, t, along) => {
+			const [x0, y0] = centre(i);
+			return [x0 + Math.cos(t) * along, y0 + Math.sin(t) * along * tilt];
+		};
+		return {
+			thickness,
+			cyTop,
+			centre,
+			point
+		};
+	};
+	const positionOf = (box, pieR) => {
+		const rr = box.placement ? fullR : pieR;
+		const d = discOf(rr);
+		const i = box.index;
+		const cos = Math.cos(box.mid);
+		const sin = Math.sin(box.mid);
+		let bx;
+		let by;
+		if (box.where === "out") {
+			const [px, py0] = d.point(i, box.mid, rr + PIE_LABEL_GAP / Math.max(tilt, .2));
+			const py = sin < 0 ? py0 - d.thickness : py0;
+			bx = px + (cos >= 0 ? box.width / 2 : -box.width / 2);
+			by = py + sin * box.height / 2;
+		} else {
+			const depth = chart.doughnut ? (rr * .5 + rr) / 2 : rr * (box.where === "ctr" ? .5 : box.where === "end" ? .75 : .6);
+			[bx, by] = d.point(i, box.mid, depth);
+		}
+		const moved = box.placement;
+		if (moved?.edge) {
+			if (moved.x !== void 0) bx = moved.x * wPt + box.width / 2;
+			if (moved.y !== void 0) by = hPt - moved.y * hPt - box.height / 2;
+		} else if (moved) {
+			bx += (moved.x ?? 0) * wPt;
+			by -= (moved.y ?? 0) * hPt;
+		}
+		return {
+			bx: Math.min(Math.max(bx, box.width / 2 + 2), wPt - box.width / 2 - 2),
+			by: Math.min(Math.max(by, box.height / 2 + 2), hPt - box.height / 2 - 2)
+		};
+	};
+	const across = (x, y, cyTop) => Math.hypot(x - cx, (y - cyTop) / tilt);
+	let r = Math.max(fullR * .4, room);
+	for (const box of plotBox ? [] : boxes) {
+		if (box.where !== "out" || !box.placement) continue;
+		const { bx, by } = positionOf(box, r);
+		const cyTop = discOf(fullR).cyTop;
+		if (across(bx, by, cyTop) < fullR * .9) continue;
+		const nx = Math.min(Math.max(cx, bx - box.width / 2), bx + box.width / 2);
+		const ny = Math.min(Math.max(cyTop, by - box.height / 2), by + box.height / 2);
+		r = Math.max(fullR * .4, Math.min(r, across(nx, ny, cyTop) - PIE_LABEL_GAP / 2));
+	}
+	const d = discOf(r);
 	const holeR = chart.doughnut ? r * .5 : 0;
-	const labelR = chart.doughnut ? (holeR + r) / 2 : r * .6;
-	let ang = Math.PI / 2;
-	for (let i = 0; i < values.length; i++) {
-		const v = values[i];
-		if (v <= 0) continue;
-		const sweep = -(v / total) * 2 * Math.PI;
-		wedges.push({
+	const polygons = [];
+	if (disc) {
+		const sides = [];
+		for (let i = 0; i < values.length; i++) {
+			if ((values[i] ?? 0) <= 0) continue;
+			const fill = shadeHex(sliceColor(series, i, chart.seriesColorCycle), .7);
+			const a0 = starts[i];
+			const a1 = a0 + sweeps[i];
+			for (const [from, to] of frontArcs(a1, a0)) {
+				const topArc = arcPoints(from, to, (t) => d.point(i, t, r));
+				const bottom = topArc.map(([x, y]) => [x, y - d.thickness]).reverse();
+				sides.push({
+					points: [...topArc, ...bottom],
+					fillHex: fill,
+					strokeHex: fill,
+					widthPt: .5,
+					depth: Math.min(...topArc.map(([, y]) => y))
+				});
+			}
+			if (explosionOfSlice(i) > 0) {
+				const [x0, y0] = d.centre(i);
+				for (const t of [a0, a1]) {
+					const [ex, ey] = d.point(i, t, r);
+					sides.push({
+						points: [
+							[x0, y0],
+							[ex, ey],
+							[ex, ey - d.thickness],
+							[x0, y0 - d.thickness]
+						],
+						fillHex: fill,
+						strokeHex: fill,
+						widthPt: .5,
+						depth: Math.min(y0, ey)
+					});
+				}
+			}
+		}
+		sides.sort((a, b) => b.depth - a.depth);
+		for (const { depth: _depth, ...side } of sides) polygons.push(side);
+		for (let i = 0; i < values.length; i++) {
+			if ((values[i] ?? 0) <= 0) continue;
+			const a0 = starts[i];
+			polygons.push({
+				points: [d.centre(i), ...arcPoints(a0, a0 + sweeps[i], (t) => d.point(i, t, r))],
+				fillHex: sliceColor(series, i, chart.seriesColorCycle),
+				strokeHex: "FFFFFF",
+				widthPt: .75
+			});
+		}
+	} else {
+		for (let i = 0; i < values.length; i++) {
+			if ((values[i] ?? 0) <= 0) continue;
+			const [x0, y0] = d.centre(i);
+			wedges.push({
+				cx: x0,
+				cy: y0,
+				r,
+				startRad: starts[i],
+				sweepRad: sweeps[i],
+				fillHex: sliceColor(series, i, chart.seriesColorCycle),
+				strokeHex: "FFFFFF"
+			});
+		}
+		if (holeR > 0) wedges.push({
 			cx,
 			cy,
-			r,
-			startRad: ang,
-			sweepRad: sweep,
-			fillHex: sliceColor(series, i, chart.seriesColorCycle),
-			strokeHex: "FFFFFF"
+			r: holeR,
+			startRad: 0,
+			sweepRad: -2 * Math.PI,
+			fillHex: "FFFFFF"
 		});
-		const mid = ang + sweep / 2;
-		const pct = Math.round(v / total * 100);
-		const own = chart.showValues ? fmtDataLabel(chart, v) : `${pct}%`;
-		const custom = atPoint(series.pointLabels, i)?.text;
-		if (custom !== void 0 || chart.showValues || pct >= 5) labels.push({
-			text: custom ?? own,
-			x: cx + Math.cos(mid) * labelR,
-			y: cy + Math.sin(mid) * labelR - 9 / 3,
-			sizePt: 9,
-			colorHex: custom !== void 0 || chart.doughnut ? LABEL_COLOR : "FFFFFF",
-			align: "center"
+	}
+	const polylines = [];
+	const face = faceOf(chart, "dataLabels");
+	const lineH = face.sizePt * 1.2;
+	const placed = boxes.map((box) => ({
+		box,
+		...positionOf(box, r)
+	}));
+	const outside = placed.filter((p) => p.box.where === "out" || across(p.bx, p.by, d.cyTop) >= r).sort((a, b) => b.by - a.by);
+	const overlaps = (a, b) => Math.abs(a.bx - b.bx) < (a.box.width + b.box.width) / 2 && Math.abs(a.by - b.by) < (a.box.height + b.box.height) / 2 + 2;
+	const fixed = outside.filter((p) => p.box.placement);
+	const chartSet = outside.filter((p) => !p.box.placement);
+	if (fixed.length + chartSet.length <= MOST_SPREAD_LABELS) {
+		chartSet.forEach((here, k) => {
+			const blocks = (other) => overlaps(other, here);
+			for (let pass = 0; pass <= fixed.length + k; pass++) {
+				const hit = fixed.find(blocks) ?? chartSet.slice(0, k).find(blocks);
+				if (!hit) break;
+				here.by = hit.by - (hit.box.height + here.box.height) / 2 - 2;
+			}
 		});
-		ang += sweep;
+		const lowest = chartSet.reduce((low, p) => low === void 0 || p.by < low.by ? p : low, void 0);
+		const under = lowest ? 2 - (lowest.by - lowest.box.height / 2) : 0;
+		if (under > 0) for (const p of chartSet) p.by += under;
 	}
-	if (holeR > 0) wedges.push({
-		cx,
-		cy,
-		r: holeR,
-		startRad: 0,
-		sweepRad: -2 * Math.PI,
-		fillHex: "FFFFFF"
-	});
-	pushChartTitle(labels, title, wPt, hPt);
+	for (const { box, bx, by } of placed) {
+		const moved = box.placement;
+		if ((box.where === "out" || moved !== void 0) && across(bx, by, d.cyTop) >= r && chart.dataLabels?.showLeaderLines) {
+			const [ex, ey] = d.point(box.index, box.mid, r);
+			const tx = Math.min(Math.max(ex, bx - box.width / 2), bx + box.width / 2);
+			const ty = Math.min(Math.max(ey, by - box.height / 2), by + box.height / 2);
+			if (Math.hypot(tx - ex, ty - ey) > 3) polylines.push({
+				points: [[ex, ey], [tx, ty]],
+				strokeHex: LABEL_COLOR,
+				widthPt: .75
+			});
+		}
+		const colorHex = box.where === "out" || moved !== void 0 || box.custom || chart.doughnut || chart.text?.dataLabels?.colorHex ? face.colorHex : "FFFFFF";
+		box.lines.forEach((line, k) => {
+			labels.push({
+				text: line,
+				x: bx,
+				y: by - face.sizePt / 3 + ((box.lines.length - 1) / 2 - k) * lineH,
+				...face,
+				colorHex,
+				align: "center"
+			});
+		});
+	}
+	pushChartTitle(labels, title, wPt, hPt, chart);
 	legend.emit(rects, labels);
 	return {
 		rects,
-		polylines: [],
+		polylines,
 		wedges,
-		labels
+		labels,
+		...polygons.length > 0 ? { polygons } : {}
 	};
 }
+/**
+* The parts of an arc from `from` to `to` (radians, `from` < `to`) that lie
+* on the disc's front half — below its centre in the y-up frame, where sin
+* is negative — each as a [from, to] pair.
+*/
+function frontArcs(from, to) {
+	const out = [];
+	const TAU = 2 * Math.PI;
+	const k0 = Math.floor((from - Math.PI) / TAU) - 1;
+	const k1 = Math.ceil((to - Math.PI) / TAU) + 1;
+	for (let k = k0; k <= k1; k++) {
+		const lo = Math.max(from, Math.PI + k * TAU);
+		const hi = Math.min(to, TAU + k * TAU);
+		if (hi - lo > 1e-6) out.push([lo, hi]);
+	}
+	return out;
+}
+/** Points along an arc from `a0` by its sweep to `a1`, one every 3.75°. */
+function arcPoints(a0, a1, at) {
+	const n = Math.max(2, Math.ceil(Math.abs(a1 - a0) / (Math.PI / 48)));
+	const out = [];
+	for (let k = 0; k <= n; k++) out.push(at(a0 + (a1 - a0) * k / n));
+	return out;
+}
+/** `hex` with each channel scaled by `f` — a darker shade of it below 1. */
+function shadeHex(hex, f) {
+	const n = parseInt(hex, 16);
+	const ch = (shift) => Math.max(0, Math.min(255, Math.round((n >> shift & 255) * f))).toString(16).padStart(2, "0");
+	return `${ch(16)}${ch(8)}${ch(0)}`.toUpperCase();
+}
+/** The room kept between a pie and a label set outside it. */
+var PIE_LABEL_GAP = 6;
+/** The most labels round a pie that are spread apart (see buildPieScene). */
+var MOST_SPREAD_LABELS = 64;
+/**
+* §21.2.2.48 — each slice's label, measured and placed: inside where the
+* position asks for it, outside for `outEnd`, and for `bestFit`, Excel's
+* default, inside where it fits across the slice and outside where it does
+* not — wrapped at its spaces to under a third of the chart's width, as
+* 45544.xlsx's function names stand beside their slices.
+*/
+function pieLabelBoxes(chart, series, values, total, sweeps, starts, fullR, wPt, measure) {
+	const face = faceOf(chart, "dataLabels");
+	const lineH = face.sizePt * 1.2;
+	const percents = wholePercents(values, total);
+	const widest = (lines) => lines.reduce((m, l) => Math.max(m, widthIn(measure, l, face)), 0);
+	const out = [];
+	for (let i = 0; i < values.length; i++) {
+		const v = values[i] ?? 0;
+		if (v <= 0) continue;
+		const custom = atPoint(series.pointLabels, i)?.text;
+		const text = custom ?? sliceLabel(chart, series, i, v, total, percents[i] ?? 0);
+		if (text === void 0 || text.length === 0) continue;
+		const placement = atPoint(series.pointLabelPlacements, i);
+		const position = placement?.position ?? chart.dataLabels?.position ?? "bestFit";
+		const sweep = Math.abs(sweeps[i] ?? 0);
+		const mid = (starts[i] ?? 0) - sweep / 2;
+		let lines = text.split("\n");
+		let width = widest(lines);
+		const across = sweep >= Math.PI ? fullR * 1.6 : 2 * fullR * .6 * Math.sin(Math.min(sweep, Math.PI) / 2);
+		let fits = width + 4 <= across && lines.length * lineH <= fullR * .7;
+		const dragged = placement !== void 0 && !placement.edge && (placement.x !== void 0 || placement.y !== void 0);
+		if (!fits && position === "bestFit" && !dragged) {
+			const wrapped = lines.flatMap((line) => wrapAtSpaces(line, Math.min(across * .9, wPt * .3), (t) => widthIn(measure, t, face)));
+			const wrappedWidth = widest(wrapped);
+			if (wrappedWidth + 4 <= across && wrapped.length * lineH <= fullR * .7) {
+				lines = wrapped;
+				width = wrappedWidth;
+				fits = true;
+			}
+		}
+		const where = chart.doughnut ? "in" : position === "outEnd" || position === "bestFit" && !fits ? "out" : position === "ctr" || position === "inBase" ? "ctr" : position === "inEnd" ? "end" : "in";
+		if (where === "out") {
+			const room = Math.max(40, wPt * .3);
+			lines = lines.flatMap((line) => wrapAtSpaces(line, room, (t) => widthIn(measure, t, face)));
+			width = widest(lines);
+		}
+		out.push({
+			index: i,
+			mid,
+			lines,
+			width,
+			height: lines.length * lineH,
+			where,
+			...placement && (placement.x !== void 0 || placement.y !== void 0) ? { placement: {
+				...placement.x !== void 0 ? { x: placement.x } : {},
+				...placement.y !== void 0 ? { y: placement.y } : {},
+				...placement.edge ? { edge: true } : {}
+			} } : {},
+			custom: custom !== void 0
+		});
+	}
+	return out;
+}
+/** A line broken at its spaces into lines no wider than `room` where a break allows. */
+function wrapAtSpaces(line, room, width) {
+	const words = line.split(" ");
+	const out = [];
+	let cur = "";
+	for (const word of words) {
+		const longer = cur ? `${cur} ${word}` : word;
+		if (cur && width(longer) > room) {
+			out.push(cur);
+			cur = word;
+		} else cur = longer;
+	}
+	out.push(cur);
+	return out;
+}
 function pointColor(series, idx) {
 	return atPoint(series.pointColors, idx)?.colorHex;
 }
@@ -1140,13 +1835,13 @@ function atPoint(overrides, idx) {
 	}
 	return byPoint.get(idx);
 }
-function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box") {
+function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, face, marker = "box") {
 	if (!hasLegend || entries.length === 0) return {
 		rightWidth: 0,
 		bottomHeight: 0,
 		emit: () => {}
 	};
-	const sw = 9;
+	const sw = face.sizePt;
 	const gap = 4;
 	const keyW = sw * 2.2;
 	const keyH = sw * .55;
@@ -1163,7 +1858,7 @@ function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box"
 		h: keyH,
 		fillHex: e.colorHex
 	};
-	const entryW = (e) => keyW + 3 + measure(e.name, 9) + gap * 2;
+	const entryW = (e) => keyW + 3 + widthIn(measure, e.name, face) + 8;
 	if (pos === "r" || pos === "l") {
 		const colW = entries.reduce((w, e) => Math.max(w, entryW(e)), 0);
 		return {
@@ -1178,8 +1873,7 @@ function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box"
 						text: e.name,
 						x: lx + keyW + 3,
 						y: ly + 1,
-						sizePt: 9,
-						colorHex: LABEL_COLOR,
+						...face,
 						align: "left"
 					});
 					ly -= sw + 4;
@@ -1199,9 +1893,8 @@ function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box"
 				labels.push({
 					text: e.name,
 					x: lx + keyW + 3,
-					y: ly + 1,
-					sizePt: 9,
-					colorHex: LABEL_COLOR,
+					y: 3,
+					...face,
 					align: "left"
 				});
 				lx += entryW(e);
@@ -1251,6 +1944,10 @@ function withReversedCategories(chart) {
 			...s.pointLabels ? { pointLabels: s.pointLabels.map((p) => ({
 				...p,
 				idx: flip(p.idx)
+			})) } : {},
+			...s.pointLabelPlacements ? { pointLabelPlacements: s.pointLabelPlacements.map((p) => ({
+				...p,
+				idx: flip(p.idx)
 			})) } : {}
 		}))
 	};
@@ -1294,4 +1991,4 @@ function withFrame(scene, chart, wPt, hPt) {
 	};
 }
 //#endregion
-export { buildChartScene, legendSeriesName };
+export { SERIES_COLORS, buildAreaScene, buildBarScene, buildChartScene, buildLineScene, buildPieScene, buildScatterScene, formatTick, legendSeriesName, niceScale, seriesColor };