reamkit 1.32.0 → 1.32.1

package/dist/esm/core/crypto/offcrypto.js

@@ -159,29 +159,73 @@ function agileKeyData(attrs) {
 	};
 }
 function passwordKeyEncryptor(xml) {
-	const re = /<[A-Za-z0-9]*:?encryptedKey\b([^>]*)\/?>/gu;
-	let m = re.exec(xml);
-	while (m) {
-		const attrs = parseAttrs(m[1] ?? "");
+	for (const raw of elementsNamed(xml, "encryptedKey")) {
+		const attrs = parseAttrs(raw);
 		if (attrs["spinCount"] !== void 0) return attrs;
-		m = re.exec(xml);
 	}
 	throw new Error("No password key encryptor in the encryption descriptor");
 }
 function attrsOf(xml, tag) {
-	const m = new RegExp(`<[A-Za-z0-9]*:?${tag}\\b([^>]*)/?>`, "u").exec(xml);
-	return m ? parseAttrs(m[1] ?? "") : {};
+	const raw = elementsNamed(xml, tag)[0];
+	return raw === void 0 ? {} : parseAttrs(raw);
+}
+function elementsNamed(xml, tag) {
+	const out = [];
+	let open = xml.indexOf("<");
+	while (open >= 0) {
+		const end = nameEnd(xml, open + 1, tag);
+		if (end < 0) {
+			open = xml.indexOf("<", open + 1);
+			continue;
+		}
+		const close = xml.indexOf(">", end);
+		if (close < 0) break;
+		out.push(xml.slice(end, close));
+		open = xml.indexOf("<", close + 1);
+	}
+	return out;
+}
+function nameEnd(xml, from, tag) {
+	let end = from;
+	while (isAlnum(xml.charCodeAt(end))) end++;
+	const prefixed = end + 1 + tag.length;
+	if (xml[end] === ":" && xml.startsWith(tag, end + 1) && !isWordChar(xml.charCodeAt(prefixed))) return prefixed;
+	if (end - from >= tag.length && xml.startsWith(tag, end - tag.length)) return isWordChar(xml.charCodeAt(end)) ? -1 : end;
+	return -1;
 }
 function parseAttrs(raw) {
 	const out = {};
-	const re = /([A-Za-z0-9_:]+)\s*=\s*"([^"]*)"/gu;
-	let m = re.exec(raw);
-	while (m) {
-		out[m[1].replace(/^.*:/u, "")] = m[2];
-		m = re.exec(raw);
+	let at = 0;
+	while (at < raw.length) {
+		if (!isNameChar(raw.charCodeAt(at))) {
+			at++;
+			continue;
+		}
+		let end = at;
+		while (isNameChar(raw.charCodeAt(end))) end++;
+		let k = skipSpace(raw, end);
+		if (raw[k] === "=") {
+			k = skipSpace(raw, k + 1);
+			const close = raw[k] === "\"" ? raw.indexOf("\"", k + 1) : -1;
+			if (close >= 0) {
+				const name = raw.slice(at, end);
+				out[name.slice(name.lastIndexOf(":") + 1)] = raw.slice(k + 1, close);
+				at = close + 1;
+				continue;
+			}
+		}
+		at = end;
 	}
 	return out;
 }
+var isAlnum = (c) => c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122;
+var isWordChar = (c) => isAlnum(c) || c === 95;
+var isNameChar = (c) => isWordChar(c) || c === 58;
+function skipSpace(s, from) {
+	let at = from;
+	while (at < s.length && /\s/u.test(s[at])) at++;
+	return at;
+}
 function utf16le(s) {
 	const out = new Uint8Array(s.length * 2);
 	const v = new DataView(out.buffer);

package/dist/esm/core/drawingml/chart-geometry.d.ts

@@ -119,22 +119,25 @@ export interface Scale {
 }
 /**
  * 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.
@@ -143,14 +146,21 @@ export interface Scale {
  */
 export declare function niceScale(dataMin: number, dataMax: number, maxIntervals?: number): Scale;
 /**
- * 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.
+ * 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.
  */
-export declare function formatTick(v: number, step: number): string;
+export declare function formatTick(v: number): string;
 export declare function buildBarScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
 /**
  * The name a series shows in the legend: its own `c:tx`, or Excel's positional

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";
@@ -25,22 +25,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 +51,170 @@ 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. 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;
-	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) * .05)
+		};
+	}
+	if (hi <= 0) {
+		const to = spread < -lo / 6 ? hi + spread / 2 : 0;
+		return {
+			lo: finite(lo - (to - lo) * .05),
+			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 * .05),
+		hi: finite(hi + spread * .05)
 	};
 }
-/** 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.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);
+}
 /**
-* 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), 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, extentPt, horizontal = false) {
-	const rounded = niceScale(chart.valAxisMin ?? dataMin, chart.valAxisMax ?? dataMax, intervalsThatFit(extentPt, horizontal));
-	const step = chart.valAxisMajorUnit ?? rounded.step;
-	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),
+	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);
 }
 /**
 * The chart title's lines. A title longer than the chart is wide wraps at its
@@ -244,32 +339,33 @@ 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 ?? (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));
+	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 catText = (c) => chart.categories[c] ?? String(c + 1);
-	const widestCat = Math.max(0, ...Array.from({ length: nCats }, (_, c) => measure(catText(c), 9)));
+	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 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);
@@ -282,7 +378,7 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	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 valueOffset = (v) => fractionOf(v, scale) * (horizontal ? plotW : plotH);
 	const zeroOffset = valueOffset(crossValue);
 	const plotBackground = chart.plotFillHex ?? chart.plotLine?.colorHex ? {
 		x: x0,
@@ -316,10 +412,10 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	});
 	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 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,
@@ -418,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;
@@ -768,22 +885,24 @@ 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 = niceScale(xLo, xHi, intervalsThatFit(wPt, true));
+	const yScale = niceScale(yLo, yHi, intervalsThatFit(hPt, false));
 	const xTicks = ticks(xScale);
 	const yTicks = ticks(yScale);
 	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;
+	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, (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);
+	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");
@@ -871,8 +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 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,
@@ -973,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,
@@ -1002,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 {
@@ -1029,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,
@@ -1100,7 +1236,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,

package/dist/esm/core/drawingml/chart-parser.d.ts

@@ -2,6 +2,25 @@ import { Chart } from '../document-model/index.js';
 import { ResourceId } from '../ir/index.js';
 import { OpcPackage } from '../opc/index.js';
 import { ColorResolver } from './colors.js';
+/**
+ * The most points a chart keeps, all its series together: as many as a sheet
+ * has rows, the longest range a series can name. A chart part states its own
+ * point counts — a cache's `c:ptCount`, each point's `idx`, the range of a
+ * `c:f` — and taken at their word, a count of two billion in a part a few
+ * hundred bytes long asked for a dense array that ran the process out of
+ * memory, and one past 2³² − 1 threw.
+ */
+export declare const MOST_CHART_POINTS = 1048576;
+/**
+ * How many points each of a chart's `seriesCount` series keeps: an even share
+ * of {@link MOST_CHART_POINTS}, so that the bound holds for the chart and not
+ * series by series — two thousand series, each declaring a sheet's worth of
+ * points, are two billion. A series' points past its share are not read.
+ *
+ * @param seriesCount How many series the chart has.
+ * @returns The points each keeps, at least one.
+ */
+export declare function pointsPerSeries(seriesCount: number): number;
 /**
  * Parse a DrawingML chart part (chart1.xml) into a {@link Chart}, reading the
  * CACHED data (`c:numCache` / `c:strCache`) rather than the embedded spreadsheet