reamkit 1.32.0 → 1.33.0

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

@@ -1,8 +1,26 @@
-import { applyNumberFormat } from "../number-format.js";
+import { applyNumberFormat, generalRenderings } from "../number-format.js";
 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",
@@ -25,22 +43,25 @@ var SERIES_COLORS = [
 var seriesColor = (s, i, cycle) => s.colorHex ?? (cycle && cycle.length > 0 ? cycle[i % cycle.length] : SERIES_COLORS[i % SERIES_COLORS.length]);
 /**
 * The scale Excel gives a value axis it is left to choose, measured against
-* Excel's own PDF of eight column charts (2026-10-01):
+* Excel's own PDF of its column charts (2026-10-01 and -02):
 *
 *  - the ends: values all of one sign put the axis's near end at zero —
 *    unless their spread is under a sixth of the largest of them, when it
 *    stops half a spread short of the nearest (93…97 runs from 91) — and the
-*    far end, like both ends of a range across zero, takes 5% of the spread
-*    beyond the data before it is rounded out to the step;
+*    far end takes 5% of its reach from that near end before it is rounded
+*    out to the step. 70…96 reaches 100.8 and runs 0…120 by 20, where 5% of
+*    the data's own spread stopped at 97.3 and ran it 0…100 by 10. Both ends
+*    of a range across zero take 5% of the spread;
 *  - the step: the smallest 1, 2 or 5 × 10ⁿ that leaves at most ten intervals
 *    (`maxIntervals`), whatever the chart's height — 3 750 runs 0…4 000 by 500
 *    on a 150pt chart as on a 400pt one. Only an axis too short to hold the
 *    labels asks for fewer, and the caller says so.
 *
-* Every case of the probe lands where Excel puts it: −1…1.2 on −1.5…1.5 by
+* Every case of the probes lands where Excel puts it: −1…1.2 on −1.5…1.5 by
 * 0.5, 0.3…4.7 on 0…5 by 0.5, 120…950 on 0…1 000 by 100, 0.012…0.047 on
-* 0…0.05 by 0.005. Heckbert's nice numbers with a budget of ticks by height
-* stepped the budget chart by 1 000 and started 93…97 at zero.
+* 0…0.05 by 0.005, 1E-150…3E-150 on 0…3.5E-150. Heckbert's nice numbers with
+* a budget of ticks by height stepped the budget chart by 1 000 and started
+* 93…97 at zero.
 *
 * @param dataMin      The smallest value to cover.
 * @param dataMax      The largest value to cover.
@@ -48,78 +69,214 @@ var seriesColor = (s, i, cycle) => s.colorHex ?? (cycle && cycle.length > 0 ? cy
 * @returns The rounded min/max and tick step.
 */
 function niceScale(dataMin, dataMax, maxIntervals = 10) {
+	const end = paddedEnds(dataMin, dataMax);
+	const step = stepFor(end.lo, end.hi, maxIntervals);
+	return {
+		min: below(end.lo, step),
+		max: above(end.hi, step),
+		step
+	};
+}
+/**
+* The ends {@link niceScale} rounds out to its step: the data's, padded as
+* 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, 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;
-	const end = {
-		lo: lo - spread * .05,
-		hi: hi + spread * .05
-	};
-	if (lo >= 0) end.lo = spread < hi / 6 ? lo - spread / 2 : 0;
-	else if (hi <= 0) end.hi = spread < -lo / 6 ? hi + spread / 2 : 0;
-	const step = stepFor(end.hi - end.lo, maxIntervals);
+	if (lo >= 0) {
+		const from = spread < hi / 6 ? lo - spread / 2 : 0;
+		return {
+			lo: from,
+			hi: finite(hi + (hi - from) * pad)
+		};
+	}
+	if (hi <= 0) {
+		const to = spread < -lo / 6 ? hi + spread / 2 : 0;
+		return {
+			lo: finite(lo - (to - lo) * pad),
+			hi: to
+		};
+	}
 	return {
-		min: Math.floor(end.lo / step + 1e-9) * step,
-		max: Math.ceil(end.hi / step - 1e-9) * step,
-		step
+		lo: finite(lo - spread * pad),
+		hi: finite(hi + spread * pad)
 	};
 }
-/** The smallest 1, 2 or 5 × 10ⁿ that cuts `span` into at most `maxIntervals` steps. */
-function stepFor(span, maxIntervals) {
+/** `v`, or the largest double of its sign where it ran past it. */
+var finite = (v) => Math.min(Number.MAX_VALUE, Math.max(-Number.MAX_VALUE, v));
+/** `v` rounded down to a multiple of `step`, short of the largest double. */
+var below = (v, step) => finite(Math.floor(v / step + 1e-9) * step);
+/** `v` rounded up to a multiple of `step`, short of the largest double. */
+var above = (v, step) => finite(Math.ceil(v / step - 1e-9) * step);
+/**
+* The smallest 1, 2 or 5 × 10ⁿ that cuts `lo`…`hi` into at most
+* `maxIntervals` steps. The share of the span each interval takes is reckoned
+* so that a span past the largest double has one: −1.7E+308…1.7E+308 spans
+* Infinity, and the search for its step never ended.
+*/
+function stepFor(lo, hi, maxIntervals) {
 	const most = Math.max(1, maxIntervals);
-	let base = 10 ** Math.floor(Math.log10(span / most));
+	const span = hi - lo;
+	const share = Math.abs(Number.isFinite(span) ? span / most : hi / most - lo / most);
+	if (!(share > 0 && share < Infinity)) return 1;
+	let base = Math.max(Number.MIN_VALUE, 10 ** Math.floor(Math.log10(share)));
 	for (;;) {
 		for (const m of [
 			1,
 			2,
 			5
-		]) if (span / (m * base) <= most + 1e-9) return m * base;
+		]) if (share <= m * base * (1 + 1e-9)) return Math.min(m * base, Number.MAX_VALUE);
 		base *= 10;
 	}
 }
+/** How many steps lie between a scale's ends — in halves where the span overflows. */
+function intervalsOf(s) {
+	const span = s.max - s.min;
+	return Number.isFinite(span) ? span / s.step : (s.max / 2 - s.min / 2) / (s.step / 2);
+}
+/**
+* How far along `s` the value `v` stands: 0 at its min, 1 at its max —
+* reckoned in halves where a difference overflows, as it does between ends
+* out at ±1.7E+308.
+*/
+function fractionOf(v, s) {
+	const span = s.max - s.min;
+	const from = v - s.min;
+	return Number.isFinite(span) && Number.isFinite(from) ? from / span : (v / 2 - s.min / 2) / (s.max / 2 - s.min / 2);
+}
 /**
-* Format an axis tick value, choosing decimal places from the tick `step` so
-* `0.25`-spaced ticks read `0.25` while integer steps drop the fraction.
+* The most intervals Excel cuts a value axis into. A finer step than that is
+* widened to a 500th of the axis: its own PDF ran 0…26.25 by 0.0525 for steps
+* of 0.05, 0.01 and 0.001 alike, and kept 0.0525 itself (2026-10-02).
+*/
+var MOST_INTERVALS = 500;
+/** The most characters Excel gives a value-axis label under General, its sign among them. */
+var AXIS_LABEL_CHARS = 9;
+/**
+* A value-axis tick as Excel labels it under General. An axis is not a cell:
+* its General gives every label nine characters, the sign among them, on an
+* axis 150pt or 500pt long, upright or lying alike — Excel's own PDF of 44
+* axes (2026-10-01 and -02). Within them it is the cells' rule
+* ({@link generalRenderings}): the number as it is where it fits (0.25 — we
+* wrote 0.3 on an axis stepped by 0.25 — 500000000, −50000000, 0.0000003),
+* else the finest of it rounded or in scientific notation (0.1234568,
+* −0.123457, 123456771, 1E+09, 1.235E+09, −1.23E+09, 1.235E-05, 5E-151).
+* Places counted from the step and written by `toFixed` threw past a hundred
+* of them, which a step of 1E-150 asked for.
 *
-* @param v    The tick value.
-* @param step The tick spacing (from {@link niceScale}).
+* @param v The tick value.
 * @returns The label text.
 */
-function formatTick(v, step) {
-	if (Number.isInteger(step) && Number.isInteger(v)) return String(v);
-	const decimals = Math.max(0, -Math.floor(Math.log10(step)));
-	const fixed = v.toFixed(decimals);
-	return fixed.includes(".") ? fixed.replace(/0+$/, "").replace(/\.$/, "") : fixed;
+function formatTick(v) {
+	return generalRenderings(v, AXIS_LABEL_CHARS, true).next().value ?? String(v);
 }
+/**
+* The values a scale labels: its min and every step up to its max. Counted,
+* not summed: the sum drifted, and its tolerance was absolute, so a scale of
+* 1E-150 ran on until it passed 1E-9 and asked for more ticks than an array
+* holds. Never more than Excel's most intervals and one past them — rounding
+* the ends out to a widened step can add that one.
+*/
 var ticks = (s) => {
+	const count = Math.min(Math.floor(intervalsOf(s) + 1e-9), 501);
 	const out = [];
-	for (let v = s.min; v <= s.max + 1e-9; v += s.step) out.push(Math.abs(v) < 1e-9 ? 0 : v);
+	for (let i = 0; i <= count; i++) {
+		const sum = s.min + i * s.step;
+		const v = Number.isFinite(sum) ? sum : 2 * (s.min / 2 + i * (s.step / 2));
+		out.push(Math.abs(v) < s.step * 1e-9 ? 0 : v);
+	}
 	return out;
 };
 /**
 * The value axis's {@link Scale}: the ends the author fixed where they fixed
-* them (§21.2.2.157 `c:scaling/c:min|c:max`), the data's own range where they
-* did not. A fixed end is exact — nice-rounding it would move a number the
-* author chose — so only the tick step comes from the rounding pass.
+* them (§21.2.2.157 `c:scaling/c:min|c:max`), the data's, padded as
+* {@link niceScale} pads them, where they did not. A fixed end is exact —
+* nice-rounding it would move a number the author chose.
 *
-* @param chart   The chart (for its fixed ends).
-* @param dataMin The smallest value to cover.
-* @param dataMax The largest value to cover.
-* @param hPt     The chart's height — how many ticks fit is a question about
-*                the plot, not about the numbers.
+* 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
+* from where the padding left them, not from where a step of our own would
+* have: 10…25 by 0.1 runs 0…26.3, as in Excel, not 0…30. And no step cuts
+* the axis finer than {@link MOST_INTERVALS}: Excel widens one that would to
+* a 500th of the span and rounds the automatic ends out to the widened step
+* (−10…25 by 0.01 runs −11.781…26.796 by 0.077). A step of 0.00001 asked for
+* three million labels and ran out of stack.
+*
+* @param chart      The chart (for its fixed ends and step).
+* @param dataMin    The smallest value to cover.
+* @param dataMax    The largest value to cover.
+* @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) {
-	const rounded = niceScale(chart.valAxisMin ?? dataMin, chart.valAxisMax ?? dataMax, intervalsThatFit(extentPt, horizontal));
-	const step = chart.valAxisMajorUnit ?? rounded.step;
+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, pad);
+	const lo = fixedMin ?? padded.lo;
+	const hi = fixedMax ?? padded.hi;
+	const rounded = (step) => ({
+		min: fixedMin ?? below(lo, step),
+		max: fixedMax ?? above(hi, step),
+		step
+	});
+	const scale = rounded(chart.valAxisMajorUnit ?? stepFor(lo, hi, intervalsThatFit(extentPt, horizontal)));
+	if (intervalsOf(scale) <= MOST_INTERVALS) return scale;
+	const span = hi - lo;
+	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 {
-		min: chart.valAxisMin ?? (step === rounded.step ? rounded.min : Math.floor(rounded.min / step) * step),
-		max: chart.valAxisMax ?? (step === rounded.step ? rounded.max : Math.ceil(rounded.max / step) * step),
+		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
@@ -135,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;
@@ -149,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"
 		});
 	});
@@ -169,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"
 		});
 	}
@@ -223,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
 	});
@@ -239,56 +401,197 @@ 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 = [];
 	const gridlines = [];
 	const labels = [];
-	const nCats = Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
+	const nCats = catCount(chart);
 	const onSecondary = chart.series.filter((s) => s.secondaryAxis);
 	const allVals = (onSecondary.length > 0 ? chart.series.filter((s) => !s.secondaryAxis) : chart.series).flatMap((s) => s.values.slice(0, nCats));
-	const [dataMin, dataMax] = opts.dataRange ?? (allVals.length > 0 ? [Math.min(...allVals), Math.max(...allVals)] : [0, 1]);
+	const [dataMin, dataMax] = opts.dataRange ?? extentOf(allVals) ?? [0, 1];
 	const scale = opts.exactRange ? {
 		min: dataMin,
 		max: dataMax,
 		step: niceScale(dataMin, dataMax, intervalsThatFit(horizontal ? wPt : hPt, horizontal)).step
-	} : axisScale(chart, dataMin, dataMax, horizontal ? wPt : hPt, horizontal);
-	const fmtVal = opts.formatValue ?? ((v) => formatTick(v, scale.step));
+	} : axisScale(chart, dataMin, dataMax, horizontal ? wPt : hPt, horizontal, opts.unpadded ? 0 : .05);
+	const fmtVal = opts.formatValue ?? formatTick;
 	const tickVals = ticks(scale);
-	const vals2 = onSecondary.flatMap((s) => s.values.slice(0, nCats));
-	const scale2 = vals2.length > 0 ? niceScale(Math.min(...vals2), Math.max(...vals2), intervalsThatFit(hPt, false)) : void 0;
+	const range2 = extentOf(onSecondary.flatMap((s) => s.values.slice(0, nCats)));
+	const scale2 = range2 ? niceScale(range2[0], range2[1], intervalsThatFit(hPt, false)) : void 0;
 	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 widestCat = Math.max(0, ...Array.from({ length: nCats }, (_, c) => measure(catText(c), 9)));
-	const catBand = 9 * 1.6;
+	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, 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, scale2.step), 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 valueOffset = (v) => (v - scale.min) / (scale.max - scale.min) * (horizontal ? plotW : plotH);
+	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,
@@ -296,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
 	});
@@ -310,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 valueOffset2 = scale2 && !horizontal ? (v) => (v - scale2.min) / (scale2.max - scale2.min) * plotH : void 0;
+	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, scale2.step),
+			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);
@@ -336,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;
@@ -379,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,
@@ -413,13 +726,38 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		polylines,
 		gridlines,
 		...plotBackground ? { plotBackground } : {},
-		labels
+		labels,
+		...depth ? {
+			depth,
+			walls
+		} : {}
 	};
 }
 var pctLabel = (v) => `${Math.round(v * 100)}%`;
 var fmtDataLabel = (chart, v) => chartValueFormatter(chart)?.(v) ?? (Number.isInteger(v) ? String(v) : String(Math.round(v * 100) / 100));
+/**
+* How many category slots a chart has: its labels, or its longest series —
+* counted in a loop, as spreading a file's series into one call overflows
+* the stack.
+*/
 function catCount(chart) {
-	return Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
+	let n = Math.max(chart.categories.length, 1);
+	for (const s of chart.series) n = Math.max(n, s.values.length);
+	return n;
+}
+/**
+* The least and the greatest of `values`, or undefined where none is a
+* number. Read in a loop: `Math.min(...values)` throws on a series of 200 000
+* points, as a call takes no more arguments than the stack holds.
+*/
+function extentOf(values) {
+	let lo = Infinity;
+	let hi = -Infinity;
+	for (const v of values) {
+		if (v < lo) lo = v;
+		if (v > hi) hi = v;
+	}
+	return lo <= hi ? [lo, hi] : void 0;
 }
 function stackedTotals(chart, nCats) {
 	let max = 0;
@@ -459,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.
@@ -501,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;
@@ -524,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,
@@ -532,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,
@@ -540,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
@@ -669,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"
 	};
 }
@@ -768,22 +1268,55 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 		wedges: [],
 		labels
 	};
-	const xScale = niceScale(Math.min(...xs), Math.max(...xs), intervalsThatFit(wPt, true));
-	const yScale = niceScale(Math.min(...ys), Math.max(...ys), intervalsThatFit(hPt, false));
+	const [xLo, xHi] = extentOf(xs) ?? [0, 1];
+	const [yLo, yHi] = extentOf(ys) ?? [0, 1];
+	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, yScale.step), 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 xAt = (v) => x0 + (v - xScale.min) / (xScale.max - xScale.min) * plotW;
-	const yAt = (v) => y0 + (v - yScale.min) / (yScale.max - yScale.min) * plotH;
-	pushChartTitle(labels, title, wPt, hPt);
-	pushGridTicks(gridlines, labels, yTicks, (v) => formatTick(v, yScale.step), "y", yAt, x0, y0, plotW, plotH, chart.gridLine);
-	pushGridTicks(gridlines, labels, xTicks, (v) => formatTick(v, xScale.step), "x", xAt, x0, y0, plotW, plotH, chart.gridLine);
+	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, 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");
@@ -871,8 +1404,7 @@ function pushMarker(rects, wedges, marker, x, y, color) {
 * @returns The positioned scene primitives.
 */
 function buildLineScene(chart, wPt, hPt, measure) {
-	const allVals = chart.series.flatMap((s) => s.values);
-	const range = [allVals.length > 0 ? Math.min(...allVals) : 0, allVals.length > 0 ? Math.max(...allVals) : 1];
+	const range = extentOf(chart.series.flatMap((s) => s.values)) ?? [0, 1];
 	const lineFormat = chartValueFormatter(chart);
 	const f = buildFrame(chart, wPt, hPt, measure, false, {
 		dataRange: range,
@@ -888,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,
@@ -944,73 +1476,372 @@ 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 = series.pointLabels?.find((l) => l.idx === 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 series.pointColors?.find((p) => p.idx === idx)?.colorHex;
+	return atPoint(series.pointColors, idx)?.colorHex;
 }
-function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box") {
+/** Each override list's entries by point index, built on first use. */
+var overridesByPoint = /* @__PURE__ */ new WeakMap();
+/**
+* The first of `overrides` for the point at `idx` — looked up, not searched
+* for: a series that overrides many of its points, searched through for every
+* one of them, took the square of their number.
+*/
+function atPoint(overrides, idx) {
+	if (!overrides) return void 0;
+	let byPoint = overridesByPoint.get(overrides);
+	if (!byPoint) {
+		const index = /* @__PURE__ */ new Map();
+		for (const o of overrides) if (!index.has(o.idx)) index.set(o.idx, o);
+		overridesByPoint.set(overrides, index);
+		byPoint = index;
+	}
+	return byPoint.get(idx);
+}
+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;
@@ -1027,9 +1858,9 @@ 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 = Math.max(...entries.map(entryW));
+		const colW = entries.reduce((w, e) => Math.max(w, entryW(e)), 0);
 		return {
 			rightWidth: pos === "r" ? colW : 0,
 			bottomHeight: 0,
@@ -1042,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;
@@ -1063,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);
@@ -1100,7 +1929,7 @@ function buildChartScene(chart, wPt, hPt, measure) {
 *          in reverse.
 */
 function withReversedCategories(chart) {
-	const n = Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
+	const n = catCount(chart);
 	const flip = (i) => n - 1 - i;
 	return {
 		...chart,
@@ -1115,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)
 			})) } : {}
 		}))
 	};
@@ -1158,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 };