reamkit 1.16.0 → 1.17.0

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

@@ -1,4 +1,4 @@
-import { Chart, ChartSeries } from '../document-model/index.js';
+import { Chart, ChartSeries, ShapeDash } from '../document-model/index.js';
 /**
  * An axis-aligned rectangle in the scene's local y-up frame: bars, scatter
  * point markers, legend swatches. Position is the bottom-left corner.
@@ -11,6 +11,8 @@ export interface ChartRect {
     readonly fillHex?: string;
     readonly strokeHex?: string;
     readonly strokeWidthPt?: number;
+    /** §20.1.10.49 — the outline's preset dash, when it names one. */
+    readonly strokeDash?: ShapeDash;
 }
 /** An open stroked polyline: line-chart series, gridlines and axis lines. */
 export interface ChartPolyline {
@@ -73,6 +75,11 @@ export interface ChartScene {
     readonly polygons?: ReadonlyArray<ChartPolygon>;
     /** §21.2.2.198 chart-space fill + outline: drawn under everything else. */
     readonly background?: ChartRect;
+    /**
+     * §21.2.2.145 the PLOT rectangle's own fill + outline, drawn over the chart
+     * frame and under the gridlines.
+     */
+    readonly plotBackground?: ChartRect;
     /**
      * Major gridlines, drawn UNDER the plotted data. Kept apart from the other
      * polylines because z-order is the whole point: gridlines over the bars strip
@@ -131,17 +138,6 @@ export declare function niceScale(dataMin: number, dataMax: number, maxTicks?: n
  * @returns The label text.
  */
 export declare function formatTick(v: number, step: number): string;
-/**
- * Lay out a bar/column {@link Chart} into a {@link ChartScene}. Honours
- * `chart.grouping` (clustered / stacked / percentStacked) and `chart.barDir`
- * (column vs horizontal bar), over the shared cartesian frame.
- *
- * @param chart   The bar/column chart.
- * @param wPt     Frame width in points.
- * @param hPt     Frame height in points.
- * @param measure Text measurer used to size labels and reserve axis gutters.
- * @returns The positioned scene primitives.
- */
 export declare function buildBarScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
 /**
  * The name a series shows in the legend: its own `c:tx`, or Excel's positional

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

@@ -186,7 +186,7 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	const fmtVal = opts.formatValue ?? ((v) => formatTick(v, scale.step));
 	const tickVals = ticks(scale);
 	const vals2 = onSecondary.flatMap((s) => s.values.slice(0, nCats));
-	const scale2 = vals2.length > 0 ? niceScale(Math.min(0, ...vals2), Math.max(0, ...vals2), Math.min(10, Math.max(4, Math.round(hPt / 24)))) : void 0;
+	const scale2 = vals2.length > 0 ? niceScale(Math.min(0, ...vals2), Math.max(0, ...vals2), tickBudget(hPt)) : void 0;
 	const tickVals2 = scale2 ? ticks(scale2) : [];
 	let top = 4;
 	if (chart.title) top += 13 * 1.6;
@@ -202,6 +202,18 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	const plotH = Math.max(1, hPt - top - y0);
 	const valueOffset = (v) => (v - scale.min) / (scale.max - scale.min) * (horizontal ? plotW : plotH);
 	const zeroOffset = valueOffset(0);
+	const plotBackground = chart.plotFillHex ?? chart.plotLine?.colorHex ? {
+		x: x0,
+		y: y0,
+		w: plotW,
+		h: plotH,
+		...chart.plotFillHex ? { fillHex: chart.plotFillHex } : {},
+		...chart.plotLine?.colorHex ? {
+			strokeHex: chart.plotLine.colorHex,
+			strokeWidthPt: chart.plotLine.widthPt ?? .75,
+			...chart.plotLine.dash ? { strokeDash: chart.plotLine.dash } : {}
+		} : {}
+	} : void 0;
 	pushChartTitle(labels, chart, wPt, hPt);
 	if (chart.valAxisTitle) labels.push({
 		text: chart.valAxisTitle,
@@ -288,6 +300,7 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		rects,
 		polylines,
 		gridlines,
+		...plotBackground ? { plotBackground } : {},
 		labels
 	};
 }
@@ -352,6 +365,24 @@ function chartValueFormatter(chart) {
 * @param measure Text measurer used to size labels and reserve axis gutters.
 * @returns The positioned scene primitives.
 */
+/**
+* §21.2.2.198 `c:ser/c:spPr/a:ln` — a bar's own outline, as the stroke fields a
+* {@link ChartRect} carries. Chart_BorderLine_Style.docx outlines each of its
+* series in a colour and dash of its own, and drawing bars unstroked lost all
+* of it.
+*
+* @param series The series the bar belongs to.
+* @returns The stroke fields, or an empty object when the series has no rule.
+*/
+function barOutline(series) {
+	const ln = series.line;
+	if (!ln || ln.none === true || !ln.colorHex) return {};
+	return {
+		strokeHex: ln.colorHex,
+		strokeWidthPt: ln.widthPt ?? .75,
+		...ln.dash && ln.dash !== "solid" ? { strokeDash: ln.dash } : {}
+	};
+}
 function buildBarScene(chart, wPt, hPt, measure) {
 	const g = chart.grouping ?? "clustered";
 	const stacked = g === "stacked" || g === "percentStacked";
@@ -379,19 +410,22 @@ function buildBarScene(chart, wPt, hPt, measure) {
 				const lo = Math.min(o0, o1);
 				const span = Math.abs(o1 - o0);
 				const color = pointColor(series, c) ?? seriesColor(series, s, chart.seriesColorCycle);
+				const outline = barOutline(series);
 				if (horizontal) f.rects.push({
 					x: f.x0 + lo,
 					y: along,
 					w: span,
 					h: barW,
-					fillHex: color
+					fillHex: color,
+					...outline
 				});
 				else f.rects.push({
 					x: along,
 					y: f.y0 + lo,
 					w: barW,
 					h: span,
-					fillHex: color
+					fillHex: color,
+					...outline
 				});
 				if (chart.showValues && span > 9) {
 					const raw = series.values[c] ?? 0;
@@ -407,6 +441,8 @@ function buildBarScene(chart, wPt, hPt, measure) {
 			rects: f.rects,
 			polylines: f.polylines,
 			gridlines: f.gridlines,
+			...f.plotBackground ? { plotBackground: f.plotBackground } : {},
+			...f.plotBackground ? { plotBackground: f.plotBackground } : {},
 			wedges: [],
 			labels: f.labels
 		};
@@ -423,6 +459,7 @@ function buildBarScene(chart, wPt, hPt, measure) {
 			const len = f.valueOffset(series.values[c] ?? 0) - f.zeroOffset;
 			const color = pointColor(series, c) ?? seriesColor(series, s, chart.seriesColorCycle);
 			const along = slotStart + b * barW;
+			const outline = barOutline(series);
 			if (horizontal) {
 				const bx = f.x0 + f.zeroOffset + Math.min(0, len);
 				f.rects.push({
@@ -430,7 +467,8 @@ function buildBarScene(chart, wPt, hPt, measure) {
 					y: along,
 					w: Math.abs(len),
 					h: barW,
-					fillHex: color
+					fillHex: color,
+					...outline
 				});
 			} else {
 				const by = f.y0 + f.zeroOffset + Math.min(0, len);
@@ -439,7 +477,8 @@ function buildBarScene(chart, wPt, hPt, measure) {
 					y: by,
 					w: barW,
 					h: Math.abs(len),
-					fillHex: color
+					fillHex: color,
+					...outline
 				});
 			}
 			if (chart.showValues) {
@@ -466,6 +505,7 @@ function buildBarScene(chart, wPt, hPt, measure) {
 		rects: f.rects,
 		polylines: f.polylines,
 		gridlines: f.gridlines,
+		...f.plotBackground ? { plotBackground: f.plotBackground } : {},
 		wedges: [],
 		labels: f.labels
 	};
@@ -580,6 +620,7 @@ function buildAreaScene(chart, wPt, hPt, measure) {
 		rects: f.rects,
 		polylines: f.polylines,
 		gridlines: f.gridlines,
+		...f.plotBackground ? { plotBackground: f.plotBackground } : {},
 		wedges: [],
 		labels: f.labels,
 		polygons
@@ -670,8 +711,12 @@ function autoRange(vals) {
 	const hi = Math.max(...vals);
 	return [lo > 0 && lo < 5 / 6 * hi ? 0 : lo, hi];
 }
-/** Ticks that fit along an axis `extentPt` long (mirrors {@link axisScale}). */
-var tickBudget = (extentPt) => Math.min(10, Math.max(4, Math.round(extentPt / 24)));
+/**
+* Ticks that fit along an axis `extentPt` long (mirrors {@link axisScale}).
+* A tick every 32pt is what both references draw: at 24 a 250pt plot carried
+* eleven of them (0, 0.5, 1 … 5.5) where both label 0…6 in whole numbers.
+*/
+var tickBudget = (extentPt) => Math.min(10, Math.max(4, Math.round(extentPt / 32)));
 /** Side (points) of the square stamped for a series that names no symbol. */
 var DEFAULT_MARKER_PT = 4;
 /**
@@ -722,7 +767,9 @@ function pushMarker(rects, wedges, marker, x, y, color) {
 */
 function buildLineScene(chart, wPt, hPt, measure) {
 	const allVals = chart.series.flatMap((s) => s.values);
-	const range = allVals.length > 0 ? [Math.min(...allVals), Math.max(...allVals)] : [0, 1];
+	const lo = allVals.length > 0 ? Math.min(...allVals) : 0;
+	const hi = allVals.length > 0 ? Math.max(...allVals) : 1;
+	const range = lo > 0 && lo > 5 / 6 * hi ? [lo, hi] : [Math.min(0, lo), Math.max(0, hi)];
 	const lineFormat = chartValueFormatter(chart);
 	const f = buildFrame(chart, wPt, hPt, measure, false, {
 		dataRange: range,
@@ -760,6 +807,7 @@ function buildLineScene(chart, wPt, hPt, measure) {
 		rects: f.rects,
 		polylines: f.polylines,
 		gridlines: f.gridlines,
+		...f.plotBackground ? { plotBackground: f.plotBackground } : {},
 		wedges,
 		labels: f.labels
 	};
@@ -1003,7 +1051,8 @@ function withFrame(scene, chart, wPt, hPt) {
 		...chart.frameFillHex ? { fillHex: chart.frameFillHex } : {},
 		...chart.frameLineHex ? {
 			strokeHex: chart.frameLineHex,
-			strokeWidthPt: .75
+			strokeWidthPt: chart.frameLineWidthPt ?? .75,
+			...chart.frameLineDash ? { strokeDash: chart.frameLineDash } : {}
 		} : {}
 	};
 	return {

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

@@ -100,10 +100,15 @@ function parseChart(chartXml, 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 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 frameLineHex = frameLine ? fillColorOf(frameLine, resolveColor) : 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;
@@ -138,6 +143,10 @@ function parseChart(chartXml, resolveColor) {
 		...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 } : {}
 	};
 }
@@ -238,6 +247,22 @@ 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"));
@@ -349,6 +374,16 @@ 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([
+	"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;
@@ -358,10 +393,14 @@ function lineStyleOf(owner, resolveColor) {
 	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;
+	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 } : {}
+		...widthPt !== void 0 ? { widthPt } : {},
+		...dash ? { dash } : {}
 	};
 }
 function valueFormatCode(plotArea) {

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

@@ -2,7 +2,7 @@ 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 {

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

@@ -102,7 +102,11 @@ function applyColorMods(hex, mods) {
 	} 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") {
+	} 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);
 	}
@@ -157,6 +161,22 @@ 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.
@@ -221,6 +241,12 @@ function resolveColorNode(c, resolveColor) {
 		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");

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

@@ -86,8 +86,33 @@ function presetPaths(preset, w, h, adjust) {
 				[0, h / 2]
 			])];
 		}
+		case "round1Rect":
+		case "round2SameRect":
+		case "round2DiagRect":
+		case "snip1Rect":
+		case "snip2SameRect":
+		case "snip2DiagRect":
+		case "snipRoundRect": return [cornerRect(preset, w, h, adjust)];
+		case "star4":
+		case "star5":
+		case "star6":
+		case "star7":
+		case "star8":
+		case "star10":
+		case "star12":
+		case "star16":
+		case "star24":
+		case "star32": {
+			const s = STARS.get(preset);
+			return s ? [star(w, h, s, adjust)] : null;
+		}
 		case "line":
 		case "straightConnector1": return [new PathBuilder().moveTo(0, h).lineTo(w, 0).build()];
+		case "bentConnector2": return [new PathBuilder().moveTo(0, h).lineTo(w, h).lineTo(w, 0).build()];
+		case "bentConnector3": {
+			const bx = clamp(frac(adjust, "adj1", 5e4), 0, 1) * w;
+			return [new PathBuilder().moveTo(0, h).lineTo(bx, h).lineTo(bx, 0).lineTo(w, 0).build()];
+		}
 		case "rightArrow": return [blockArrow(w, h, adjust, "right")];
 		case "leftArrow": return [blockArrow(w, h, adjust, "left")];
 		case "upArrow": return [blockArrow(w, h, adjust, "up")];
@@ -157,6 +182,214 @@ function customPaths(geom, wPt, hPt) {
 	}
 	return [b.build()];
 }
+var SQUARE = {
+	cut: 0,
+	round: false
+};
+var CORNER_RECTS = new Map([
+	["round1Rect", {
+		defaults: [16667, 0],
+		corners: [
+			void 0,
+			0,
+			void 0,
+			void 0
+		],
+		round: true
+	}],
+	["snip1Rect", {
+		defaults: [16667, 0],
+		corners: [
+			void 0,
+			0,
+			void 0,
+			void 0
+		],
+		round: false
+	}],
+	["round2SameRect", {
+		defaults: [16667, 0],
+		corners: [
+			0,
+			0,
+			1,
+			1
+		],
+		round: true
+	}],
+	["snip2SameRect", {
+		defaults: [16667, 0],
+		corners: [
+			0,
+			0,
+			1,
+			1
+		],
+		round: false
+	}],
+	["round2DiagRect", {
+		defaults: [16667, 0],
+		corners: [
+			0,
+			1,
+			0,
+			1
+		],
+		round: true
+	}],
+	["snip2DiagRect", {
+		defaults: [16667, 0],
+		corners: [
+			0,
+			1,
+			0,
+			1
+		],
+		round: false
+	}],
+	["snipRoundRect", {
+		defaults: [16667, 16667],
+		corners: [
+			0,
+			1,
+			void 0,
+			void 0
+		],
+		round: [false, true]
+	}]
+]);
+function cornerRect(preset, w, h, adjust) {
+	const spec = CORNER_RECTS.get(preset);
+	const ss = Math.min(w, h);
+	const guide = (i) => {
+		return clamp((adjust.get(i === 0 ? "adj1" : "adj2") ?? (i === 0 ? adjust.get("adj") : void 0) ?? spec.defaults[i]) / 1e5, 0, .5) * ss;
+	};
+	return roundedCorners(w, h, spec.corners.map((g) => {
+		if (g === void 0) return SQUARE;
+		const round = typeof spec.round === "boolean" ? spec.round : spec.round[g];
+		return {
+			cut: guide(g),
+			round
+		};
+	}));
+}
+function roundedCorners(w, h, [tl, tr, br, bl]) {
+	const at = [
+		{
+			c: tl,
+			from: [0, h - tl.cut],
+			to: [tl.cut, h],
+			centre: [tl.cut, h - tl.cut],
+			start: Math.PI
+		},
+		{
+			c: tr,
+			from: [w - tr.cut, h],
+			to: [w, h - tr.cut],
+			centre: [w - tr.cut, h - tr.cut],
+			start: Math.PI / 2
+		},
+		{
+			c: br,
+			from: [w, br.cut],
+			to: [w - br.cut, 0],
+			centre: [w - br.cut, br.cut],
+			start: 0
+		},
+		{
+			c: bl,
+			from: [bl.cut, 0],
+			to: [0, bl.cut],
+			centre: [bl.cut, bl.cut],
+			start: -Math.PI / 2
+		}
+	];
+	const b = new PathBuilder();
+	at.forEach((corner, i) => {
+		if (i === 0) b.moveTo(corner.from[0], corner.from[1]);
+		else b.lineTo(corner.from[0], corner.from[1]);
+		if (corner.c.cut <= 0) return;
+		if (corner.c.round) b.append(arcToBeziers(corner.centre[0], corner.centre[1], corner.c.cut, corner.c.cut, corner.start, -Math.PI / 2));
+		else b.lineTo(corner.to[0], corner.to[1]);
+	});
+	return b.close().build();
+}
+var STARS = new Map([
+	["star4", {
+		points: 4,
+		adj: 12500,
+		hf: 1e5,
+		vf: 1e5
+	}],
+	["star5", {
+		points: 5,
+		adj: 19098,
+		hf: 105146,
+		vf: 110557
+	}],
+	["star6", {
+		points: 6,
+		adj: 28868,
+		hf: 115470,
+		vf: 1e5
+	}],
+	["star7", {
+		points: 7,
+		adj: 34601,
+		hf: 102572,
+		vf: 105210
+	}],
+	["star8", {
+		points: 8,
+		adj: 37500,
+		hf: 1e5,
+		vf: 1e5
+	}],
+	["star10", {
+		points: 10,
+		adj: 42533,
+		hf: 105146,
+		vf: 1e5
+	}],
+	["star12", {
+		points: 12,
+		adj: 37500,
+		hf: 1e5,
+		vf: 1e5
+	}],
+	["star16", {
+		points: 16,
+		adj: 37500,
+		hf: 1e5,
+		vf: 1e5
+	}],
+	["star24", {
+		points: 24,
+		adj: 37500,
+		hf: 1e5,
+		vf: 1e5
+	}],
+	["star32", {
+		points: 32,
+		adj: 37500,
+		hf: 1e5,
+		vf: 1e5
+	}]
+]);
+function star(w, h, preset, adjust) {
+	const inner = clamp(frac(adjust, "adj", preset.adj) * 2, 0, 1);
+	const hf = preset.hf / 1e5;
+	const vf = preset.vf / 1e5;
+	const pts = [];
+	for (let i = 0; i < preset.points; i++) {
+		const out = -Math.PI / 2 + i * 2 * Math.PI / preset.points;
+		for (const [angle, r] of [[out, 1], [out + Math.PI / preset.points, inner]]) {
+			const x = w / 2 * (1 + hf * r * Math.cos(angle));
+			pts.push([x, h - h / 2 * vf * (1 + r * Math.sin(angle))]);
+		}
+	}
+	return polygon(pts);
+}
 function regularPolygon(w, h, n) {
 	const cx = w / 2;
 	const cy = h / 2;

package/dist/esm/core/drawingml/shape-render.d.ts

@@ -37,6 +37,18 @@ export declare function gradientToSolid(gradient: ShapeGradient): string;
  * @returns The `<linearGradient>` or `<radialGradient>` markup.
  */
 export declare function gradientSvgDef(id: string, g: ShapeGradient): string;
+/**
+ * §20.1.8.24 / §20.1.8.42 — the arrowheads a line asks for at its ends, as
+ * filled paths in the same local frame as the shape's own geometry. The head
+ * rides the first point of the first subpath and the tail the last point of
+ * the last one, each turned along the segment that reaches it.
+ *
+ * @param paths        The shape's geometry paths.
+ * @param line         The parsed line (its `headEnd`/`tailEnd` are read).
+ * @param strokeWidthPt The pen width the decorations are sized against.
+ * @returns The decoration paths (empty when the line asks for none).
+ */
+export declare function lineEndPaths(paths: ReadonlyArray<VectorPath>, line: ShapeLine | undefined, strokeWidthPt: number): Array<VectorPath>;
 /**
  * Build a {@link StrokeStyle} from a shape's `a:ln` line, resolving the default
  * width (0.75pt), dash pattern and line cap. Returns `undefined` for no line or