reamkit 1.32.0 → 1.33.0

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

@@ -2,6 +2,26 @@ import { Chart } from '../document-model/index.js';
 import { ResourceId } from '../ir/index.js';
 import { OpcPackage } from '../opc/index.js';
 import { ColorResolver } from './colors.js';
+import { ChartTextDefaults } from './chart-text.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
@@ -13,9 +33,12 @@ import { ColorResolver } from './colors.js';
  *
  * @param chartXml     The raw chart1.xml part bytes.
  * @param resolveColor Maps a DrawingML colour reference to a 6-hex string.
+ * @param resolveImage Maps a blip's relationship id to its image resource.
+ * @param textDefaults The host's defaults for chart text; given, the chart's
+ *                     text is resolved role by role ({@link Chart.text}).
  * @returns The parsed chart, or `null` when there is no `c:chart` / `c:plotArea`.
  */
-export declare function parseChart(chartXml: Uint8Array, resolveColor: ColorResolver, resolveImage?: (relId: string) => ResourceId | undefined): Chart | null;
+export declare function parseChart(chartXml: Uint8Array, resolveColor: ColorResolver, resolveImage?: (relId: string) => ResourceId | undefined, textDefaults?: ChartTextDefaults): Chart | null;
 /**
  * MS-ODRAWXML chartColorStyle (charts/colorsN.xml): the top-level colour list is
  * the series cycle (`meth="cycle"` — the common case; variations are luminance

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

@@ -1,4 +1,5 @@
 import { poAttr, poChildren, poFindByPath, poFindDescendant, poIntAttr, poIs, poTag, poText, poVal } from "../po-helpers.js";
+import { chartTextStyles } from "./chart-text.js";
 import { resolveColorNode } from "./colors.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/core/drawingml/chart-parser.ts
@@ -25,6 +26,27 @@ var TYPE_OF_TAG = {
 	"c:scatterChart": "scatter"
 };
 /**
+* 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.
+*/
+var 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.
+*/
+function pointsPerSeries(seriesCount) {
+	return Math.max(1, Math.floor(MOST_CHART_POINTS / Math.max(1, seriesCount)));
+}
+/**
 * Parse a DrawingML chart part (chart1.xml) into a {@link Chart}, reading the
 * CACHED data (`c:numCache` / `c:strCache`) rather than the embedded spreadsheet
 * — the cache holds the last-computed categories and values, exactly what Word
@@ -35,9 +57,12 @@ var TYPE_OF_TAG = {
 *
 * @param chartXml     The raw chart1.xml part bytes.
 * @param resolveColor Maps a DrawingML colour reference to a 6-hex string.
+* @param resolveImage Maps a blip's relationship id to its image resource.
+* @param textDefaults The host's defaults for chart text; given, the chart's
+*                     text is resolved role by role ({@link Chart.text}).
 * @returns The parsed chart, or `null` when there is no `c:chart` / `c:plotArea`.
 */
-function parseChart(chartXml, resolveColor, resolveImage) {
+function parseChart(chartXml, resolveColor, resolveImage, textDefaults) {
 	const tree = parser.parse(decoder.decode(chartXml));
 	const chart = poFindByPath(tree, ["c:chartSpace", "c:chart"]);
 	if (!chart) return null;
@@ -48,6 +73,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const type = group ? TYPE_OF_TAG[poTag(group)] ?? "unknown" : "unknown";
 	const groupAxIds = (g) => poChildren(g).filter((c) => poIs(c, "c:axId")).map((c) => poAttr(c, "val") ?? "");
 	const primaryAxIds = new Set(group ? groupAxIds(group) : []);
+	const most = pointsPerSeries(groups.reduce((n, g) => n + poChildren(g).filter((c) => poIs(c, "c:ser")).length, 0));
 	const serNodes = [];
 	const series = [];
 	let secondaryValAxId;
@@ -58,7 +84,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		for (const s of poChildren(g).filter((c) => poIs(c, "c:ser"))) {
 			serNodes.push(s);
 			series.push({
-				...parseSeries(s, resolveColor),
+				...parseSeries(s, resolveColor, most),
 				...groupType === type ? {} : { type: groupType },
 				...secondary ? { secondaryAxis: true } : {}
 			});
@@ -75,8 +101,8 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	for (const s of serNodes) {
 		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
 		if (cat) {
-			const levels = multiLevelCategories(cat);
-			categories = levels ? levels.categories : denseStrings(cat);
+			const levels = multiLevelCategories(cat, most);
+			categories = levels ? levels.categories : denseStrings(cat, most);
 			categoryGroups = levels?.groups;
 			categoriesRef ??= refFormula(cat);
 			break;
@@ -88,21 +114,55 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const barDir = group ? poVal(poChildren(group).find((c) => poIs(c, "c:barDir"))) : void 0;
 	const grouping = group ? poVal(poChildren(group).find((c) => poIs(c, "c:grouping"))) : void 0;
 	const doughnut = group ? poIs(group, "c:doughnutChart") : false;
+	const view3D = poChildren(chart).find((c) => poIs(c, "c:view3D"));
+	const viewAngle = (tag, fallback) => {
+		const v = Number(poVal(view3D ? poChildren(view3D).find((c) => poIs(c, tag)) : void 0));
+		return Number.isFinite(v) ? v : fallback;
+	};
+	const pie3D = group && poIs(group, "c:pie3DChart") ? {
+		rotX: viewAngle("c:rotX", 0),
+		rotY: viewAngle("c:rotY", 0)
+	} : void 0;
+	const gapDepthRaw = group && poIs(group, "c:bar3DChart") ? Number(poVal(poChildren(group).find((c) => poIs(c, "c:gapDepth"))) ?? NaN) : NaN;
+	const bar3D = group && poIs(group, "c:bar3DChart") ? {
+		rotX: Math.min(90, Math.max(-90, viewAngle("c:rotX", 0))),
+		rotY: (viewAngle("c:rotY", 0) % 360 + 360) % 360,
+		depthPercent: Math.min(2e3, Math.max(20, viewAngle("c:depthPercent", 100))),
+		gapDepth: Number.isFinite(gapDepthRaw) ? Math.min(500, Math.max(0, gapDepthRaw)) : 150
+	} : void 0;
+	const floor = bar3D ? surfaceOf(poChildren(chart).find((c) => poIs(c, "c:floor")), resolveColor) : void 0;
+	const backWall = bar3D ? surfaceOf(poChildren(chart).find((c) => poIs(c, "c:backWall")), resolveColor) : void 0;
+	const sideWall = bar3D ? surfaceOf(poChildren(chart).find((c) => poIs(c, "c:sideWall")), resolveColor) : void 0;
+	const plotBox = plotBoxOf(plotArea);
+	const firstSliceRaw = group && (poIs(group, "c:pieChart") || poIs(group, "c:doughnutChart")) ? Number(poVal(poChildren(group).find((c) => poIs(c, "c:firstSliceAng")))) : NaN;
+	const firstSliceAngle = Number.isFinite(firstSliceRaw) ? firstSliceRaw : void 0;
 	const showValues = group ? chartShowsValues(group) : false;
-	const catAxisTitle = axisTitle(plotArea, "c:catAx");
-	const valAxisTitle = axisTitle(plotArea, "c:valAx");
+	const dataLabels = dataLabelsOf(group, group ? poChildren(group).find((c) => poIs(c, "c:ser")) : void 0);
 	const catAxNode = poChildren(plotArea).find((c) => poIs(c, "c:catAx"));
 	const valAxNode = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
 	const axisAt = (...where) => poChildren(plotArea).find((c) => (poIs(c, "c:catAx") || poIs(c, "c:valAx") || poIs(c, "c:dateAx")) && c !== secondaryValAx && where.includes(poVal(poChildren(c).find((k) => poIs(k, "c:axPos"))) ?? ""));
 	const bottomAxNode = axisAt("b", "t") ?? catAxNode;
 	const leftAxNode = axisAt("l", "r") ?? valAxNode;
-	const catAxisLine = lineStyleOf(bottomAxNode, resolveColor);
-	const valAxisLine = lineStyleOf(leftAxNode, resolveColor);
+	const isScatter = type === "scatter";
+	const valRoleAx = isScatter ? leftAxNode : poChildren(plotArea).find((c) => poIs(c, "c:valAx") && c !== secondaryValAx);
+	const catRoleAx = isScatter ? bottomAxNode : catAxNode ?? poChildren(plotArea).find((c) => poIs(c, "c:dateAx"));
+	const catAxisDeleted = isDeletedAxis(catRoleAx);
+	const valAxisDeleted = isDeletedAxis(valRoleAx);
+	const ruleOf = (ax) => isDeletedAxis(ax) ? { none: true } : lineStyleOf(ax, resolveColor);
+	const catAxisLine = ruleOf(bottomAxNode);
+	const valAxisLine = ruleOf(leftAxNode);
 	const secondaryValAxisLine = lineStyleOf(secondaryValAx, resolveColor);
-	const gridLine = lineStyleOf(leftAxNode ? poChildren(leftAxNode).find((c) => poIs(c, "c:majorGridlines")) : void 0, resolveColor);
-	const valAxisMin = axisScaling(plotArea, "c:min");
-	const valAxisMax = axisScaling(plotArea, "c:max");
-	const valAxisMajorUnit = majorUnitOf(plotArea);
+	const gridLine = gridlinesOf(valRoleAx, resolveColor);
+	const xGridLine = isScatter ? gridlinesOf(bottomAxNode, resolveColor) : void 0;
+	const catAxisTitle = isScatter ? axisTitleOf(bottomAxNode) : axisTitle(plotArea, "c:catAx");
+	const valAxisTitle = isScatter ? axisTitleOf(leftAxNode) : axisTitle(plotArea, "c:valAx");
+	const valAxisMin = isScatter ? axisScalingOf(leftAxNode, "c:min") : axisScaling(plotArea, "c:min");
+	const valAxisMax = isScatter ? axisScalingOf(leftAxNode, "c:max") : axisScaling(plotArea, "c:max");
+	const valAxisMajorUnit = isScatter ? majorUnitOfAxis(leftAxNode) : majorUnitOf(plotArea);
+	const xAxisMin = isScatter ? axisScalingOf(bottomAxNode, "c:min") : void 0;
+	const xAxisMax = isScatter ? axisScalingOf(bottomAxNode, "c:max") : void 0;
+	const xAxisMajorUnit = isScatter ? majorUnitOfAxis(bottomAxNode) : void 0;
+	const xNumberFormat = isScatter ? formatCodeOf(bottomAxNode) : void 0;
 	const catAxisReversed = axisOrientation(catAxNode) === "maxMin";
 	const catAxisCrosses = axisCrossing(catAxNode);
 	const valAxisCrosses = axisCrossing(valAxNode);
@@ -118,17 +178,32 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const plotFillHex = plotSpPr ? frameFillOf(plotSpPr, resolveColor) : void 0;
 	const plotLine = lineStyleOf(plotArea, resolveColor);
 	const frameLineHex = spaceSpPr ? frameLine ? frameFillOf(frameLine, resolveColor) : void 0 : "D9D9D9";
-	const numberFormat = valueFormatCode(plotArea);
+	const numberFormat = isScatter ? formatCodeOf(leftAxNode) : valueFormatCode(plotArea);
 	const legend = poChildren(chart).find((c) => poIs(c, "c:legend"));
 	const legendPos = legend ? poVal(poChildren(legend).find((c) => poIs(c, "c:legendPos"))) : void 0;
+	const firstSer = serNodes[0];
+	const text = textDefaults ? chartTextStyles({
+		...chartSpace ? { chartSpace } : {},
+		...withNode("title", poChildren(chart).find((c) => poIs(c, "c:title"))),
+		...withNode("legend", legend),
+		...withNode("catAxis", catRoleAx),
+		...withNode("valAxis", valRoleAx),
+		...withNode("secondaryValAxis", secondaryValAx),
+		...withNode("dataLabels", (firstSer ? poChildren(firstSer).find((c) => poIs(c, "c:dLbls")) : void 0) ?? (group ? poChildren(group).find((c) => poIs(c, "c:dLbls")) : void 0))
+	}, resolveColor, (fill) => colorFromSolidFill(fill, resolveColor), textDefaults) : void 0;
 	const title = chartTitle(chart, series);
 	const gapNode = poChildren(plotArea).flatMap((g) => poChildren(g)).find((c) => poIs(c, "c:gapWidth"));
 	const gapRaw = gapNode ? poVal(gapNode) : void 0;
 	const gapPercent = gapRaw === void 0 ? NaN : Number(gapRaw);
+	const overlapNode = poChildren(plotArea).flatMap((g) => poChildren(g)).find((c) => poIs(c, "c:overlap"));
+	const overlapRaw = overlapNode ? poVal(overlapNode) : void 0;
+	const overlapPercent = overlapRaw === void 0 ? NaN : Number(overlapRaw);
 	return {
 		type,
 		...title ? { title } : {},
+		...text ? { text } : {},
 		...Number.isFinite(gapPercent) && gapPercent >= 0 ? { gapPercent } : {},
+		...Number.isFinite(overlapPercent) && overlapPercent !== 0 ? { overlapPercent: Math.min(100, Math.max(-100, overlapPercent)) } : {},
 		categories,
 		...categoriesRef ? { categoriesRef } : {},
 		...categoryGroups && categoryGroups.length > 0 ? { categoryGroups } : {},
@@ -138,7 +213,15 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...barDir === "col" || barDir === "bar" ? { barDir } : {},
 		...isGrouping(grouping) ? { grouping } : {},
 		...doughnut ? { doughnut: true } : {},
+		...pie3D ? { pie3D } : {},
+		...bar3D ? { bar3D } : {},
+		...floor ? { floor } : {},
+		...backWall ? { backWall } : {},
+		...sideWall ? { sideWall } : {},
+		...plotBox ? { plotBox } : {},
+		...firstSliceAngle ? { firstSliceAngle } : {},
 		...showValues ? { showValues: true } : {},
+		...dataLabels ? { dataLabels } : {},
 		...catAxisTitle ? { catAxisTitle } : {},
 		...catAxisReversed ? { catAxisReversed } : {},
 		...catAxisCrosses !== void 0 ? { catAxisCrosses } : {},
@@ -152,9 +235,16 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...valAxisLine ? { valAxisLine } : {},
 		...secondaryValAxisLine ? { secondaryValAxisLine } : {},
 		...gridLine ? { gridLine } : {},
+		...xGridLine ? { xGridLine } : {},
+		...catAxisDeleted ? { catAxisDeleted: true } : {},
+		...valAxisDeleted ? { valAxisDeleted: true } : {},
 		...valAxisMin !== void 0 ? { valAxisMin } : {},
 		...valAxisMax !== void 0 ? { valAxisMax } : {},
 		...valAxisMajorUnit !== void 0 ? { valAxisMajorUnit } : {},
+		...xAxisMin !== void 0 ? { xAxisMin } : {},
+		...xAxisMax !== void 0 ? { xAxisMax } : {},
+		...xAxisMajorUnit !== void 0 ? { xAxisMajorUnit } : {},
+		...xNumberFormat ? { xNumberFormat } : {},
 		...frameFillHex ? { frameFillHex } : {},
 		...frameFillImage ? { frameFillImage } : {},
 		...frameLineHex ? { frameLineHex } : {},
@@ -165,15 +255,29 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...numberFormat ? { numberFormat } : {}
 	};
 }
-function parseSeries(ser, resolveColor) {
+/** `{ [role]: node }` when there is a node — the shape `ChartTextNodes` takes. */
+function withNode(role, node) {
+	return node ? { [role]: node } : {};
+}
+function parseSeries(ser, resolveColor, most) {
 	const valNode = poChildren(ser).find((c) => poIs(c, "c:val")) ?? poChildren(ser).find((c) => poIs(c, "c:yVal"));
-	const values = valNode ? denseNumbers(valNode) : [];
+	const values = valNode ? denseNumbers(valNode, most) : [];
 	const xValNode = poChildren(ser).find((c) => poIs(c, "c:xVal"));
-	const xValues = xValNode ? denseNumbers(xValNode) : void 0;
+	const xValues = xValNode ? denseNumbers(xValNode, most) : void 0;
 	const name = seriesName(ser);
 	const colorHex = fillColorOf(poChildren(ser).find((c) => poIs(c, "c:spPr")), resolveColor);
 	const pointColors = dataPointColors(ser, resolveColor);
 	const pointLabels = customDataLabels(ser);
+	const explosion = explosionOf(ser);
+	const pointExplosions = poChildren(ser).filter((c) => poIs(c, "c:dPt")).flatMap((dPt) => {
+		const percent = explosionOf(dPt);
+		const idx = poIntAttr(poChildren(dPt).find((c) => poIs(c, "c:idx")), "val");
+		return percent !== void 0 && idx !== void 0 ? [{
+			idx,
+			percent
+		}] : [];
+	});
+	const pointLabelPlacements = labelPlacements(ser);
 	const marker = seriesMarker(ser);
 	const line = lineStyleOf(ser, resolveColor);
 	const valuesRef = valNode ? refFormula(valNode) : void 0;
@@ -187,11 +291,14 @@ function parseSeries(ser, resolveColor) {
 		...colorHex ? { colorHex } : {},
 		...pointColors.length > 0 ? { pointColors } : {},
 		...pointLabels.length > 0 ? { pointLabels } : {},
+		...explosion ? { explosion } : {},
+		...pointExplosions.length > 0 ? { pointExplosions } : {},
+		...pointLabelPlacements.length > 0 ? { pointLabelPlacements } : {},
 		...marker ? { marker } : {},
 		...line ? { line } : {}
 	};
 }
-var MARKER_SYMBOLS = new Set([
+var MARKER_SYMBOLS = /* @__PURE__ */ new Set([
 	"circle",
 	"dash",
 	"diamond",
@@ -230,6 +337,43 @@ function seriesName(ser) {
 * its own `<c:tx><c:rich>` replaces whatever the chart would have computed for
 * that point, and it is the only place that text exists.
 */
+/**
+* §21.2.2.104 — the plot area's box where the author sized it: `edge` mode,
+* every one of x, y, w and h stated, each a fraction of the chart.
+*/
+function plotBoxOf(plotArea) {
+	const layout = poChildren(plotArea).find((c) => poIs(c, "c:layout"));
+	const manual = layout ? poChildren(layout).find((c) => poIs(c, "c:manualLayout")) : void 0;
+	if (!manual) return void 0;
+	const kids = poChildren(manual);
+	const val = (tag) => poVal(kids.find((c) => poIs(c, tag)));
+	if (val("c:xMode") !== "edge" || val("c:yMode") !== "edge") return void 0;
+	const [x, y, w, h] = [
+		"c:x",
+		"c:y",
+		"c:w",
+		"c:h"
+	].map((tag) => Number(val(tag)));
+	if (![
+		x,
+		y,
+		w,
+		h
+	].every((v) => v !== void 0 && Number.isFinite(v))) return void 0;
+	if (w <= 0 || h <= 0) return void 0;
+	return {
+		x,
+		y,
+		w,
+		h,
+		...val("c:layoutTarget") === "inner" ? { inner: true } : {}
+	};
+}
+/** §21.2.2.61 `c:explosion` — a percentage of the pie's radius, at most 400. */
+function explosionOf(owner) {
+	const v = Number(poVal(poChildren(owner).find((c) => poIs(c, "c:explosion"))));
+	return Number.isFinite(v) && v >= 0 ? Math.min(v, 400) : void 0;
+}
 function customDataLabels(ser) {
 	const dLbls = poChildren(ser).find((c) => poIs(c, "c:dLbls"));
 	if (!dLbls) return [];
@@ -375,11 +519,14 @@ function cachedTitleText(title) {
 	const tx = poChildren(title).find((c) => poIs(c, "c:tx"));
 	const ref = tx ? poChildren(tx).find((c) => poIs(c, "c:strRef")) : void 0;
 	if (!ref) return void 0;
-	const cached = denseStrings(ref).filter((t) => t.length > 0);
+	const cached = denseStrings(ref, MOST_CHART_POINTS).filter((t) => t.length > 0);
 	return cached.length > 0 ? cached.join(" ") : void 0;
 }
 function axisTitle(plotArea, axTag) {
-	const ax = poChildren(plotArea).find((c) => poIs(c, axTag));
+	return axisTitleOf(poChildren(plotArea).find((c) => poIs(c, axTag)));
+}
+/** An axis node's own `c:title` text. */
+function axisTitleOf(ax) {
 	const title = ax ? poChildren(ax).find((c) => poIs(c, "c:title")) : void 0;
 	if (!title) return void 0;
 	return collectAT(title) || cachedTitleText(title) || "Axis Title";
@@ -411,15 +558,19 @@ function axisOrientation(ax) {
 	const scaling = ax ? poChildren(ax).find((c) => poIs(c, "c:scaling")) : void 0;
 	return scaling ? poVal(poChildren(scaling).find((c) => poIs(c, "c:orientation"))) : void 0;
 }
-/** §21.2.2.98 `c:valAx/c:majorUnit` — a positive step, or undefined for "auto". */
+/** §21.2.2.103 `c:valAx/c:majorUnit` — a positive step, or undefined for "auto". */
 function majorUnitOf(plotArea) {
-	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	return majorUnitOfAxis(poChildren(plotArea).find((c) => poIs(c, "c:valAx")));
+}
+function majorUnitOfAxis(ax) {
 	const node = ax ? poChildren(ax).find((c) => poIs(c, "c:majorUnit")) : void 0;
 	const v = node ? Number(poAttr(node, "val")) : NaN;
 	return Number.isFinite(v) && v > 0 ? v : void 0;
 }
 function axisScaling(plotArea, tag) {
-	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	return axisScalingOf(poChildren(plotArea).find((c) => poIs(c, "c:valAx")), tag);
+}
+function axisScalingOf(ax, tag) {
 	const scaling = ax ? poChildren(ax).find((c) => poIs(c, "c:scaling")) : void 0;
 	const node = scaling ? poChildren(scaling).find((c) => poIs(c, tag)) : void 0;
 	const v = node ? Number(poAttr(node, "val")) : NaN;
@@ -436,7 +587,7 @@ function axisScaling(plotArea, tag) {
 * @param resolveColor Maps a DrawingML colour reference to 6 hex digits.
 * @returns The rule, or undefined when the node says nothing about it.
 */
-var DASHES = new Set([
+var DASHES = /* @__PURE__ */ new Set([
 	"solid",
 	"dot",
 	"dash",
@@ -446,6 +597,30 @@ var DASHES = new Set([
 	"sysDash",
 	"sysDot"
 ]);
+/** A 3-D chart's wall or floor: what its `c:spPr` fills and rules it with. */
+function surfaceOf(node, resolveColor) {
+	const spPr = node ? poChildren(node).find((c) => poIs(c, "c:spPr")) : void 0;
+	if (!spPr) return void 0;
+	const fillHex = frameFillOf(spPr, resolveColor);
+	const line = lineStyleOf(node, resolveColor);
+	return {
+		...fillHex ? { fillHex } : {},
+		...line ? { line } : {}
+	};
+}
+/** §21.2.2.40 — whether the author deleted an axis. */
+function isDeletedAxis(ax) {
+	const del = ax ? poVal(poChildren(ax).find((c) => poIs(c, "c:delete"))) : void 0;
+	return del === "1" || del === "true";
+}
+/**
+* §21.2.2.100 — an axis's major gridlines: their rule, the default one where
+* they state none (undefined), and none at all where the axis has none.
+*/
+function gridlinesOf(ax, resolveColor) {
+	const grid = ax ? poChildren(ax).find((c) => poIs(c, "c:majorGridlines")) : void 0;
+	return grid ? lineStyleOf(grid, resolveColor) : { none: true };
+}
 function lineStyleOf(owner, resolveColor) {
 	const spPr = owner ? poChildren(owner).find((c) => poIs(c, "c:spPr")) : void 0;
 	const ln = spPr ? poChildren(spPr).find((c) => poIs(c, "a:ln")) : void 0;
@@ -466,7 +641,9 @@ function lineStyleOf(owner, resolveColor) {
 	};
 }
 function valueFormatCode(plotArea) {
-	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	return formatCodeOf(poChildren(plotArea).find((c) => poIs(c, "c:valAx")));
+}
+function formatCodeOf(ax) {
 	const numFmt = ax ? poChildren(ax).find((c) => poIs(c, "c:numFmt")) : void 0;
 	const code = numFmt ? poAttr(numFmt, "formatCode") : void 0;
 	if (code === void 0 || code.trim().length === 0) return void 0;
@@ -477,6 +654,107 @@ function dLblsShowVal(dLbls) {
 	const v = poVal(poChildren(dLbls).find((c) => poIs(c, "c:showVal")));
 	return v === "1" || v === "true";
 }
+/**
+* §21.2.2.49 — what a chart's data labels show: its group's `c:dLbls` with the
+* first series' own over it. `c:delete` shows nothing; a chart with no
+* `c:dLbls` anywhere has no labels, which is not a chart that shows its
+* percentages — Excel prints nothing on such a pie.
+*
+* @param group     The chart group (`c:pieChart`, …).
+* @param firstSer  Its first series.
+* @returns The switches, or undefined for a chart without data labels.
+*/
+function dataLabelsOf(group, firstSer) {
+	const own = (owner) => owner ? poChildren(owner).find((c) => poIs(c, "c:dLbls")) : void 0;
+	const groupLabels = own(group);
+	const seriesLabels = own(firstSer);
+	if (!groupLabels && !seriesLabels) return void 0;
+	const read = (dLbls) => {
+		if (!dLbls) return {};
+		const kids = poChildren(dLbls);
+		const deleted = poVal(kids.find((c) => poIs(c, "c:delete")));
+		if (deleted === "1" || deleted === "true") return {
+			showVal: false,
+			showCatName: false,
+			showSerName: false,
+			showPercent: false
+		};
+		const flag = (tag) => {
+			const v = poVal(kids.find((c) => poIs(c, tag)));
+			return v === void 0 ? {} : { [tag.slice(2)]: v === "1" || v === "true" };
+		};
+		const separatorNode = kids.find((c) => poIs(c, "c:separator"));
+		const numFmt = kids.find((c) => poIs(c, "c:numFmt"));
+		const code = numFmt ? poAttr(numFmt, "formatCode") : void 0;
+		const linked = numFmt ? poAttr(numFmt, "sourceLinked") : void 0;
+		const position = labelPosition(kids);
+		return {
+			...flag("c:showVal"),
+			...flag("c:showCatName"),
+			...flag("c:showSerName"),
+			...flag("c:showPercent"),
+			...flag("c:showLeaderLines"),
+			...position ? { position } : {},
+			...separatorNode ? { separator: poText(separatorNode) } : {},
+			...code && code.trim() !== "" && code.trim().toLowerCase() !== "general" && linked !== "1" ? { numberFormat: code } : {}
+		};
+	};
+	return {
+		...read(groupLabels),
+		...read(seriesLabels)
+	};
+}
+var LABEL_POSITIONS = /* @__PURE__ */ new Set([
+	"bestFit",
+	"b",
+	"ctr",
+	"inBase",
+	"inEnd",
+	"l",
+	"outEnd",
+	"r",
+	"t"
+]);
+/** §21.2.2.48 — a label's `c:dLblPos` among its siblings, when it states one. */
+function labelPosition(kids) {
+	const v = poVal(kids.find((c) => poIs(c, "c:dLblPos")));
+	return v !== void 0 && LABEL_POSITIONS.has(v) ? v : void 0;
+}
+/**
+* §21.2.2.47 — where each point's own label stands, for the points that say:
+* their `c:dLblPos`, and the `c:manualLayout` an author dragged them to
+* (45544.xlsx sets every one of its slices' names out by hand).
+*/
+function labelPlacements(ser) {
+	const dLbls = poChildren(ser).find((c) => poIs(c, "c:dLbls"));
+	if (!dLbls) return [];
+	const out = [];
+	for (const dLbl of poChildren(dLbls)) {
+		if (!poIs(dLbl, "c:dLbl")) continue;
+		const kids = poChildren(dLbl);
+		const idx = poIntAttr(kids.find((c) => poIs(c, "c:idx")), "val") ?? 0;
+		const position = labelPosition(kids);
+		const layout = kids.find((c) => poIs(c, "c:layout"));
+		const manual = layout ? poChildren(layout).find((c) => poIs(c, "c:manualLayout")) : void 0;
+		const num = (tag) => {
+			const v = Number(poVal(manual ? poChildren(manual).find((c) => poIs(c, tag)) : void 0));
+			return Number.isFinite(v) ? v : void 0;
+		};
+		const x = num("c:x");
+		const y = num("c:y");
+		const mode = (tag) => poVal(manual ? poChildren(manual).find((c) => poIs(c, tag)) : void 0);
+		const edge = mode("c:xMode") === "edge" && mode("c:yMode") === "edge";
+		if (position === void 0 && x === void 0 && y === void 0) continue;
+		out.push({
+			idx,
+			...position ? { position } : {},
+			...x !== void 0 ? { x } : {},
+			...y !== void 0 ? { y } : {},
+			...edge ? { edge: true } : {}
+		});
+	}
+	return out;
+}
 function chartShowsValues(group) {
 	if (dLblsShowVal(poChildren(group).find((c) => poIs(c, "c:dLbls")))) return true;
 	for (const ser of poChildren(group)) if (poIs(ser, "c:ser") && dLblsShowVal(poChildren(ser).find((c) => poIs(c, "c:dLbls")))) return true;
@@ -509,24 +787,36 @@ function ptCountOf(container) {
 	const pc = cache ? poChildren(cache).find((c) => poIs(c, "c:ptCount")) : void 0;
 	return pc ? poIntAttr(pc, "val") ?? 0 : 0;
 }
-function denseLength(container, pts) {
-	let max = ptCountOf(container);
-	for (const p of pts) max = Math.max(max, p.idx + 1);
-	return max;
+/** Whether `n` can index a point: a whole number from zero. */
+var isPointIndex = (n) => Number.isInteger(n) && n >= 0;
+/**
+* How many slots `count` points and those at `indexes` take — the count, or
+* past it the last of them, and never more than `most`. A count or an index
+* that is no whole number (2.5) asked for an array of no possible length and
+* threw; it counts for nothing.
+*/
+function denseLength(count, indexes, most) {
+	let length = isPointIndex(count) ? count : 0;
+	for (const idx of indexes) if (isPointIndex(idx)) length = Math.max(length, idx + 1);
+	return Math.min(length, most);
 }
-function denseNumbers(container) {
+/** A cache's values by point index, gaps 0, at most `most` of them. */
+function denseNumbers(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill(0);
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill(0);
 	for (const p of pts) {
 		const n = Number(p.v);
-		if (Number.isFinite(n)) arr[p.idx] = n;
+		if (Number.isFinite(n) && isPointIndex(p.idx) && p.idx < length) arr[p.idx] = n;
 	}
 	return arr;
 }
-function denseStrings(container) {
+/** A cache's texts by point index, gaps empty, at most `most` of them. */
+function denseStrings(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill("");
-	for (const p of pts) arr[p.idx] = p.v;
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill("");
+	for (const p of pts) if (isPointIndex(p.idx) && p.idx < length) arr[p.idx] = p.v;
 	return arr;
 }
 /**
@@ -537,11 +827,12 @@ function denseStrings(container) {
 * names, both columns of them in turn: WithChartSheet.xlsx's six bars stood in
 * the first six of sixteen slots under a jumble of years and measure names.
 *
-* @param cat The `c:cat` element.
+* @param cat  The `c:cat` element.
+* @param most The most categories it keeps (see {@link pointsPerSeries}).
 * @returns The innermost labels and the outer levels' groups, or undefined
 *   for a category axis of one level.
 */
-function multiLevelCategories(cat) {
+function multiLevelCategories(cat, most) {
 	const cache = poFindDescendant(cat, "c:multiLvlStrCache");
 	if (!cache) return void 0;
 	const count = poIntAttr(poChildren(cache).find((c) => poIs(c, "c:ptCount")) ?? cache, "val") ?? 0;
@@ -553,11 +844,13 @@ function multiLevelCategories(cat) {
 		};
 	}));
 	if (!inner) return void 0;
-	const categories = new Array(Math.max(count, ...inner.map((p) => p.start + 1))).fill("");
-	for (const p of inner) categories[p.start] = p.label;
+	const length = denseLength(count, inner.map((p) => p.start), most);
+	const categories = new Array(length).fill("");
+	const kept = (p) => isPointIndex(p.start) && p.start < length;
+	for (const p of inner) if (kept(p)) categories[p.start] = p.label;
 	return {
 		categories,
-		groups: outer.map((level) => [...level].sort((a, b) => a.start - b.start))
+		groups: outer.map((level) => level.filter(kept).sort((a, b) => a.start - b.start))
 	};
 }
 function isLegendPos(v) {
@@ -626,7 +919,7 @@ var ACCENT_SLOTS = [
 	"accent5",
 	"accent6"
 ];
-var SCATTER_STYLES = new Set([
+var SCATTER_STYLES = /* @__PURE__ */ new Set([
 	"none",
 	"line",
 	"lineMarker",
@@ -636,4 +929,4 @@ var SCATTER_STYLES = new Set([
 ]);
 var REL_CHART_COLOR_STYLE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 //#endregion
-export { parseChart, withChartColorStyle };
+export { MOST_CHART_POINTS, parseChart, parseChartColorStyle, pointsPerSeries, withChartColorStyle };

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

@@ -0,0 +1,41 @@
+import { PoNode } from '../po-helpers.js';
+import { ChartTextStyles } from '../document-model/index.js';
+import { ColorResolver } from './colors.js';
+import { ThemeFonts } from './theme-parser.js';
+/**
+ * What a host application sets the chart text a chart leaves unsaid in.
+ * Passing it asks for the text to be resolved at all; without it a chart
+ * carries no {@link ChartTextStyles} and the renderer keeps its own defaults.
+ */
+export interface ChartTextDefaults {
+    /** The theme's font scheme — what `+mn-lt` and `+mj-lt` stand for. */
+    readonly themeFonts?: ThemeFonts;
+    /** The family of text no run names. */
+    readonly family?: string;
+}
+/** Excel's size for chart text no run sizes. */
+export declare const EXCEL_CHART_TEXT_PT = 10;
+/** The nodes each role's own text properties hang from. */
+export interface ChartTextNodes {
+    readonly chartSpace?: PoNode;
+    readonly title?: PoNode;
+    readonly legend?: PoNode;
+    readonly catAxis?: PoNode;
+    readonly valAxis?: PoNode;
+    readonly secondaryValAxis?: PoNode;
+    /** `c:dLbls` — the first series' own, else its group's. */
+    readonly dataLabels?: PoNode;
+}
+/** Reads an `a:solidFill` as a chart reads it, to RRGGBB. */
+export type ChartFillReader = (solidFill: PoNode) => string | undefined;
+/**
+ * Resolve a chart's text, role by role: the element's own run properties over
+ * the chart's over the host's defaults.
+ *
+ * @param nodes        Where each role's properties hang.
+ * @param resolveColor Maps a colour reference to RRGGBB — the default text colour.
+ * @param readFill     Reads a run's `a:solidFill`.
+ * @param defaults     The host's defaults and theme fonts.
+ * @returns Every role, resolved.
+ */
+export declare function chartTextStyles(nodes: ChartTextNodes, resolveColor: ColorResolver, readFill: ChartFillReader, defaults: ChartTextDefaults): ChartTextStyles;