reamkit 1.31.0 → 1.32.1

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

@@ -2,6 +2,25 @@ import { Chart } from '../document-model/index.js';
 import { ResourceId } from '../ir/index.js';
 import { OpcPackage } from '../opc/index.js';
 import { ColorResolver } from './colors.js';
+/**
+ * The most points a chart keeps, all its series together: as many as a sheet
+ * has rows, the longest range a series can name. A chart part states its own
+ * point counts — a cache's `c:ptCount`, each point's `idx`, the range of a
+ * `c:f` — and taken at their word, a count of two billion in a part a few
+ * hundred bytes long asked for a dense array that ran the process out of
+ * memory, and one past 2³² − 1 threw.
+ */
+export declare const MOST_CHART_POINTS = 1048576;
+/**
+ * How many points each of a chart's `seriesCount` series keeps: an even share
+ * of {@link MOST_CHART_POINTS}, so that the bound holds for the chart and not
+ * series by series — two thousand series, each declaring a sheet's worth of
+ * points, are two billion. A series' points past its share are not read.
+ *
+ * @param seriesCount How many series the chart has.
+ * @returns The points each keeps, at least one.
+ */
+export declare function pointsPerSeries(seriesCount: number): number;
 /**
  * Parse a DrawingML chart part (chart1.xml) into a {@link Chart}, reading the
  * CACHED data (`c:numCache` / `c:strCache`) rather than the embedded spreadsheet

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

@@ -25,6 +25,27 @@ var TYPE_OF_TAG = {
 	"c:scatterChart": "scatter"
 };
 /**
+* The most points a chart keeps, all its series together: as many as a sheet
+* has rows, the longest range a series can name. A chart part states its own
+* point counts — a cache's `c:ptCount`, each point's `idx`, the range of a
+* `c:f` — and taken at their word, a count of two billion in a part a few
+* hundred bytes long asked for a dense array that ran the process out of
+* memory, and one past 2³² − 1 threw.
+*/
+var MOST_CHART_POINTS = 1048576;
+/**
+* How many points each of a chart's `seriesCount` series keeps: an even share
+* of {@link MOST_CHART_POINTS}, so that the bound holds for the chart and not
+* series by series — two thousand series, each declaring a sheet's worth of
+* points, are two billion. A series' points past its share are not read.
+*
+* @param seriesCount How many series the chart has.
+* @returns The points each keeps, at least one.
+*/
+function pointsPerSeries(seriesCount) {
+	return Math.max(1, Math.floor(MOST_CHART_POINTS / Math.max(1, seriesCount)));
+}
+/**
 * Parse a DrawingML chart part (chart1.xml) into a {@link Chart}, reading the
 * CACHED data (`c:numCache` / `c:strCache`) rather than the embedded spreadsheet
 * — the cache holds the last-computed categories and values, exactly what Word
@@ -48,6 +69,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const type = group ? TYPE_OF_TAG[poTag(group)] ?? "unknown" : "unknown";
 	const groupAxIds = (g) => poChildren(g).filter((c) => poIs(c, "c:axId")).map((c) => poAttr(c, "val") ?? "");
 	const primaryAxIds = new Set(group ? groupAxIds(group) : []);
+	const most = pointsPerSeries(groups.reduce((n, g) => n + poChildren(g).filter((c) => poIs(c, "c:ser")).length, 0));
 	const serNodes = [];
 	const series = [];
 	let secondaryValAxId;
@@ -58,7 +80,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		for (const s of poChildren(g).filter((c) => poIs(c, "c:ser"))) {
 			serNodes.push(s);
 			series.push({
-				...parseSeries(s, resolveColor),
+				...parseSeries(s, resolveColor, most),
 				...groupType === type ? {} : { type: groupType },
 				...secondary ? { secondaryAxis: true } : {}
 			});
@@ -71,10 +93,13 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const secondaryValAxisTitle = secondaryTitleNode ? collectAT(secondaryTitleNode) || "Axis Title" : void 0;
 	let categories = [];
 	let categoriesRef;
+	let categoryGroups;
 	for (const s of serNodes) {
 		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
 		if (cat) {
-			categories = denseStrings(cat);
+			const levels = multiLevelCategories(cat, most);
+			categories = levels ? levels.categories : denseStrings(cat, most);
+			categoryGroups = levels?.groups;
 			categoriesRef ??= refFormula(cat);
 			break;
 		}
@@ -99,7 +124,12 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	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 catAxisReversed = axisOrientation(catAxNode) === "maxMin";
+	const catAxisCrosses = axisCrossing(catAxNode);
+	const valAxisCrosses = axisCrossing(valAxNode);
+	const tickLblPos = catAxNode ? poVal(poChildren(catAxNode).find((c) => poIs(c, "c:tickLblPos"))) : void 0;
+	const catTickLabelPos = tickLblPos === "low" || tickLblPos === "high" || tickLblPos === "none" ? tickLblPos : void 0;
 	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;
@@ -123,6 +153,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...Number.isFinite(gapPercent) && gapPercent >= 0 ? { gapPercent } : {},
 		categories,
 		...categoriesRef ? { categoriesRef } : {},
+		...categoryGroups && categoryGroups.length > 0 ? { categoryGroups } : {},
 		series,
 		hasLegend: legend !== void 0,
 		...isLegendPos(legendPos) ? { legendPos } : {},
@@ -132,6 +163,9 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...showValues ? { showValues: true } : {},
 		...catAxisTitle ? { catAxisTitle } : {},
 		...catAxisReversed ? { catAxisReversed } : {},
+		...catAxisCrosses !== void 0 ? { catAxisCrosses } : {},
+		...valAxisCrosses !== void 0 ? { valAxisCrosses } : {},
+		...catTickLabelPos ? { catTickLabelPos } : {},
 		...valAxisTitle ? { valAxisTitle } : {},
 		...secondaryValAxisTitle ? { secondaryValAxisTitle } : {},
 		...scatterStyle ? { scatterStyle } : {},
@@ -142,6 +176,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...gridLine ? { gridLine } : {},
 		...valAxisMin !== void 0 ? { valAxisMin } : {},
 		...valAxisMax !== void 0 ? { valAxisMax } : {},
+		...valAxisMajorUnit !== void 0 ? { valAxisMajorUnit } : {},
 		...frameFillHex ? { frameFillHex } : {},
 		...frameFillImage ? { frameFillImage } : {},
 		...frameLineHex ? { frameLineHex } : {},
@@ -152,11 +187,11 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...numberFormat ? { numberFormat } : {}
 	};
 }
-function parseSeries(ser, resolveColor) {
+function parseSeries(ser, resolveColor, most) {
 	const valNode = poChildren(ser).find((c) => poIs(c, "c:val")) ?? poChildren(ser).find((c) => poIs(c, "c:yVal"));
-	const values = valNode ? denseNumbers(valNode) : [];
+	const values = valNode ? denseNumbers(valNode, most) : [];
 	const xValNode = poChildren(ser).find((c) => poIs(c, "c:xVal"));
-	const xValues = xValNode ? denseNumbers(xValNode) : void 0;
+	const xValues = xValNode ? denseNumbers(xValNode, most) : void 0;
 	const name = seriesName(ser);
 	const colorHex = fillColorOf(poChildren(ser).find((c) => poIs(c, "c:spPr")), resolveColor);
 	const pointColors = dataPointColors(ser, resolveColor);
@@ -298,9 +333,16 @@ function fillColorOf(spPr, resolveColor) {
 	const lnFill = ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0;
 	return lnFill ? colorFromSolidFill(lnFill, resolveColor) : void 0;
 }
+/** The colour elements a chart's fill names a colour by (§20.1.2.3). */
+var CHART_COLOR_NODES = [
+	"a:srgbClr",
+	"a:schemeClr",
+	"a:sysClr",
+	"a:prstClr"
+];
 function colorFromSolidFill(solid, resolveColor) {
 	for (const c of poChildren(solid)) {
-		if (!poIs(c, "a:srgbClr") && !poIs(c, "a:schemeClr")) continue;
+		if (!CHART_COLOR_NODES.some((name) => poIs(c, name))) continue;
 		if (!poAttr(c, "val")) continue;
 		return resolveColorNode(c, resolveColor);
 	}
@@ -355,7 +397,7 @@ function cachedTitleText(title) {
 	const tx = poChildren(title).find((c) => poIs(c, "c:tx"));
 	const ref = tx ? poChildren(tx).find((c) => poIs(c, "c:strRef")) : void 0;
 	if (!ref) return void 0;
-	const cached = denseStrings(ref).filter((t) => t.length > 0);
+	const cached = denseStrings(ref, MOST_CHART_POINTS).filter((t) => t.length > 0);
 	return cached.length > 0 ? cached.join(" ") : void 0;
 }
 function axisTitle(plotArea, axTag) {
@@ -374,10 +416,30 @@ function axisTitle(plotArea, axTag) {
 * does not carry — those keep the plain numeric render.
 */
 /** §21.2.2.134 `c:scaling/c:orientation` — `minMax` (the default) or `maxMin`. */
+/**
+* §21.2.2.33/§21.2.2.34 — where an axis crosses the one it is drawn against:
+* `crossesAt` a value, or `crosses` at that axis's minimum or maximum.
+* undefined for `autoZero`, the default.
+*/
+function axisCrossing(ax) {
+	if (!ax) return void 0;
+	const at = poChildren(ax).find((c) => poIs(c, "c:crossesAt"));
+	const value = at ? Number(poAttr(at, "val")) : NaN;
+	if (Number.isFinite(value)) return value;
+	const crosses = poVal(poChildren(ax).find((c) => poIs(c, "c:crosses")));
+	return crosses === "min" || crosses === "max" ? crosses : void 0;
+}
 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". */
+function majorUnitOf(plotArea) {
+	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	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"));
 	const scaling = ax ? poChildren(ax).find((c) => poIs(c, "c:scaling")) : void 0;
@@ -469,26 +531,72 @@ function ptCountOf(container) {
 	const pc = cache ? poChildren(cache).find((c) => poIs(c, "c:ptCount")) : void 0;
 	return pc ? poIntAttr(pc, "val") ?? 0 : 0;
 }
-function denseLength(container, pts) {
-	let max = ptCountOf(container);
-	for (const p of pts) max = Math.max(max, p.idx + 1);
-	return max;
+/** Whether `n` can index a point: a whole number from zero. */
+var isPointIndex = (n) => Number.isInteger(n) && n >= 0;
+/**
+* How many slots `count` points and those at `indexes` take — the count, or
+* past it the last of them, and never more than `most`. A count or an index
+* that is no whole number (2.5) asked for an array of no possible length and
+* threw; it counts for nothing.
+*/
+function denseLength(count, indexes, most) {
+	let length = isPointIndex(count) ? count : 0;
+	for (const idx of indexes) if (isPointIndex(idx)) length = Math.max(length, idx + 1);
+	return Math.min(length, most);
 }
-function denseNumbers(container) {
+/** A cache's values by point index, gaps 0, at most `most` of them. */
+function denseNumbers(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill(0);
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill(0);
 	for (const p of pts) {
 		const n = Number(p.v);
-		if (Number.isFinite(n)) arr[p.idx] = n;
+		if (Number.isFinite(n) && isPointIndex(p.idx) && p.idx < length) arr[p.idx] = n;
 	}
 	return arr;
 }
-function denseStrings(container) {
+/** A cache's texts by point index, gaps empty, at most `most` of them. */
+function denseStrings(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill("");
-	for (const p of pts) arr[p.idx] = p.v;
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill("");
+	for (const p of pts) if (isPointIndex(p.idx) && p.idx < length) arr[p.idx] = p.v;
 	return arr;
 }
+/**
+* §21.2.2.115 `c:multiLvlStrCache` — categories labelled on several levels:
+* the first `c:lvl` labels each category, every later one groups them, a
+* group's label standing at the category it starts at. Read as one flat cache
+* it read as none, and an xlsx chart fell back to the cells its reference
+* names, both columns of them in turn: WithChartSheet.xlsx's six bars stood in
+* the first six of sixteen slots under a jumble of years and measure names.
+*
+* @param cat  The `c:cat` element.
+* @param most The most categories it keeps (see {@link pointsPerSeries}).
+* @returns The innermost labels and the outer levels' groups, or undefined
+*   for a category axis of one level.
+*/
+function multiLevelCategories(cat, most) {
+	const cache = poFindDescendant(cat, "c:multiLvlStrCache");
+	if (!cache) return void 0;
+	const count = poIntAttr(poChildren(cache).find((c) => poIs(c, "c:ptCount")) ?? cache, "val") ?? 0;
+	const [inner, ...outer] = poChildren(cache).filter((c) => poIs(c, "c:lvl")).map((lvl) => poChildren(lvl).filter((pt) => poIs(pt, "c:pt")).map((pt) => {
+		const v = poChildren(pt).find((c) => poIs(c, "c:v"));
+		return {
+			start: poIntAttr(pt, "idx") ?? 0,
+			label: v ? poText(v) : ""
+		};
+	}));
+	if (!inner) return void 0;
+	const length = denseLength(count, inner.map((p) => p.start), most);
+	const categories = new Array(length).fill("");
+	const kept = (p) => isPointIndex(p.start) && p.start < length;
+	for (const p of inner) if (kept(p)) categories[p.start] = p.label;
+	return {
+		categories,
+		groups: outer.map((level) => level.filter(kept).sort((a, b) => a.start - b.start))
+	};
+}
 function isLegendPos(v) {
 	return v === "r" || v === "l" || v === "t" || v === "b";
 }
@@ -565,4 +673,4 @@ var SCATTER_STYLES = new Set([
 ]);
 var REL_CHART_COLOR_STYLE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 //#endregion
-export { parseChart, withChartColorStyle };
+export { parseChart, pointsPerSeries, withChartColorStyle };

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

@@ -40,6 +40,12 @@ export declare function applyColorMods(hex: string, mods: ReadonlyArray<ColorMod
  * scheme slots when a document carries no custom theme part.
  */
 export declare const DEFAULT_THEME_PALETTE: ReadonlyMap<string, string>;
+/**
+ * The Office 2023 theme's palette — what Excel colours a workbook that carries
+ * 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.
+ */
+export declare const OFFICE_2023_THEME_PALETTE: ReadonlyMap<string, string>;
 /**
  * Which theme slot each `schemeClr` name stands for. Only the text/background
  * aliases are ever remapped; anything absent resolves under its own name.

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

@@ -148,6 +148,25 @@ var DEFAULT_THEME_PALETTE = new Map([
 	["hlink", "0563C1"],
 	["folHlink", "954F72"]
 ]);
+/**
+* The Office 2023 theme's palette — what Excel colours a workbook that carries
+* 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([
+	["dk1", "000000"],
+	["lt1", "FFFFFF"],
+	["dk2", "0E2841"],
+	["lt2", "E8E8E8"],
+	["accent1", "156082"],
+	["accent2", "E97132"],
+	["accent3", "196B24"],
+	["accent4", "0F9ED5"],
+	["accent5", "A02B93"],
+	["accent6", "4EA72E"],
+	["hlink", "467886"],
+	["folHlink", "96607D"]
+]);
 var DEFAULT_SCHEME_ALIAS = {
 	tx1: "dk1",
 	bg1: "lt1",
@@ -284,8 +303,9 @@ var SYSTEM_COLORS = new Map([
 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 hex = last && /^[0-9A-Fa-f]{6}$/.test(last) ? last.toUpperCase() : SYSTEM_COLORS.get(poAttr(c, "val") ?? "");
+		const sysMods = readColorMods(c);
+		return hex !== void 0 && sysMods.length > 0 ? applyColorMods(hex, sysMods) : hex;
 	}
 	if (poIs(c, "a:prstClr")) {
 		const hex = PRESET_COLORS.get((poAttr(c, "val") ?? "").toLowerCase());
@@ -305,4 +325,4 @@ function resolveColorNode(c, resolveColor) {
 	} : raw);
 }
 //#endregion
-export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, applyColorMods, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode };
+export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, OFFICE_2023_THEME_PALETTE, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode };

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

@@ -30,7 +30,9 @@ export declare function gradientToSolid(gradient: ShapeGradient): string;
  * An SVG `<linearGradient>` / `<radialGradient>` definition for a gradient fill
  * (EP16), shared by the SVG and HTML writers. The linear vector is expressed in
  * `objectBoundingBox` space; the angle is negated because the shape's own path
- * transform flips y (local y-up → page y-down).
+ * transform flips y (local y-up → page y-down) — and a radial centre, given in
+ * fractions down from the box's top, is measured up from its bottom for the
+ * same reason.
  *
  * @param id The gradient element id (referenced by `fill="url(#id)"`).
  * @param g  The gradient fill.

package/dist/esm/core/drawingml/shape-render.js

@@ -51,7 +51,9 @@ function gradientToSolid(gradient) {
 * An SVG `<linearGradient>` / `<radialGradient>` definition for a gradient fill
 * (EP16), shared by the SVG and HTML writers. The linear vector is expressed in
 * `objectBoundingBox` space; the angle is negated because the shape's own path
-* transform flips y (local y-up → page y-down).
+* transform flips y (local y-up → page y-down) — and a radial centre, given in
+* fractions down from the box's top, is measured up from its bottom for the
+* same reason.
 *
 * @param id The gradient element id (referenced by `fill="url(#id)"`).
 * @param g  The gradient fill.
@@ -64,7 +66,7 @@ function gradientSvgDef(id, g) {
 		const c = g.center;
 		if (!c) return `<radialGradient id="${id}">${stops}</radialGradient>`;
 		const r = Math.SQRT2 / 2;
-		return `<radialGradient id="${id}" cx="${n(c.x)}" cy="${n(c.y)}" r="${n(r)}">${stops}</radialGradient>`;
+		return `<radialGradient id="${id}" cx="${n(c.x)}" cy="${n(1 - c.y)}" r="${n(r)}">${stops}</radialGradient>`;
 	}
 	const rad = -(g.angle ?? 0) * Math.PI / 180;
 	const dx = Math.cos(rad) / 2;

package/dist/esm/core/font/measure.d.ts

@@ -29,6 +29,15 @@ export interface FontMeasure {
      * `[…] TJ` array when shaping moved a glyph off its own advance.
      */
     readonly showText: (text: string) => string;
+    /**
+     * The glyphs `text` is drawn with and the advance each one takes, in font
+     * units — exactly what {@link showText} shows, kerning and ligatures
+     * included — for a writer that places each glyph itself.
+     */
+    readonly glyphRun: (text: string) => {
+        readonly gids: ReadonlyArray<number>;
+        readonly advances: ReadonlyArray<number>;
+    };
 }
 /**
  * Build a {@link FontMeasure} over a parsed font.

package/dist/esm/core/font/measure.js

@@ -52,6 +52,13 @@ function createFontMeasure(parsed, kern = true) {
 		if (hex !== "") parts.push(`<${hex}>`);
 		return `[${parts.join(" ")}] TJ`;
 	};
+	const glyphRun = (text) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		return {
+			gids: shaped.gids,
+			advances: shaped.advances
+		};
+	};
 	const glyf = parsed.tables.get("glyf");
 	const glyphInk = (gid) => {
 		if (!glyf || gid < 0 || gid >= parsed.numGlyphs) return void 0;
@@ -92,7 +99,8 @@ function createFontMeasure(parsed, kern = true) {
 		textWidthPt,
 		textInkPt,
 		encodeTextAsCidHex,
-		showText
+		showText,
+		glyphRun
 	};
 }
 //#endregion

package/dist/esm/core/fonts/families.js

@@ -28,8 +28,10 @@ function familiesInFlow(flow) {
 		for (const el of elements) if (el.kind === "paragraph") {
 			add(el.paragraph.properties.runProperties?.fontFamily?.ascii);
 			for (const run of el.paragraph.runs) add(run.properties.fontFamily?.ascii);
-		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape") shapeText(el.shape);
+		} else if (el.kind === "table") {
+			for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+			visit(el.table.overlay?.drawings ?? []);
+		} else if (el.kind === "shape") shapeText(el.shape);
 	};
 	visit(flow.body);
 	for (const band of flow.headersFooters?.values() ?? []) visit(band);

package/dist/esm/core/fonts/scripts.js

@@ -163,8 +163,10 @@ function scriptsInFlow(flow) {
 	};
 	const visit = (elements) => {
 		for (const el of elements) if (el.kind === "paragraph") for (const run of el.paragraph.runs) read(run.text);
-		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape") shapeText(el.shape);
+		else if (el.kind === "table") {
+			for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+			visit(el.table.overlay?.drawings ?? []);
+		} else if (el.kind === "shape") shapeText(el.shape);
 	};
 	visit(flow.body);
 	for (const band of flow.headersFooters?.values() ?? []) visit(band);

package/dist/esm/core/ir/flow.d.ts

@@ -155,4 +155,10 @@ export interface FlowDoc {
      * room.
      */
     readonly typesetBy?: 'word';
+    /**
+     * The document's front floats cover the text under them, as a spreadsheet's
+     * drawings cover its cells: a note's box hides the value beside its cell,
+     * and a chart the figures it sits on. Absent, the text is painted over them.
+     */
+    readonly floatsOverText?: true;
 }

package/dist/esm/core/ir/sheet.d.ts

@@ -13,6 +13,11 @@ export interface SheetChartRef {
     /** Where the anchor puts it, in points from the grid's top-left. */
     readonly xPt?: number;
     readonly yPt?: number;
+    /**
+     * §20.5.2.3 `fPrintsWithSheet="0"` — on the sheet, not on its paper: a
+     * window shows it, a print leaves it out.
+     */
+    readonly screenOnly?: true;
 }
 /**
  * §20.5.2.1 xdr:pic — a picture anchored over a sheet's grid, sized from its
@@ -26,6 +31,11 @@ export interface SheetImageRef {
     /** Where the anchor puts it, in points from the grid's top-left. */
     readonly xPt?: number;
     readonly yPt?: number;
+    /**
+     * §20.5.2.3 `fPrintsWithSheet="0"` — on the sheet, not on its paper: a
+     * window shows it, a print leaves it out.
+     */
+    readonly screenOnly?: true;
 }
 /** One item (label + selection state) in a {@link SheetSlicer}. */
 export interface SheetSlicerItem {
@@ -70,7 +80,35 @@ export interface SheetComment {
     readonly ref: string;
     readonly author?: string;
     readonly text: string;
+    /** The note as written, run by run with each run's own font — the bold "Author:" line included. */
+    readonly runs?: ReadonlyArray<SheetRichRun>;
     readonly threaded: boolean;
+    /**
+     * The note's box, when its legacy VML shape SHOWS it (`<x:Visible/>`):
+     * Excel draws a shown note on the sheet beside its cell, with a line to the
+     * cell's corner, and prints it there when `<pageSetup cellComments>` is
+     * `asDisplayed`. Absent ⇒ the note is only flagged in its cell.
+     */
+    readonly shown?: SheetNoteBox;
+}
+/**
+ * Where a shown note stands and how it is painted. Distances are in points
+ * from the sheet's top-left corner, measured in the file's own column order —
+ * a sheet that reads from the right mirrors them with everything else.
+ */
+export interface SheetNoteBox {
+    readonly xPt: number;
+    readonly yPt: number;
+    readonly widthPt: number;
+    readonly heightPt: number;
+    /** The top-right corner of the cell (or merge) the note belongs to — its line ends there. */
+    readonly cornerXPt: number;
+    readonly cornerYPt: number;
+    readonly fillHex: string;
+    readonly lineHex: string;
+    readonly shadow: boolean;
+    /** The side the note's text is set to; absent ⇒ its start. */
+    readonly textAlign?: 'left' | 'center' | 'right';
 }
 /**
  * A form control resolved against its ctrlProp part (E-SHEET W8): the display
@@ -150,6 +188,11 @@ export interface Sheet {
     readonly images?: ReadonlyArray<SheetImageRef>;
     /** Drawing shapes on this sheet (E-SHEET W2), fully resolved + anchor-ordered. */
     readonly shapes?: ReadonlyArray<ShapeBlock>;
+    /**
+     * The indexes into {@link shapes} of those that do not print with the sheet
+     * (§20.5.2.3 `fPrintsWithSheet="0"`): a window shows them, paper does not.
+     */
+    readonly screenOnlyShapes?: ReadonlySet<number>;
     /**
      * Cell hyperlinks resolved to external URLs (E-SHEET W3); the projection sets
      * `run.href` on covered cells. In-workbook (location-only) links are not carried.

package/dist/esm/core/number-format.d.ts

@@ -50,25 +50,50 @@ export declare function excelSerialToDate(serial: number, date1904: boolean): Da
  */
 export declare function excelSerialFromUtcParts(year: number, month0: number, day: number, date1904: boolean): number;
 /**
- * A General number rounded to the decimals that fit `maxChars` characters.
+ * A General number in its column: the most precise of the ways General may
+ * write it ({@link generalRenderings}) that `fits`.
  *
- * General is not a fixed format: a spreadsheet shows as many decimal places as
- * the column has room for and ROUNDS to that, so 4.3900875881221957 in a
- * column eight characters wide reads 4.390088. We rendered every stored digit
- * and let the cell clip it, which turns the same value into 4.390087 — off by
- * one in the last place shown, with nothing to say a digit was cut.
+ * General is not a fixed format: a spreadsheet shows as many places as the
+ * column has room for and ROUNDS to that, so 4.3900875881221957 in a column
+ * eight characters wide reads 4.390088. We rendered every stored digit and let
+ * the cell clip it, which turns the same value into 4.390087 — off by one in
+ * the last place shown, with nothing to say a digit was cut. A number too wide
+ * for every way of writing it comes back in its finest, and the cell fills
+ * with `#` (CellProperties.hashOnOverflow); one under 1 always fits as `0` or
+ * `-0`, which is what Excel prints in a column too narrow for anything else.
  *
- * The integer part is never dropped: a number too wide even without decimals
- * keeps them all and the cell says so its own way (see hashOnOverflow).
- *
- * `fits` decides, and it must measure in the face this will be DRAWN in rather
- * than count characters against the column's width in the document's unit.
- * Counted that way we produced nine digits for a column that holds nine of
- * Excel's and eight of ours, and the layout clipped the ninth — the very
- * truncation this exists to prevent. Fewer digits than the reference shows is a
- * coarser number; a clipped one is a different number.
+ * `fits` decides whether a rendering has room. The print model asks it in the
+ * document's own terms — the column's width less the padding it carries, in
+ * the font's widest digits — because that is the room Excel gives up places
+ * against, whatever face the page is drawn in.
  *
  * @param rawValue The cell's stored value.
  * @param fits     Whether a rendering will fit the cell.
  */
 export declare function generalToWidth(rawValue: string, fits: (text: string) => boolean): string;
+/**
+ * Every way General may write `value` in `chars` characters, the most precise
+ * first. One rule, measured in Excel's own PDF on chart axes, which give it
+ * nine characters with the sign among them, and in cells, eleven with the
+ * sign apart (2026-10-01/02):
+ *
+ *  - the number as it is, its first 15 significant digits, where that fits:
+ *    0.000012345, 0.0000003, 12345678901;
+ *  - else rounded to fewer places or written in scientific notation, whichever
+ *    keeps the finer last digit — 0.123456789, not 1.23457E-01; 1.23457E-10,
+ *    not 0; 4E-04, not 0, in a column five characters wide — and of two as
+ *    fine, the plain one down to 0.0001 and the scientific one below it: 0.0001
+ *    for 0.000123456 but 1E-05 for 1.00049E-05;
+ *  - a whole part longer than the room only in scientific notation, and never
+ *    with the zeros a mantissa or a fraction ends in: 1E+10, 2.5E+12.
+ *
+ * The digits are the 15 of {@link decimalOf}, rounded half away from zero, so
+ * 1.2345E-05 is 1.235E-05, where `toExponential` rounded the binary double
+ * down to 1.234E-05.
+ *
+ * @param value      The number.
+ * @param chars      How many characters General has.
+ * @param signCounts Whether a minus sign takes one of them.
+ * @returns The renderings, sign included, finest first.
+ */
+export declare function generalRenderings(value: number, chars: number, signCounts?: boolean): Generator<string, void, undefined>;