reamkit 1.15.4 → 1.17.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,90 @@ 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 chartSpace = tree.find((c) => poIs(c, "c:chartSpace"));
+	const spaceSpPr = poChildren(chartSpace).find((c) => poIs(c, "c:spPr"));
+	const frameLine = spaceSpPr ? poChildren(spaceSpPr).find((c) => poIs(c, "a:ln")) : void 0;
+	const frameStyle = lineStyleOf(chartSpace, resolveColor);
+	const frameFillHex = spaceSpPr ? frameFillOf(spaceSpPr, resolveColor) : "FFFFFF";
+	const plotSpPr = poChildren(plotArea).find((c) => poIs(c, "c:spPr"));
+	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 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 +130,24 @@ 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 } : {},
+		...frameStyle?.widthPt !== void 0 ? { frameLineWidthPt: frameStyle.widthPt } : {},
+		...frameStyle?.dash ? { frameLineDash: frameStyle.dash } : {},
+		...plotFillHex ? { plotFillHex } : {},
+		...plotLine && plotLine.none !== true ? { plotLine } : {},
+		...numberFormat ? { numberFormat } : {}
 	};
 }
 function parseSeries(ser, resolveColor) {
@@ -85,12 +158,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 +210,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)) {
@@ -114,11 +247,31 @@ function dataPointColors(ser, resolveColor) {
 	}
 	return out;
 }
+/**
+* The BACKGROUND fill of a frame (the chart space, the plot rectangle): its own
+* `a:solidFill` and nothing else. Unlike a series, a frame that states
+* `<a:noFill/>` is not filled in the colour of its own rule —
+* Chart_Plot_BorderLine_Style.docx rules its plot in orange and we painted the
+* whole plot orange.
+*
+* @param spPr         The frame's `c:spPr`, or `undefined`.
+* @param resolveColor Maps a DrawingML colour reference to 6-hex.
+* @returns The fill colour, or `undefined` when the frame states none.
+*/
+function frameFillOf(spPr, resolveColor) {
+	if (!spPr) return void 0;
+	const solid = poChildren(spPr).find((c) => poIs(c, "a:solidFill"));
+	return solid ? colorFromSolidFill(solid, resolveColor) : void 0;
+}
 function fillColorOf(spPr, resolveColor) {
 	if (!spPr) return void 0;
 	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 +292,123 @@ 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.
+*/
+var DASHES = new Set([
+	"solid",
+	"dot",
+	"dash",
+	"dashDot",
+	"lgDash",
+	"lgDashDot",
+	"sysDash",
+	"sysDot"
+]);
+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;
+	const prst = poChildren(ln).find((c) => poIs(c, "a:prstDash"));
+	const dashVal = prst ? poAttr(prst, "val") : void 0;
+	const dash = dashVal !== void 0 && DASHES.has(dashVal) ? dashVal : void 0;
+	if (!colorHex && widthPt === void 0 && !dash) return void 0;
+	return {
+		...colorHex ? { colorHex } : {},
+		...widthPt !== void 0 ? { widthPt } : {},
+		...dash ? { dash } : {}
+	};
+}
+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 +420,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 +518,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

@@ -2,11 +2,11 @@ import { PoNode } from '../po-helpers.js';
 /**
  * A colour transform child (§20.1.2.3): `lumMod`/`lumOff` modulate luminance,
  * `shade` darkens toward black, `tint` lightens toward white. `val` is normalised
- * to 0..1 (the XML stores thousandths of a percent). `alpha` is parsed but ignored
+ * to 0..1 (the XML stores thousandths of a percent). `alpha` composites over white
  * (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,19 @@ 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 === "alpha") {
+		r = r * m.val + (1 - m.val);
+		g = g * m.val + (1 - m.val);
+		b = b * m.val + (1 - m.val);
+	} else {
+		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();
@@ -148,39 +161,92 @@ function makeColorResolver(palette) {
 }
 /** A {@link ColorResolver} backed by the {@link DEFAULT_THEME_PALETTE}. */
 var defaultColorResolver = makeColorResolver(DEFAULT_THEME_PALETTE);
+var PRESET_COLORS = new Map([
+	["black", "000000"],
+	["white", "FFFFFF"],
+	["gray", "808080"],
+	["grey", "808080"],
+	["darkGray".toLowerCase(), "A9A9A9"],
+	["lightGray".toLowerCase(), "D3D3D3"],
+	["red", "FF0000"],
+	["green", "008000"],
+	["blue", "0000FF"],
+	["yellow", "FFFF00"],
+	["cyan", "00FFFF"],
+	["magenta", "FF00FF"],
+	["dkGray".toLowerCase(), "A9A9A9"],
+	["ltGray".toLowerCase(), "D3D3D3"]
+]);
 /**
 * Read the colour transform children ({@link ColorMod}s) under an `a:srgbClr` /
 * `a:schemeClr` node, normalising each `val` from thousandths-of-a-percent to 0..1.
 */
 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") ?? "");
+	}
+	if (poIs(c, "a:prstClr")) {
+		const hex = PRESET_COLORS.get((poAttr(c, "val") ?? "").toLowerCase());
+		if (hex === void 0) return void 0;
+		const presetMods = readColorMods(c);
+		return presetMods.length > 0 ? applyColorMods(hex, presetMods) : hex;
+	}
 	const isSrgb = poIs(c, "a:srgbClr");
 	if (!isSrgb && !poIs(c, "a:schemeClr")) return void 0;
 	const v = poAttr(c, "val");
@@ -193,4 +259,4 @@ function resolveColorNode(c, resolveColor) {
 	} : raw);
 }
 //#endregion
-export { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver, resolveColorNode };
+export { DEFAULT_THEME_PALETTE, applyColorMods, defaultColorResolver, makeColorResolver, readColorMods, resolveColorNode };