reamkit 1.31.0 → 1.32.1

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

@@ -1,4 +1,4 @@
-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";
@@ -23,85 +23,238 @@ var SERIES_COLORS = [
 * @returns An RRGGBB hex string.
 */
 var seriesColor = (s, i, cycle) => s.colorHex ?? (cycle && cycle.length > 0 ? cycle[i % cycle.length] : SERIES_COLORS[i % SERIES_COLORS.length]);
-function niceNum(range, round) {
-	const exp = Math.floor(Math.log10(range));
-	const f = range / 10 ** exp;
-	let nf;
-	if (round) nf = f < 1.5 ? 1 : f < 3 ? 2 : f < 7 ? 5 : 10;
-	else nf = f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10;
-	return nf * 10 ** exp;
-}
 /**
-* Compute a human-friendly axis {@link Scale} for the data range using
-* Heckbert's "nice numbers" algorithm: rounded endpoints and a 1/2/5·10ⁿ step
-* that yields about `maxTicks` ticks. A degenerate range (`dataMin === dataMax`)
-* is widened by 1 so the axis is non-empty.
+* The scale Excel gives a value axis it is left to choose, measured against
+* 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 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 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, 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 data value to cover.
-* @param dataMax  The largest data value to cover.
-* @param maxTicks Target upper bound on tick count (default 6).
+* @param dataMin      The smallest value to cover.
+* @param dataMax      The largest value to cover.
+* @param maxIntervals At most this many steps between the ends (default 10).
 * @returns The rounded min/max and tick step.
 */
-function niceScale(dataMin, dataMax, maxTicks = 6) {
-	const lo = Math.min(dataMin, dataMax);
-	let hi = Math.max(dataMin, dataMax);
-	if (lo === hi) hi = lo + 1;
-	const step = niceNum((hi - lo) / Math.max(1, maxTicks - 1), true);
-	const headroom = hi > 0 ? hi * 1.05 : hi;
+function niceScale(dataMin, dataMax, maxIntervals = 10) {
+	const end = paddedEnds(dataMin, dataMax);
+	const step = stepFor(end.lo, end.hi, maxIntervals);
 	return {
-		min: Math.floor(lo / step) * step,
-		max: Math.ceil(headroom / step) * step,
+		min: below(end.lo, step),
+		max: above(end.hi, step),
 		step
 	};
 }
 /**
-* 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 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
+* out at ±1.7E+308 would run them to.
+*/
+function paddedEnds(dataMin, dataMax) {
+	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;
+	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)
+		};
+	}
+	if (hi <= 0) {
+		const to = spread < -lo / 6 ? hi + spread / 2 : 0;
+		return {
+			lo: finite(lo - (to - lo) * .05),
+			hi: to
+		};
+	}
+	return {
+		lo: finite(lo - spread * .05),
+		hi: finite(hi + spread * .05)
+	};
+}
+/** `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);
+	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 (share <= m * base * 1.000000001) 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);
+}
+/**
+* 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)));
-	return v.toFixed(decimals).replace(/\.?0+$/, (m) => m.includes(".") ? "" : m);
+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), MOST_INTERVALS + 1);
 	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.98 `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.
 * @returns The axis min/max and tick step.
 */
-function axisScale(chart, dataMin, dataMax, hPt) {
-	const rounded = niceScale(chart.valAxisMin ?? dataMin, chart.valAxisMax ?? dataMax, tickBudget(hPt));
-	return {
-		min: chart.valAxisMin ?? rounded.min,
-		max: chart.valAxisMax ?? rounded.max,
-		step: rounded.step
-	};
+function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false) {
+	const fixedMin = chart.valAxisMin;
+	const fixedMax = chart.valAxisMax;
+	const padded = paddedEnds(fixedMin ?? dataMin, fixedMax ?? dataMax);
+	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);
 }
-function pushChartTitle(labels, chart, wPt, hPt) {
-	if (!chart.title) return;
-	labels.push({
-		text: chart.title,
-		x: wPt / 2,
-		y: hPt - 4 - 13,
-		sizePt: 13,
-		colorHex: TITLE_COLOR,
-		align: "center"
+/**
+* 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
+* Counties on Days per Patient (ALOS) in 2015" crossed the cells beside its
+* chart. A line holds at most four fifths of the chart's width.
+*
+* @param chart   The chart.
+* @param wPt     The chart's width.
+* @param measure The text measurer.
+* @returns The lines, top first; none for a chart without a title.
+*/
+function titleLines(chart, wPt, measure) {
+	if (!chart.title) return [];
+	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) {
+			lines.push(line);
+			line = word;
+		} else line = longer;
+	}
+	if (line) lines.push(line);
+	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) {
+	lines.forEach((text, i) => {
+		labels.push({
+			text,
+			x: wPt / 2,
+			y: hPt - 4 - 13 * (1 + 1.2 * i),
+			sizePt: 13,
+			colorHex: TITLE_COLOR,
+			align: "center"
+		});
 	});
 }
 function buildLegendBlock(chart, wPt, hPt, measure) {
@@ -113,7 +266,7 @@ function buildLegendBlock(chart, wPt, hPt, measure) {
 	const marker = chart.type === "line" || chart.type === "scatter" ? "line" : "box";
 	return layoutLegend(legendEntries, chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure, marker);
 }
-function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid) {
+function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid, atEnd = false) {
 	for (const v of tickVals) if (axis === "x") {
 		const gx = at(v);
 		gridlines.push({
@@ -124,7 +277,7 @@ function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW
 		labels.push({
 			text: fmt(v),
 			x: gx,
-			y: y0 - 9,
+			y: atEnd ? y0 + plotH + 9 * .4 : y0 - 9,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
 			align: "center"
@@ -138,11 +291,11 @@ function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW
 		});
 		labels.push({
 			text: fmt(v),
-			x: x0 - 3,
+			x: atEnd ? x0 + plotW + 3 : x0 - 3,
 			y: gy - 9 / 3,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
-			align: "right"
+			align: atEnd ? "left" : "right"
 		});
 	}
 }
@@ -159,16 +312,24 @@ function axisStroke(style) {
 		widthPt: style?.widthPt ?? 1
 	};
 }
-function pushAxisLines(polylines, x0, y0, plotW, plotH, chart) {
+/**
+* The two axis lines: the upright one (in the left axis's style) and the one
+* lying along (in the bottom axis's). The category axis lies where it crosses
+* 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 = {}) {
 	const val = axisStroke(chart.valAxisLine);
+	const x = x0 + (cross.x ?? 0);
+	const y = y0 + (cross.y ?? 0);
 	if (val) polylines.push({
-		points: [[x0, y0], [x0, y0 + plotH]],
+		points: [[x, y0], [x, y0 + plotH]],
 		strokeHex: val.hex,
 		widthPt: val.widthPt
 	});
 	const cat = axisStroke(chart.catAxisLine);
 	if (cat) polylines.push({
-		points: [[x0, y0], [x0 + plotW, y0]],
+		points: [[x0, y], [x0 + plotW, y]],
 		strokeHex: cat.hex,
 		widthPt: cat.widthPt
 	});
@@ -178,30 +339,47 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	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 ?? [Math.min(0, ...allVals), Math.max(0, ...allVals)];
-	const scale = axisScale(chart, dataMin, dataMax, hPt);
-	const fmtVal = opts.formatValue ?? ((v) => formatTick(v, scale.step));
+	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 ?? formatTick;
 	const tickVals = ticks(scale);
-	const vals2 = onSecondary.flatMap((s) => s.values.slice(0, nCats));
-	const scale2 = vals2.length > 0 ? niceScale(Math.min(0, ...vals2), Math.max(0, ...vals2), tickBudget(hPt)) : 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) : [];
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	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 catText = (c) => chart.categories[c] ?? String(c + 1);
+	let widestCat = 0;
+	for (let c = 0; c < nCats; c++) widestCat = Math.max(widestCat, measure(catText(c), 9));
+	const catBand = 9 * 1.6;
+	const groupLevels = horizontal ? [] : chart.categoryGroups ?? [];
+	const valAtEnd = chart.catAxisReversed === true ? chart.valAxisCrosses !== "max" : chart.valAxisCrosses === "max";
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title) + (!horizontal && labelsAt === "end" ? catBand : 0) + (horizontal && valAtEnd ? 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 plotRight = wPt - 4 - legend.rightWidth - tick2W;
+	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 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 catLabelH = 9 * 1.6;
-	const catTitleH = chart.catAxisTitle ? 9 * 1.5 : 0;
-	const x0 = 4 + (chart.valAxisTitle ? 9 * 1.5 : 0) + tickLabelW;
-	const y0 = 4 + legend.bottomHeight + catTitleH + catLabelH;
+	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 zeroOffset = valueOffset(0);
+	const valueOffset = (v) => fractionOf(v, scale) * (horizontal ? plotW : plotH);
+	const zeroOffset = valueOffset(crossValue);
 	const plotBackground = chart.plotFillHex ?? chart.plotLine?.colorHex ? {
 		x: x0,
 		y: y0,
@@ -214,9 +392,9 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 			...chart.plotLine.dash ? { strokeDash: chart.plotLine.dash } : {}
 		} : {}
 	} : void 0;
-	pushChartTitle(labels, chart, wPt, hPt);
-	if (chart.valAxisTitle) labels.push({
-		text: chart.valAxisTitle,
+	pushChartTitle(labels, title, wPt, hPt);
+	if (leftTitle) labels.push({
+		text: leftTitle,
 		x: 12.1,
 		y: y0 + plotH / 2,
 		sizePt: 9,
@@ -224,20 +402,20 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		align: "center",
 		rotationDeg: 90
 	});
-	if (chart.catAxisTitle) labels.push({
-		text: chart.catAxisTitle,
+	if (footTitle) labels.push({
+		text: footTitle,
 		x: x0 + plotW / 2,
 		y: legend.bottomHeight + 2,
 		sizePt: 9,
 		colorHex: LABEL_COLOR,
 		align: "center"
 	});
-	if (horizontal) pushGridTicks(gridlines, labels, tickVals, fmtVal, "x", (v) => x0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine);
-	else pushGridTicks(gridlines, labels, tickVals, fmtVal, "y", (v) => y0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine);
-	const valueOffset2 = scale2 && !horizontal ? (v) => (v - scale2.min) / (scale2.max - scale2.min) * plotH : void 0;
+	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) => 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,
@@ -261,30 +439,60 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		});
 	}
 	const slot = (horizontal ? plotH : plotW) / nCats;
-	const need = horizontal ? 9 * 1.4 : Math.max(0, ...chart.categories.map((t) => measure(t, 9))) + 4;
+	const need = horizontal ? 9 * 1.4 : widestCat + 4;
 	const step = Math.max(1, Math.ceil(need / Math.max(slot, .01)));
-	for (let c = 0; c < nCats; c += step) {
-		const cat = chart.categories[c] ?? String(c + 1);
+	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);
+	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: x0 - 3,
+			x: labelsAt === "end" ? x0 + across + 3 : x0 + across - 3,
 			y: center - 9 / 3,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
-			align: "right"
+			align: labelsAt === "end" ? "left" : "right"
 		});
 		else labels.push({
 			text: cat,
 			x: center,
-			y: y0 - 9,
+			y: labelsAt === "end" ? y0 + across + 9 * .4 : y0 + across - 9,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
 			align: "center"
 		});
 	}
-	pushAxisLines(polylines, x0, y0, plotW, plotH, chart);
+	if (labelsAt !== "none" && labelsAt !== "end") groupLevels.forEach((groups, level) => {
+		const rowY = y0 + across - 9 - (level + 1) * catBand;
+		groups.forEach((group, i) => {
+			const end = Math.min(nCats, groups[i + 1]?.start ?? nCats);
+			if (end <= group.start) return;
+			labels.push({
+				text: group.label,
+				x: x0 + (group.start + end) / 2 * slot,
+				y: rowY,
+				sizePt: 9,
+				colorHex: LABEL_COLOR,
+				align: "center"
+			});
+			if (i > 0) polylines.push({
+				points: [[x0 + group.start * slot, y0 + across], [x0 + group.start * slot, rowY - 9 * .4]],
+				strokeHex: GRID_COLOR,
+				widthPt: .75
+			});
+		});
+	});
+	pushAxisLines(polylines, x0, y0, plotW, plotH, chart, horizontal ? {
+		x: zeroOffset,
+		...valAtEnd ? { y: plotH } : {}
+	} : {
+		y: zeroOffset,
+		...valAtEnd ? { x: plotW } : {}
+	});
 	legend.emit(rects, labels);
 	return {
 		x0,
@@ -306,8 +514,29 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 }
 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;
@@ -332,6 +561,7 @@ function groupingFrameOpts(chart, nCats) {
 	const g = chart.grouping ?? "clustered";
 	if (g === "percentStacked") return {
 		dataRange: [0, 1],
+		exactRange: true,
 		formatValue: pctLabel
 	};
 	const format = chartValueFormatter(chart);
@@ -655,22 +885,24 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 		wedges: [],
 		labels
 	};
-	const xScale = niceScale(...autoRange(xs), tickBudget(wPt / 2));
-	const yScale = niceScale(...autoRange(ys), tickBudget(hPt));
+	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 xTicks = ticks(xScale);
 	const yTicks = ticks(yScale);
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title);
 	const legend = buildLegendBlock(chart, wPt, hPt, measure);
-	const x0 = 4 + (Math.max(0, ...yTicks.map((v) => measure(formatTick(v, yScale.step), 9))) + 4);
+	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 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, chart, 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 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);
 	pushAxisLines(polylines, x0, y0, plotW, plotH, chart);
 	const style = chart.scatterStyle ?? "marker";
 	const joins = style === "line" || style === "lineMarker" || style.startsWith("smooth");
@@ -702,27 +934,13 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 	};
 }
 /**
-* The data range an automatic axis covers: its own extent, except that data
-* starting within 5/6 of the top reads as data that belongs against a zero
-* baseline — Excel's own rule for when an automatic minimum stays at 0.
+* How many intervals an axis `extentPt` long has room to label: ten, Excel's
+* own most, unless its labels would run into each other first — one label
+* line apiece stacked up a vertical axis, a few digits' width apiece along a
+* horizontal one. Excel crams nine labels up a 150pt column chart rather than
+* step it more coarsely, so the room is all that limits it.
 */
-function autoRange(vals) {
-	const lo = Math.min(...vals);
-	const hi = Math.max(...vals);
-	return [lo > 0 && lo < 5 / 6 * hi ? 0 : lo, hi];
-}
-/**
-* How many ticks an axis `extentPt` long carries (mirrors {@link axisScale}).
-*
-* A tall axis takes more of them — a fixed six drew 0/100/200/300 down a plot
-* where both references fit 0/50/…/300 — but the appetite is milder than it
-* looks: asked for one every 32pt, a 427pt chart wanted ten, and Excel labels
-* that chart's 0…5 data 0/1/…/6 where we drew half-steps (chart-texture-bg
-* .pptx). One per ~48pt and never more than eight satisfies both, now that
-* {@link niceScale} measures its step against the range the data spans rather
-* than against Heckbert's rounded-up one.
-*/
-var tickBudget = (extentPt) => Math.min(8, Math.max(4, Math.round(extentPt / 48)));
+var intervalsThatFit = (extentPt, horizontal) => Math.min(10, Math.max(2, Math.floor(extentPt * .75 / (9 * (horizontal ? 3.5 : 1.4)))));
 /** Side (points) of the square stamped for a series that names no symbol. */
 var DEFAULT_MARKER_PT = 4;
 /**
@@ -772,10 +990,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 lo = allVals.length > 0 ? Math.min(...allVals) : 0;
-	const hi = allVals.length > 0 ? Math.max(...allVals) : 1;
-	const range = lo > 0 && lo > 5 / 6 * hi ? [lo, hi] : [Math.min(0, lo), Math.max(0, hi)];
+	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,
@@ -846,8 +1061,8 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		wedges,
 		labels
 	};
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title);
 	const legend = layoutLegend(values.map((_, i) => ({
 		name: chart.categories[i] ?? String(i + 1),
 		colorHex: sliceColor(series, i, chart.seriesColorCycle)
@@ -876,7 +1091,7 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		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;
+		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,
@@ -895,14 +1110,7 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		sweepRad: -2 * Math.PI,
 		fillHex: "FFFFFF"
 	});
-	if (chart.title) labels.push({
-		text: chart.title,
-		x: wPt / 2,
-		y: hPt - 4 - 13,
-		sizePt: 13,
-		colorHex: TITLE_COLOR,
-		align: "center"
-	});
+	pushChartTitle(labels, title, wPt, hPt);
 	legend.emit(rects, labels);
 	return {
 		rects,
@@ -912,7 +1120,25 @@ function buildPieScene(chart, wPt, hPt, measure) {
 	};
 }
 function pointColor(series, idx) {
-	return series.pointColors?.find((p) => p.idx === idx)?.colorHex;
+	return atPoint(series.pointColors, idx)?.colorHex;
+}
+/** 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, marker = "box") {
 	if (!hasLegend || entries.length === 0) return {
@@ -939,7 +1165,7 @@ function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure, marker = "box"
 	};
 	const entryW = (e) => keyW + 3 + measure(e.name, 9) + gap * 2;
 	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,
@@ -1010,11 +1236,11 @@ 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,
-		categories: chart.categories.length > 0 ? Array.from({ length: n }, (_, i) => chart.categories[flip(i)] ?? "") : chart.categories,
+		categories: Array.from({ length: n }, (_, i) => chart.categories.length > 0 ? chart.categories[flip(i)] ?? "" : String(flip(i) + 1)),
 		series: chart.series.map((s) => ({
 			...s,
 			values: Array.from({ length: n }, (_, i) => s.values[flip(i)] ?? 0),