reamkit 1.15.4 → 1.16.0

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

@@ -4,6 +4,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/core/drawingml/chart-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	preserveOrder: true,
@@ -37,35 +38,85 @@ var TYPE_OF_TAG = {
 * @returns The parsed chart, or `null` when there is no `c:chart` / `c:plotArea`.
 */
 function parseChart(chartXml, resolveColor) {
-	const chart = poFindByPath(parser.parse(decoder.decode(chartXml)), ["c:chartSpace", "c:chart"]);
+	const tree = parser.parse(decoder.decode(chartXml));
+	const chart = poFindByPath(tree, ["c:chartSpace", "c:chart"]);
 	if (!chart) return null;
 	const plotArea = poChildren(chart).find((c) => poIs(c, "c:plotArea"));
 	if (!plotArea) return null;
-	const group = poChildren(plotArea).find((c) => (poTag(c) ?? "") in TYPE_OF_TAG);
+	const groups = poChildren(plotArea).filter((c) => (poTag(c) ?? "") in TYPE_OF_TAG);
+	const group = groups[0];
 	const type = group ? TYPE_OF_TAG[poTag(group)] ?? "unknown" : "unknown";
-	const serNodes = group ? poChildren(group).filter((c) => poIs(c, "c:ser")) : [];
-	const series = serNodes.map((s) => parseSeries(s, resolveColor));
+	const groupAxIds = (g) => poChildren(g).filter((c) => poIs(c, "c:axId")).map((c) => poAttr(c, "val") ?? "");
+	const primaryAxIds = new Set(group ? groupAxIds(group) : []);
+	const serNodes = [];
+	const series = [];
+	let secondaryValAxId;
+	for (const g of groups) {
+		const groupType = TYPE_OF_TAG[poTag(g)] ?? "unknown";
+		const own = groupAxIds(g).filter((id) => !primaryAxIds.has(id));
+		const secondary = own.length > 0;
+		for (const s of poChildren(g).filter((c) => poIs(c, "c:ser"))) {
+			serNodes.push(s);
+			series.push({
+				...parseSeries(s, resolveColor),
+				...groupType === type ? {} : { type: groupType },
+				...secondary ? { secondaryAxis: true } : {}
+			});
+		}
+		if (secondary && series.length > 0) secondaryValAxId ??= own.find((id) => poChildren(plotArea).some((c) => poIs(c, "c:valAx") && poChildren(c).some((k) => poIs(k, "c:axId") && poAttr(k, "val") === id)));
+	}
+	const secondaryValAx = secondaryValAxId ? poChildren(plotArea).find((c) => poIs(c, "c:valAx") && poChildren(c).some((k) => poIs(k, "c:axId") && poAttr(k, "val") === secondaryValAxId)) : void 0;
+	const secondaryDeleted = secondaryValAx !== void 0 && poChildren(secondaryValAx).some((c) => poIs(c, "c:delete") && poAttr(c, "val") === "1");
+	const secondaryTitleNode = secondaryValAx && !secondaryDeleted ? poChildren(secondaryValAx).find((c) => poIs(c, "c:title")) : void 0;
+	const secondaryValAxisTitle = secondaryTitleNode ? collectAT(secondaryTitleNode) || "Axis Title" : void 0;
 	let categories = [];
+	let categoriesRef;
 	for (const s of serNodes) {
 		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
 		if (cat) {
 			categories = denseStrings(cat);
+			categoriesRef ??= refFormula(cat);
 			break;
 		}
 	}
+	const scatterStyleRaw = group ? poVal(poChildren(group).find((c) => poIs(c, "c:scatterStyle"))) : void 0;
+	const scatterStyle = SCATTER_STYLES.has(scatterStyleRaw ?? "") ? scatterStyleRaw : void 0;
+	const lineMarkers = group && poIs(group, "c:lineChart") ? poVal(poChildren(group).find((c) => poIs(c, "c:marker"))) === "1" : false;
 	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 showValues = group ? chartShowsValues(group) : false;
 	const catAxisTitle = axisTitle(plotArea, "c:catAx");
 	const valAxisTitle = axisTitle(plotArea, "c:valAx");
+	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 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 catAxisReversed = axisOrientation(catAxNode) === "maxMin";
+	const spaceSpPr = poChildren(tree.find((c) => poIs(c, "c:chartSpace"))).find((c) => poIs(c, "c:spPr"));
+	const frameFillHex = fillColorOf(spaceSpPr, resolveColor);
+	const frameLine = spaceSpPr ? poChildren(spaceSpPr).find((c) => poIs(c, "a:ln")) : void 0;
+	const frameLineHex = frameLine ? fillColorOf(frameLine, resolveColor) : void 0;
+	const numberFormat = 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 title = chartTitle(chart);
+	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);
 	return {
 		type,
 		...title ? { title } : {},
+		...Number.isFinite(gapPercent) && gapPercent >= 0 ? { gapPercent } : {},
 		categories,
+		...categoriesRef ? { categoriesRef } : {},
 		series,
 		hasLegend: legend !== void 0,
 		...isLegendPos(legendPos) ? { legendPos } : {},
@@ -74,7 +125,20 @@ function parseChart(chartXml, resolveColor) {
 		...doughnut ? { doughnut: true } : {},
 		...showValues ? { showValues: true } : {},
 		...catAxisTitle ? { catAxisTitle } : {},
-		...valAxisTitle ? { valAxisTitle } : {}
+		...catAxisReversed ? { catAxisReversed } : {},
+		...valAxisTitle ? { valAxisTitle } : {},
+		...secondaryValAxisTitle ? { secondaryValAxisTitle } : {},
+		...scatterStyle ? { scatterStyle } : {},
+		...lineMarkers ? { lineMarkers: true } : {},
+		...catAxisLine ? { catAxisLine } : {},
+		...valAxisLine ? { valAxisLine } : {},
+		...secondaryValAxisLine ? { secondaryValAxisLine } : {},
+		...gridLine ? { gridLine } : {},
+		...valAxisMin !== void 0 ? { valAxisMin } : {},
+		...valAxisMax !== void 0 ? { valAxisMax } : {},
+		...frameFillHex ? { frameFillHex } : {},
+		...frameLineHex ? { frameLineHex } : {},
+		...numberFormat ? { numberFormat } : {}
 	};
 }
 function parseSeries(ser, resolveColor) {
@@ -85,12 +149,49 @@ function parseSeries(ser, resolveColor) {
 	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 marker = seriesMarker(ser);
+	const line = lineStyleOf(ser, resolveColor);
+	const valuesRef = valNode ? refFormula(valNode) : void 0;
+	const nameRef = refFormula(poChildren(ser).find((c) => poIs(c, "c:tx")));
 	return {
 		values,
+		...valuesRef ? { valuesRef } : {},
+		...nameRef ? { nameRef } : {},
 		...xValues && xValues.length > 0 ? { xValues } : {},
 		...name ? { name } : {},
 		...colorHex ? { colorHex } : {},
-		...pointColors.length > 0 ? { pointColors } : {}
+		...pointColors.length > 0 ? { pointColors } : {},
+		...pointLabels.length > 0 ? { pointLabels } : {},
+		...marker ? { marker } : {},
+		...line ? { line } : {}
+	};
+}
+var MARKER_SYMBOLS = new Set([
+	"circle",
+	"dash",
+	"diamond",
+	"dot",
+	"none",
+	"plus",
+	"square",
+	"star",
+	"triangle",
+	"x"
+]);
+/**
+* §21.2.2.106 `c:marker` — the series' own point symbol. `auto` (and the
+* picture marker we cannot draw) read as absent, leaving the reader's default.
+*/
+function seriesMarker(ser) {
+	const node = poChildren(ser).find((c) => poIs(c, "c:marker"));
+	if (!node) return void 0;
+	const symbol = poVal(poChildren(node).find((c) => poIs(c, "c:symbol")));
+	if (!symbol || !MARKER_SYMBOLS.has(symbol)) return void 0;
+	const sizePt = poIntAttr(poChildren(node).find((c) => poIs(c, "c:size")), "val");
+	return {
+		symbol,
+		...sizePt !== void 0 && sizePt > 0 ? { sizePt } : {}
 	};
 }
 function seriesName(ser) {
@@ -100,6 +201,29 @@ function seriesName(ser) {
 	if (direct) return poText(direct) || void 0;
 	return readPts(tx)[0]?.v || void 0;
 }
+/**
+* §21.2.2.49 — the labels the author typed, by point index. A `<c:dLbl>` with
+* 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.
+*/
+function customDataLabels(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 idxNode = poChildren(dLbl).find((c) => poIs(c, "c:idx"));
+		const tx = poChildren(dLbl).find((c) => poIs(c, "c:tx"));
+		if (!tx) continue;
+		const text = collectAT(tx).trim();
+		if (text.length === 0) continue;
+		out.push({
+			idx: idxNode ? poIntAttr(idxNode, "val") ?? 0 : 0,
+			text
+		});
+	}
+	return out;
+}
 function dataPointColors(ser, resolveColor) {
 	const out = [];
 	for (const dPt of poChildren(ser)) {
@@ -119,6 +243,10 @@ function fillColorOf(spPr, resolveColor) {
 	const directFill = poChildren(spPr).find((c) => poIs(c, "a:solidFill"));
 	const fromFill = directFill ? colorFromSolidFill(directFill, resolveColor) : void 0;
 	if (fromFill) return fromFill;
+	const grad = poChildren(spPr).find((c) => poIs(c, "a:gradFill"));
+	const firstStop = grad ? poChildren(grad).filter((c) => poIs(c, "a:gsLst")).flatMap((lst) => poChildren(lst)).find((gs) => poIs(gs, "a:gs")) : void 0;
+	const fromGrad = firstStop ? colorFromSolidFill(firstStop, resolveColor) : void 0;
+	if (fromGrad) return fromGrad;
 	const ln = poChildren(spPr).find((c) => poIs(c, "a:ln"));
 	const lnFill = ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0;
 	return lnFill ? colorFromSolidFill(lnFill, resolveColor) : void 0;
@@ -139,14 +267,109 @@ function collectAT(node) {
 	walk(node);
 	return text;
 }
-function chartTitle(chart) {
+/**
+* §21.2.2.213 `c:title` — the chart's title, authored or generated.
+*
+* `c:tx` is OPTIONAL: a `<c:title>` with none asks the application to make the
+* title up, and §21.2.2.10's `c:autoTitleDeleted val="0"` says that generated
+* title has not been removed. Excel and LibreOffice agree on the rule — one
+* series means the series' name, anything else the placeholder "Chart Title" —
+* and reading only the `a:t` runs gave 56557.xlsx a blank page where the
+* reference draws its title. Eleven chart parts across eight corpus files are
+* written this way.
+*
+* The placeholder is an application string and therefore a locale: this file
+* was authored in Swedish, where Excel prints "Diagramrubrik". English is what
+* both references print here, and what we have to pick.
+*
+* @param chart  The `c:chart` element.
+* @param series The chart's series, for the single-series case.
+* @returns The title text, or undefined when there is no title to draw.
+*/
+function chartTitle(chart, series) {
 	const title = poChildren(chart).find((c) => poIs(c, "c:title"));
-	return title ? collectAT(title) || void 0 : void 0;
+	if (!title) return void 0;
+	const authored = collectAT(title) || cachedTitleText(title);
+	if (authored) return authored;
+	if (poVal(poChildren(chart).find((c) => poIs(c, "c:autoTitleDeleted"))) === "1") return void 0;
+	return (series.length === 1 ? series[0]?.name : void 0) ?? "Chart Title";
+}
+/**
+* §21.2.2.215 — a title the author gave as a FORMULA: `c:tx/c:strRef` with the
+* text in its `c:strCache`, and not one `a:t` run anywhere. Read for rich text
+* alone, such a title came out as the generated placeholder —
+* chartTitle_withTitleFormula.xlsx printed "Chart Title" where both references
+* print "Formula Title from Excel 2016".
+*
+* @param title The `c:title` node.
+* @returns The cached text, or undefined when the title carries no cache.
+*/
+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);
+	return cached.length > 0 ? cached.join(" ") : void 0;
 }
 function axisTitle(plotArea, axTag) {
 	const ax = poChildren(plotArea).find((c) => poIs(c, axTag));
 	const title = ax ? poChildren(ax).find((c) => poIs(c, "c:title")) : void 0;
-	return title ? collectAT(title) || void 0 : void 0;
+	if (!title) return void 0;
+	return collectAT(title) || cachedTitleText(title) || "Axis Title";
+}
+/**
+* §21.2.2.121 `c:numFmt` on the value axis — the number format its tick labels
+* and the chart's data labels are drawn in. It is the same code grammar cells
+* use (§18.8.31), so a currency axis reads as currency: without it a monthly
+* budget's axis ran 0/1000/2000 where every other reader shows $0/$1,000/$2,000.
+*
+* `sourceLinked="1"` means "whatever the source cells use", which the chart part
+* does not carry — those keep the plain numeric render.
+*/
+/** §21.2.2.134 `c:scaling/c:orientation` — `minMax` (the default) or `maxMin`. */
+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;
+}
+function axisScaling(plotArea, tag) {
+	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	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;
+	return Number.isFinite(v) ? v : void 0;
+}
+/**
+* §21.2.2.196 `c:spPr/a:ln` — an axis's (or a series') own rule.
+* `<a:ln><a:noFill/>` means it draws nothing, which is not the same as having
+* no `c:spPr` at all: the first hides the line, the second leaves it to the
+* renderer's default.
+*
+* @param owner        The `c:catAx` / `c:valAx` / `c:majorGridlines` / `c:ser`
+*                     node.
+* @param resolveColor Maps a DrawingML colour reference to 6 hex digits.
+* @returns The rule, or undefined when the node says nothing about it.
+*/
+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;
+	if (!ln) return void 0;
+	if (poChildren(ln).some((c) => poIs(c, "a:noFill"))) return { none: true };
+	const solid = poChildren(ln).find((c) => poIs(c, "a:solidFill"));
+	const colorHex = solid ? colorFromSolidFill(solid, resolveColor) : void 0;
+	const emu = Number(poAttr(ln, "w"));
+	const widthPt = Number.isFinite(emu) && emu > 0 ? emu / 12700 : void 0;
+	if (!colorHex && widthPt === void 0) return void 0;
+	return {
+		...colorHex ? { colorHex } : {},
+		...widthPt !== void 0 ? { widthPt } : {}
+	};
+}
+function valueFormatCode(plotArea) {
+	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	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;
+	return code.trim().toLowerCase() === "general" ? void 0 : code;
 }
 function dLblsShowVal(dLbls) {
 	if (!dLbls) return false;
@@ -158,6 +381,13 @@ function chartShowsValues(group) {
 	for (const ser of poChildren(group)) if (poIs(ser, "c:ser") && dLblsShowVal(poChildren(ser).find((c) => poIs(c, "c:dLbls")))) return true;
 	return false;
 }
+/** The `<c:f>` inside a c:val / c:cat / c:tx, or undefined when there is none. */
+function refFormula(container) {
+	if (!container) return void 0;
+	const f = poFindDescendant(container, "c:f");
+	const text = f ? poText(f).trim() : "";
+	return text.length > 0 ? text : void 0;
+}
 function readPts(container) {
 	const cache = poFindDescendant(container, "c:numCache") ?? poFindDescendant(container, "c:strCache");
 	if (!cache) return [];
@@ -249,8 +479,29 @@ function withChartColorStyle(chart, pkg, chartPartPath, resolveColor) {
 			seriesColorCycle: cycle
 		};
 	}
-	return chart;
+	const themed = ACCENT_SLOTS.map((scheme) => resolveColor({ scheme }));
+	return themed.every((c) => c !== void 0) ? {
+		...chart,
+		seriesColorCycle: themed
+	} : chart;
 }
+/** §20.1.4.1.5 — the accent slots a chart cycles its series through. */
+var ACCENT_SLOTS = [
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6"
+];
+var SCATTER_STYLES = new Set([
+	"none",
+	"line",
+	"lineMarker",
+	"marker",
+	"smooth",
+	"smoothMarker"
+]);
 var REL_CHART_COLOR_STYLE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 //#endregion
 export { parseChart, withChartColorStyle };

package/dist/esm/core/drawingml/colors.d.ts

@@ -6,7 +6,7 @@ import { PoNode } from '../po-helpers.js';
  * (solid fills emit no transparency).
  */
 export interface ColorMod {
-    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha';
+    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha' | 'satMod' | 'hueOff' | 'satOff';
     readonly val: number;
 }
 /**
@@ -60,11 +60,11 @@ export declare const defaultColorResolver: ColorResolver;
  */
 export declare function readColorMods(colorNode: PoNode): Array<ColorMod>;
 /**
- * Resolve an `a:srgbClr` / `a:schemeClr` node to a hex string (with colour
- * transforms applied). Returns `undefined` when the node is some other element,
- * valueless, or the resolver does not know the colour. Container traversal policy
- * (stop at the first colour node vs continue past unresolved ones) stays with the
- * callers.
+ * Resolve an `a:srgbClr` / `a:schemeClr` / `a:sysClr` node to a hex string (with
+ * colour transforms applied). Returns `undefined` when the node is some other
+ * element, valueless, or the resolver does not know the colour. Container
+ * traversal policy (stop at the first colour node vs continue past unresolved
+ * ones) stays with the callers.
  *
  * @param c            The candidate colour node.
  * @param resolveColor The resolver mapping a {@link RawColor} to hex.

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

@@ -96,6 +96,15 @@ function applyColorMods(hex, mods) {
 		const [h, s, l] = rgbToHsl(r, g, b);
 		const l2 = m.kind === "lumMod" ? l * m.val : clamp01(l + m.val);
 		[r, g, b] = hslToRgb(h, s, l2);
+	} else if (m.kind === "hueOff") {
+		const [h, sat, l] = rgbToHsl(r, g, b);
+		[r, g, b] = hslToRgb(((h + m.val) % 360 + 360) % 360, sat, l);
+	} else if (m.kind === "satOff") {
+		const [h, sat, l] = rgbToHsl(r, g, b);
+		[r, g, b] = hslToRgb(h, clamp01(sat + m.val), l);
+	} else if (m.kind === "satMod") {
+		const [h, s, l] = rgbToHsl(r, g, b);
+		[r, g, b] = hslToRgb(h, clamp01(s * m.val), l);
 	}
 	const toHex = (x) => Math.round(clamp01(x) * 255).toString(16).padStart(2, "0");
 	return (toHex(r) + toHex(g) + toHex(b)).toUpperCase();
@@ -154,33 +163,64 @@ var defaultColorResolver = makeColorResolver(DEFAULT_THEME_PALETTE);
 */
 function readColorMods(colorNode) {
 	const mods = [];
-	for (const c of poChildren(colorNode)) for (const kind of [
-		"lumMod",
-		"lumOff",
-		"shade",
-		"tint",
-		"alpha"
-	]) if (poIs(c, `a:${kind}`)) {
-		const v = poIntAttr(c, "val");
-		if (v !== void 0) mods.push({
-			kind,
-			val: v / 1e5
-		});
+	for (const c of poChildren(colorNode)) {
+		for (const kind of [
+			"lumMod",
+			"lumOff",
+			"shade",
+			"tint",
+			"alpha",
+			"satMod",
+			"satOff"
+		]) if (poIs(c, `a:${kind}`)) {
+			const v = poIntAttr(c, "val");
+			if (v !== void 0) mods.push({
+				kind,
+				val: v / 1e5
+			});
+		}
+		if (poIs(c, "a:hueOff")) {
+			const v = poIntAttr(c, "val");
+			if (v !== void 0) mods.push({
+				kind: "hueOff",
+				val: v / 6e4
+			});
+		}
 	}
 	return mods;
 }
 /**
-* Resolve an `a:srgbClr` / `a:schemeClr` node to a hex string (with colour
-* transforms applied). Returns `undefined` when the node is some other element,
-* valueless, or the resolver does not know the colour. Container traversal policy
-* (stop at the first colour node vs continue past unresolved ones) stays with the
-* callers.
+* §20.1.2.3.32 `a:sysClr` — the host system's own colour. `val` names it and
+* `lastClr` carries what the producing application resolved it to, which is
+* what a reader uses; the two names that matter without one are the window
+* background and its text.
+*/
+var SYSTEM_COLORS = new Map([
+	["window", "FFFFFF"],
+	["windowText", "000000"],
+	["windowFrame", "000000"],
+	["btnText", "000000"],
+	["btnFace", "F0F0F0"],
+	["highlight", "0078D7"],
+	["highlightText", "FFFFFF"]
+]);
+/**
+* Resolve an `a:srgbClr` / `a:schemeClr` / `a:sysClr` node to a hex string (with
+* colour transforms applied). Returns `undefined` when the node is some other
+* element, valueless, or the resolver does not know the colour. Container
+* traversal policy (stop at the first colour node vs continue past unresolved
+* ones) stays with the callers.
 *
 * @param c            The candidate colour node.
 * @param resolveColor The resolver mapping a {@link RawColor} to hex.
 * @returns The resolved RRGGBB, or `undefined`.
 */
 function resolveColorNode(c, resolveColor) {
+	if (poIs(c, "a:sysClr")) {
+		const last = poAttr(c, "lastClr");
+		if (last && /^[0-9A-Fa-f]{6}$/.test(last)) return last.toUpperCase();
+		return SYSTEM_COLORS.get(poAttr(c, "val") ?? "");
+	}
 	const isSrgb = poIs(c, "a:srgbClr");
 	if (!isSrgb && !poIs(c, "a:schemeClr")) return void 0;
 	const v = poAttr(c, "val");
@@ -193,4 +233,4 @@ function resolveColorNode(c, resolveColor) {
 	} : raw);
 }
 //#endregion
-export { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver, resolveColorNode };
+export { DEFAULT_THEME_PALETTE, applyColorMods, defaultColorResolver, makeColorResolver, readColorMods, resolveColorNode };

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

@@ -172,10 +172,11 @@ function regularPolygon(w, h, n) {
 function blockArrow(w, h, adjust, dir) {
 	const thick = clamp(frac(adjust, "adj1", 5e4), 0, 1);
 	const head = clamp(frac(adjust, "adj2", 5e4), 0, 1);
+	const ss = Math.min(w, h);
 	if (dir === "right" || dir === "left") {
-		const sb = h * (1 - thick) / 2;
-		const st = h * (1 + thick) / 2;
-		const hl = head * w;
+		const sb = (h - ss * thick) / 2;
+		const st = (h + ss * thick) / 2;
+		const hl = head * ss;
 		if (dir === "right") {
 			const bx = w - hl;
 			return polygon([
@@ -199,9 +200,9 @@ function blockArrow(w, h, adjust, dir) {
 			[w, st]
 		]);
 	}
-	const sl = w * (1 - thick) / 2;
-	const sr = w * (1 + thick) / 2;
-	const hh = head * h;
+	const sl = (w - ss * thick) / 2;
+	const sr = (w + ss * thick) / 2;
+	const hh = head * ss;
 	if (dir === "up") {
 		const by = h - hh;
 		return polygon([

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

@@ -59,14 +59,16 @@ function columnSpark(values, w, h, color) {
 	const slot = w / n;
 	const bw = slot * .72;
 	const off = (slot - bw) / 2;
-	const pad = h * .06;
 	const paths = [];
+	const at = (v) => (v - min) / span * h;
+	const zero = Math.min(h, Math.max(0, at(0)));
 	for (let i = 0; i < n; i++) {
 		const v = values[i];
 		if (v === null || v === void 0) continue;
-		const frac = (v - min) / span;
-		const bh = Math.max(.4, pad + frac * (h - pad));
-		paths.push(rectPath(i * slot + off, 0, bw, bh));
+		const y = at(v);
+		const bottom = Math.min(zero, y);
+		const bh = Math.max(.4, Math.abs(y - zero));
+		paths.push(rectPath(i * slot + off, bottom, bw, bh));
 	}
 	return paths.length > 0 ? [{
 		paths,

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

@@ -1,3 +1,4 @@
+import { PoNode } from '../po-helpers.js';
 /**
  * Parse a DrawingML theme part (ECMA-376 §20.1.6.2, `a:clrScheme`) into a
  * `name → hex` colour map. Reads the twelve scheme slots — `dk1`/`lt1`/`dk2`/
@@ -10,3 +11,43 @@
  *          empty when no `a:clrScheme` is present.
  */
 export declare function parseTheme(themeXml: Uint8Array): Map<string, string>;
+/**
+ * Parse a theme's line-style widths (ECMA-376 §20.1.4.1.21 `a:lnStyleLst`).
+ *
+ * A shape drawn from the gallery keeps its outline as `<a:lnRef idx="N">`,
+ * which is a 1-based index into this list — the reference names the colour and
+ * the list holds the width. The standard Office theme is 0.75pt / 2pt / 3pt.
+ *
+ * @param themeXml The raw theme part bytes, UTF-8.
+ * @returns The widths in points, in list order; empty when the theme declares
+ *          no `a:fmtScheme`.
+ */
+export declare function parseThemeLineWidths(themeXml: Uint8Array): Array<number>;
+/**
+ * Parse a theme's fill styles (§20.1.4.1.13 `a:fillStyleLst`), as the raw nodes.
+ *
+ * A shape drawn from the gallery carries no fill of its own — only
+ * `<a:fillRef idx="N">`, a 1-based index into this list, and a colour to put
+ * where the styles say `phClr`. The standard Office theme's slots are a solid,
+ * a subtle gradient and a stronger one, so reading the reference's colour alone
+ * paints slot 3 flat: 47504.xlsx's rectangle is a gradient in both references
+ * and a single blue in ours.
+ *
+ * The nodes are handed back unparsed because what they hold is a whole fill —
+ * solid, gradient, pattern — which the shape readers already know how to read.
+ *
+ * @param themeXml The raw theme part bytes, UTF-8.
+ * @returns The `a:fillStyleLst` children in list order; empty when the theme
+ *          declares no `a:fmtScheme`.
+ */
+export declare function parseThemeFillStyles(themeXml: Uint8Array): Array<PoNode>;
+/**
+ * Parse a theme's effect styles (§20.1.4.1.15 `a:effectStyleLst`), as the raw
+ * nodes. `<a:effectRef idx="N">` is a 1-based index into this list, exactly as
+ * the fill and line references index theirs.
+ *
+ * @param themeXml The raw theme part bytes, UTF-8.
+ * @returns The `a:effectStyle` children in list order; empty when the theme
+ *          declares no `a:fmtScheme`.
+ */
+export declare function parseThemeEffectStyles(themeXml: Uint8Array): Array<PoNode>;