reamkit 1.32.1 → 1.33.0

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

@@ -2,6 +2,7 @@ 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
@@ -32,9 +33,12 @@ export declare function pointsPerSeries(seriesCount: number): number;
  *
  * @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
@@ -56,9 +57,12 @@ function pointsPerSeries(seriesCount) {
 *
 * @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;
@@ -110,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);
@@ -140,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 } : {},
@@ -160,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 } : {},
@@ -174,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 } : {},
@@ -187,6 +255,10 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...numberFormat ? { numberFormat } : {}
 	};
 }
+/** `{ [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, most) : [];
@@ -196,6 +268,16 @@ function parseSeries(ser, resolveColor, most) {
 	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;
@@ -209,11 +291,14 @@ function parseSeries(ser, resolveColor, most) {
 		...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",
@@ -252,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 [];
@@ -401,7 +523,10 @@ function cachedTitleText(title) {
 	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";
@@ -433,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;
@@ -458,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",
@@ -468,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;
@@ -488,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;
@@ -499,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;
@@ -663,7 +919,7 @@ var ACCENT_SLOTS = [
 	"accent5",
 	"accent6"
 ];
-var SCATTER_STYLES = new Set([
+var SCATTER_STYLES = /* @__PURE__ */ new Set([
 	"none",
 	"line",
 	"lineMarker",
@@ -673,4 +929,4 @@ var SCATTER_STYLES = new Set([
 ]);
 var REL_CHART_COLOR_STYLE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 //#endregion
-export { parseChart, pointsPerSeries, 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;

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

@@ -0,0 +1,93 @@
+import { poAttr, poChildren, poIs } from "../po-helpers.js";
+import { resolveThemeFont } from "./theme-parser.js";
+/**
+* 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.
+*/
+function chartTextStyles(nodes, resolveColor, readFill, defaults) {
+	const ctx = {
+		readFill,
+		fonts: defaults.themeFonts
+	};
+	const space = {
+		...defaults.family ? { family: defaults.family } : {},
+		sizePt: 10,
+		colorHex: resolveColor({ scheme: "tx1" }) ?? "000000",
+		...bodyStyle(child(nodes.chartSpace, "c:txPr"), ctx)
+	};
+	const titled = {
+		...space,
+		bold: space.bold ?? true
+	};
+	const ofTitle = (title) => ({
+		...titled,
+		...titleStyle(title, ctx)
+	});
+	const ofText = (node) => ({
+		...space,
+		...bodyStyle(child(node, "c:txPr"), ctx)
+	});
+	return {
+		title: ofTitle(nodes.title),
+		legend: ofText(nodes.legend),
+		catAxis: ofText(nodes.catAxis),
+		valAxis: ofText(nodes.valAxis),
+		secondaryValAxis: ofText(nodes.secondaryValAxis ?? nodes.valAxis),
+		catAxisTitle: ofTitle(child(nodes.catAxis, "c:title")),
+		valAxisTitle: ofTitle(child(nodes.valAxis, "c:title")),
+		secondaryValAxisTitle: ofTitle(child(nodes.secondaryValAxis, "c:title")),
+		dataLabels: ofText(nodes.dataLabels)
+	};
+}
+/**
+* A title's text: its `c:txPr`, then the rich text's paragraph defaults, then
+* the first run's own properties — Excel keeps one style for a whole title.
+*/
+function titleStyle(title, ctx) {
+	if (!title) return {};
+	const rich = child(child(title, "c:tx"), "c:rich");
+	const firstRun = rich ? poChildren(rich).filter((c) => poIs(c, "a:p")).flatMap((p) => poChildren(p)).find((c) => poIs(c, "a:r")) : void 0;
+	return {
+		...bodyStyle(child(title, "c:txPr"), ctx),
+		...bodyStyle(rich, ctx),
+		...runStyle(child(firstRun, "a:rPr"), ctx)
+	};
+}
+/** A text body's paragraph defaults — the first paragraph's `a:pPr/a:defRPr`. */
+function bodyStyle(body, ctx) {
+	return runStyle(child(child(body ? poChildren(body).find((c) => poIs(c, "a:p")) : void 0, "a:pPr"), "a:defRPr"), ctx);
+}
+/** §21.1.2.3.2 — one run-property node, read for what it states. */
+function runStyle(node, ctx) {
+	if (!node) return {};
+	const size = Number(poAttr(node, "sz") ?? NaN);
+	const bold = flag(poAttr(node, "b"));
+	const italic = flag(poAttr(node, "i"));
+	const typeface = poAttr(child(node, "a:latin"), "typeface")?.trim();
+	const family = typeface ? resolveThemeFont(typeface, ctx.fonts) : void 0;
+	const fill = child(node, "a:solidFill");
+	const colorHex = fill ? ctx.readFill(fill) : void 0;
+	return {
+		...family ? { family } : {},
+		...Number.isFinite(size) && size >= 100 ? { sizePt: size / 100 } : {},
+		...bold !== void 0 ? { bold } : {},
+		...italic !== void 0 ? { italic } : {},
+		...colorHex ? { colorHex } : {}
+	};
+}
+/** xsd:boolean, as an attribute states it. */
+function flag(value) {
+	if (value === "1" || value === "true") return true;
+	if (value === "0" || value === "false") return false;
+}
+function child(node, tag) {
+	return node ? poChildren(node).find((c) => poIs(c, tag)) : void 0;
+}
+//#endregion
+export { chartTextStyles };

package/dist/esm/core/drawingml/colors.js

@@ -134,7 +134,7 @@ function applyColorMods(hex, mods) {
 * Office 2013 default theme palette — the colours Word assigns to the standard
 * scheme slots when a document carries no custom theme part.
 */
-var DEFAULT_THEME_PALETTE = new Map([
+var DEFAULT_THEME_PALETTE = /* @__PURE__ */ new Map([
 	["dk1", "000000"],
 	["lt1", "FFFFFF"],
 	["dk2", "44546A"],
@@ -153,7 +153,7 @@ var DEFAULT_THEME_PALETTE = new Map([
 * no theme part with. Its own PDF of theme slots 0…9 in such a workbook
 * (2026-10-01) paints exactly these: accent1 is 156082, not 2013's 4472C4.
 */
-var OFFICE_2023_THEME_PALETTE = new Map([
+var OFFICE_2023_THEME_PALETTE = /* @__PURE__ */ new Map([
 	["dk1", "000000"],
 	["lt1", "FFFFFF"],
 	["dk2", "0E2841"],
@@ -217,7 +217,7 @@ function placeholderColors(base, phHex) {
 }
 /** A {@link ColorResolver} backed by the {@link DEFAULT_THEME_PALETTE}. */
 var defaultColorResolver = makeColorResolver(DEFAULT_THEME_PALETTE);
-var PRESET_COLORS = new Map([
+var PRESET_COLORS = /* @__PURE__ */ new Map([
 	["black", "000000"],
 	["white", "FFFFFF"],
 	["gray", "808080"],
@@ -280,7 +280,7 @@ function readColorMods(colorNode) {
 * what a reader uses; the two names that matter without one are the window
 * background and its text.
 */
-var SYSTEM_COLORS = new Map([
+var SYSTEM_COLORS = /* @__PURE__ */ new Map([
 	["window", "FFFFFF"],
 	["windowText", "000000"],
 	["windowFrame", "000000"],
@@ -325,4 +325,4 @@ function resolveColorNode(c, resolveColor) {
 	} : raw);
 }
 //#endregion
-export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, OFFICE_2023_THEME_PALETTE, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode };
+export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, OFFICE_2023_THEME_PALETTE, applyColorMods, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode, resolveSchemeName };

package/dist/esm/core/drawingml/diagram/layout-engine.js

@@ -376,10 +376,7 @@ function rectIn(constrs, name, box, placed, fontEmu = 0, outer = []) {
 			case "ctrX":
 				x = box.x + v - cx / 2;
 				break;
-			case "ctrY":
-				y = box.y + v - cy / 2;
-				break;
-			default: break;
+			case "ctrY": y = box.y + v - cy / 2;
 		}
 	}
 	return {

package/dist/esm/core/drawingml/diagram/run.js

@@ -40,7 +40,8 @@ function laidOutDiagramTree(parts, frame, parse) {
 	const data = new DiagramData(parse(parts.data));
 	const nodes = layoutDiagram(parse(parts.layout), data, frame.cx, frame.cy);
 	if (nodes.length === 0) return void 0;
-	const xml = diagramDrawingXml(nodes, frame, parts.colors ? new DiagramColors(parse(parts.colors)) : void 0, data.background);
+	const colors = parts.colors ? new DiagramColors(parse(parts.colors)) : void 0;
+	const xml = diagramDrawingXml(nodes, frame, colors, data.background);
 	for (const root of parse(new TextEncoder().encode(xml))) {
 		const found = poFindDescendant(root, "dsp:spTree");
 		if (found) return found;