reamkit 1.15.3 → 1.16.0

package/dist/esm/excel/styles-parser.d.ts

@@ -1,11 +1,39 @@
-import { XlsxStyles } from '../core/spreadsheet-model/index.js';
+import { Dxf, XlsxStyles } from '../core/spreadsheet-model/index.js';
+import { INDEXED_COLORS } from '../core/indexed-colors.js';
+export { INDEXED_COLORS };
 /** The empty style table, returned for a workbook with no (or a malformed) `styles.xml`. */
 export declare const EMPTY_XLSX_STYLES: XlsxStyles;
+/** A workbook theme's colour scheme, slot name → RRGGBB (see `parseTheme`). */
+export type ThemePalette = ReadonlyMap<string, string>;
+/**
+ * Everything a `<color>` in this workbook can point AT: the theme's scheme
+ * (§18.8.3 `theme`) and the legacy palette (§18.8.27 `indexed`), which the
+ * workbook may replace with one of its own.
+ */
+export interface WorkbookColors {
+    readonly theme?: ThemePalette;
+    readonly indexed: ReadonlyArray<string>;
+}
 /**
  * Parse `xl/styles.xml` (§18.8) into the {@link XlsxStyles} table the renderer
  * consumes: custom number formats, fonts, fills, borders, the cell formats
  * (`cellXfs` — each indexing font/fill/border/numFmt + optional alignment) and the
  * differential formats (`dxfs`) conditional formatting applies. Returns
  * {@link EMPTY_XLSX_STYLES} when the root is absent or malformed.
+ *
+ * @param theme The workbook's theme palette, resolving `<color theme="N">`.
+ *              Without it those colours are dropped, and a sheet styled from the
+ *              theme loses every fill and font colour it has.
+ */
+export declare function parseXlsxStyles(data: Uint8Array, theme?: ThemePalette): XlsxStyles;
+/**
+ * Read one §18.8.14 `<dxf>` — the differential format a conditional-format rule
+ * applies on match. Exported because the 2009 extension writes its dxf INSIDE
+ * the rule (`<x14:dxf>`) rather than into the workbook's `<dxfs>` table, and
+ * the sheet reader has to resolve it there.
+ *
+ * @param item   The `<dxf>` node, as parsed.
+ * @param colors The workbook palette, resolving theme and indexed colours.
+ * @returns The format; empty when the node states nothing.
  */
-export declare function parseXlsxStyles(data: Uint8Array): XlsxStyles;
+export declare function parseDxf(item: unknown, colors: WorkbookColors): Dxf;

package/dist/esm/excel/styles-parser.js

@@ -1,7 +1,12 @@
+import { INDEXED_COLORS } from "../core/indexed-colors.js";
+import { applyColorMods } from "../core/drawingml/colors.js";
+import { resolveInternalEntities } from "../core/opc/xml-entities.js";
+import { resolveAlternateContent } from "../core/opc/alternate-content.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/styles-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	textNodeName: "#text",
@@ -24,38 +29,56 @@ var EMPTY_XLSX_STYLES = {
 * (`cellXfs` — each indexing font/fill/border/numFmt + optional alignment) and the
 * differential formats (`dxfs`) conditional formatting applies. Returns
 * {@link EMPTY_XLSX_STYLES} when the root is absent or malformed.
+*
+* @param theme The workbook's theme palette, resolving `<color theme="N">`.
+*              Without it those colours are dropped, and a sheet styled from the
+*              theme loses every fill and font colour it has.
 */
-function parseXlsxStyles(data) {
-	const xml = decoder.decode(data);
+function parseXlsxStyles(data, theme) {
+	const xml = resolveAlternateContent(resolveInternalEntities(decoder.decode(data)));
 	const root = asObject(parser.parse(xml)["styleSheet"]);
 	if (!root) return EMPTY_XLSX_STYLES;
-	const dxfs = parseDxfs(root);
+	const colors = {
+		...theme ? { theme } : {},
+		indexed: parseIndexedColors(root)
+	};
+	const dxfs = parseDxfs(root, colors);
 	return {
 		numFmts: parseNumFmts(root),
-		fonts: parseFonts(root),
-		fills: parseFills(root),
-		borders: parseBorders(root),
+		fonts: parseFonts(root, colors),
+		fills: parseFills(root, colors),
+		borders: parseBorders(root, colors),
 		cellXfs: parseCellXfs(root),
 		...dxfs.length > 0 ? { dxfs } : {}
 	};
 }
-function parseDxfs(root) {
+function parseDxfs(root, colors) {
 	const node = asObject(root["dxfs"]);
 	if (!node) return [];
-	const out = [];
-	for (const item of asArray(node["dxf"])) {
+	return asArray(node["dxf"]).map((item) => parseDxf(item, colors));
+}
+/**
+* Read one §18.8.14 `<dxf>` — the differential format a conditional-format rule
+* applies on match. Exported because the 2009 extension writes its dxf INSIDE
+* the rule (`<x14:dxf>`) rather than into the workbook's `<dxfs>` table, and
+* the sheet reader has to resolve it there.
+*
+* @param item   The `<dxf>` node, as parsed.
+* @param colors The workbook palette, resolving theme and indexed colours.
+* @returns The format; empty when the node states nothing.
+*/
+function parseDxf(item, colors) {
+	{
 		const obj = asObject(item);
-		if (!obj) {
-			out.push({});
-			continue;
-		}
+		if (!obj) return {};
 		const dxf = {};
 		const fontObj = asObject(obj["font"]);
 		if (fontObj) {
 			const font = {};
 			if (hasChild(fontObj, "b")) font.bold = childToggle(fontObj, "b");
 			if (hasChild(fontObj, "i")) font.italic = childToggle(fontObj, "i");
-			const colorHex = colorOf(asObject(fontObj["color"]));
+			if (hasChild(fontObj, "strike")) font.strike = childToggle(fontObj, "strike");
+			const colorHex = colorOf(asObject(fontObj["color"]), colors);
 			if (colorHex) font.colorHex = colorHex;
 			if (Object.keys(font).length > 0) dxf.font = font;
 		}
@@ -64,15 +87,31 @@ function parseDxfs(root) {
 			const fill = {};
 			const pt = strAttr(pf, "patternType");
 			if (pt) fill.patternType = pt;
-			const fg = colorOf(asObject(pf["fgColor"]));
-			const bg = colorOf(asObject(pf["bgColor"]));
+			const fg = colorOf(asObject(pf["fgColor"]), colors);
+			const bg = colorOf(asObject(pf["bgColor"]), colors);
 			if (fg) fill.fgColorHex = fg;
 			if (bg) fill.bgColorHex = bg;
 			if (Object.keys(fill).length > 0) dxf.fill = fill;
 		}
-		out.push(dxf);
+		const numFmtObj = asObject(obj["numFmt"]);
+		const code = numFmtObj ? strAttr(numFmtObj, "formatCode") : void 0;
+		if (code !== void 0 && code.length > 0) dxf.numberFormat = code;
+		const borderObj = asObject(obj["border"]);
+		if (borderObj) {
+			const border = {};
+			for (const side of [
+				"top",
+				"right",
+				"bottom",
+				"left"
+			]) {
+				const edge = parseBorderEdge(asObject(borderObj[side]), colors);
+				if (edge) border[side] = edge;
+			}
+			if (Object.keys(border).length > 0) dxf.border = border;
+		}
+		return dxf;
 	}
-	return out;
 }
 var VALID_BORDER_STYLES = new Set([
 	"none",
@@ -90,7 +129,7 @@ var VALID_BORDER_STYLES = new Set([
 	"mediumDashDotDot",
 	"slantDashDot"
 ]);
-function parseBorders(root) {
+function parseBorders(root, colors) {
 	const node = asObject(root["borders"]);
 	if (!node) return [];
 	const out = [];
@@ -101,15 +140,15 @@ function parseBorders(root) {
 			continue;
 		}
 		const border = {};
-		const top = parseBorderEdge(asObject(obj["top"]));
-		const right = parseBorderEdge(asObject(obj["right"]));
-		const bottom = parseBorderEdge(asObject(obj["bottom"]));
-		const left = parseBorderEdge(asObject(obj["left"]));
+		const top = parseBorderEdge(asObject(obj["top"]), colors);
+		const right = parseBorderEdge(asObject(obj["right"]), colors);
+		const bottom = parseBorderEdge(asObject(obj["bottom"]), colors);
+		const left = parseBorderEdge(asObject(obj["left"]), colors);
 		if (top) border.top = top;
 		if (right) border.right = right;
 		if (bottom) border.bottom = bottom;
 		if (left) border.left = left;
-		const diagonal = parseBorderEdge(asObject(obj["diagonal"]));
+		const diagonal = parseBorderEdge(asObject(obj["diagonal"]), colors);
 		if (diagonal) {
 			border.diagonal = diagonal;
 			if (boolAttr(obj, "diagonalUp")) border.diagonalUp = true;
@@ -119,12 +158,12 @@ function parseBorders(root) {
 	}
 	return out;
 }
-function parseBorderEdge(node) {
+function parseBorderEdge(node, colors) {
 	if (!node) return void 0;
 	const styleRaw = strAttr(node, "style");
 	if (!styleRaw) return void 0;
 	if (!VALID_BORDER_STYLES.has(styleRaw)) return void 0;
-	const colorHex = colorOf(asObject(node["color"]));
+	const colorHex = colorOf(asObject(node["color"]), colors);
 	const edge = { style: styleRaw };
 	if (colorHex) edge.colorHex = colorHex;
 	return edge;
@@ -142,13 +181,16 @@ function parseNumFmts(root) {
 	}
 	return result;
 }
-function parseFonts(root) {
+function parseFonts(root, colors) {
 	const node = asObject(root["fonts"]);
 	if (!node) return [];
 	const out = [];
 	for (const item of asArray(node["font"])) {
 		const obj = asObject(item);
-		if (!obj) continue;
+		if (!obj) {
+			out.push({});
+			continue;
+		}
 		const font = {};
 		const sz = childValAttr(obj, "sz");
 		if (sz !== void 0) {
@@ -157,8 +199,9 @@ function parseFonts(root) {
 		}
 		if (hasChild(obj, "b")) font.bold = childToggle(obj, "b");
 		if (hasChild(obj, "i")) font.italic = childToggle(obj, "i");
-		if (hasChild(obj, "u")) font.underline = childToggle(obj, "u");
-		const colorRgb = colorOf(asObject(obj["color"]));
+		if (hasChild(obj, "u")) font.underline = childUnderline(obj);
+		if (hasChild(obj, "strike")) font.strike = childToggle(obj, "strike");
+		const colorRgb = colorOf(asObject(obj["color"]), colors);
 		if (colorRgb) font.colorHex = colorRgb;
 		const nameVal = childValAttr(obj, "name");
 		if (nameVal) font.name = nameVal;
@@ -166,25 +209,28 @@ function parseFonts(root) {
 	}
 	return out;
 }
-function parseFills(root) {
+function parseFills(root, colors) {
 	const node = asObject(root["fills"]);
 	if (!node) return [];
 	const out = [];
 	for (const item of asArray(node["fill"])) {
 		const obj = asObject(item);
-		if (!obj) continue;
+		if (!obj) {
+			out.push({});
+			continue;
+		}
 		const fill = {};
 		const pf = asObject(obj["patternFill"]);
 		if (pf) {
 			const pt = strAttr(pf, "patternType");
 			if (pt) fill.patternType = pt;
-			const fg = colorOf(asObject(pf["fgColor"]));
-			const bg = colorOf(asObject(pf["bgColor"]));
+			const fg = colorOf(asObject(pf["fgColor"]), colors);
+			const bg = colorOf(asObject(pf["bgColor"]), colors);
 			if (fg) fill.fgColorHex = fg;
 			if (bg) fill.bgColorHex = bg;
 		}
 		if (!fill.patternType) {
-			const avg = averageGradientColor(asObject(obj["gradientFill"]));
+			const avg = averageGradientColor(asObject(obj["gradientFill"]), colors);
 			if (avg) {
 				fill.patternType = "solid";
 				fill.fgColorHex = avg;
@@ -200,7 +246,15 @@ function parseCellXfs(root) {
 	const out = [];
 	for (const item of asArray(node["xf"])) {
 		const obj = asObject(item);
-		if (!obj) continue;
+		if (!obj) {
+			out.push({
+				numFmtId: 0,
+				fontId: 0,
+				fillId: 0,
+				borderId: 0
+			});
+			continue;
+		}
 		const xf = {
 			numFmtId: numAttr(obj, "numFmtId") ?? 0,
 			fontId: numAttr(obj, "fontId") ?? 0,
@@ -268,6 +322,14 @@ function childValAttr(obj, childName) {
 function hasChild(obj, childName) {
 	return childName in obj;
 }
+function childUnderline(obj) {
+	const child = obj["u"];
+	if (child === "" || child === null || child === void 0) return true;
+	if (typeof child !== "object") return true;
+	const val = strAttr(child, "val");
+	if (val === void 0) return true;
+	return !(val === "none" || val === "false" || val === "0");
+}
 function childToggle(obj, childName) {
 	const child = obj[childName];
 	if (child === "" || child === null || child === void 0) return true;
@@ -276,7 +338,7 @@ function childToggle(obj, childName) {
 	if (val === void 0) return true;
 	return !(val === "false" || val === "0");
 }
-function averageGradientColor(gf) {
+function averageGradientColor(gf, colors) {
 	if (!gf) return void 0;
 	let r = 0;
 	let g = 0;
@@ -284,7 +346,7 @@ function averageGradientColor(gf) {
 	let n = 0;
 	for (const s of asArray(gf["stop"])) {
 		const so = asObject(s);
-		const hex = so ? colorOf(asObject(so["color"])) : void 0;
+		const hex = so ? colorOf(asObject(so["color"]), colors) : void 0;
 		if (!hex) continue;
 		r += parseInt(hex.slice(0, 2), 16);
 		g += parseInt(hex.slice(2, 4), 16);
@@ -295,13 +357,88 @@ function averageGradientColor(gf) {
 	const h = (x) => Math.round(x / n).toString(16).padStart(2, "0").toUpperCase();
 	return `${h(r)}${h(g)}${h(b)}`;
 }
-function colorOf(node) {
+function colorOf(node, colors) {
 	if (!node) return void 0;
 	const rgb = strAttr(node, "rgb");
 	if (rgb) {
 		if (/^[0-9A-Fa-f]{8}$/.test(rgb)) return rgb.substring(2).toUpperCase();
 		if (/^[0-9A-Fa-f]{6}$/.test(rgb)) return rgb.toUpperCase();
 	}
+	const indexed = strAttr(node, "indexed");
+	if (indexed !== void 0) {
+		const i = Number(indexed);
+		if (Number.isInteger(i) && i >= 0 && i < colors.indexed.length) return colors.indexed[i];
+	}
+	const themeIdx = strAttr(node, "theme");
+	if (themeIdx !== void 0 && colors.theme) {
+		const slot = THEME_SLOTS[Number(themeIdx)];
+		const base = slot ? colors.theme.get(slot) : void 0;
+		if (base) return applyTint(base, Number(strAttr(node, "tint") ?? "0"));
+	}
+}
+/** §18.8.27 — the indexed palette proper; 56 and 57+ are system colours. */
+var PALETTE_ENTRIES = 56;
+/**
+* §18.8.27 `<colors><indexedColors>` — the workbook's OWN legacy palette. It
+* replaces the built-in one wholesale (Excel writes all 56 entries), and a
+* workbook that ships one means it: customIndexedColors.xlsx paints a cell from
+* index 61, which is a plum in the default table and the light grey #E8E8E8 in
+* its own.
+*/
+function parseIndexedColors(root) {
+	const colors = asObject(root["colors"]);
+	const node = colors ? asObject(colors["indexedColors"]) : void 0;
+	if (!node) return INDEXED_COLORS;
+	const out = [];
+	for (const item of asArray(node["rgbColor"])) {
+		const obj = asObject(item);
+		const rgb = obj ? strAttr(obj, "rgb") : void 0;
+		if (rgb === void 0) break;
+		const hex = rgb.length === 8 ? rgb.slice(2) : rgb;
+		if (!/^[0-9A-Fa-f]{6}$/.test(hex)) break;
+		out.push(hex.toUpperCase());
+	}
+	if (out.length < PALETTE_ENTRIES) return INDEXED_COLORS;
+	return [...out, ...INDEXED_COLORS.slice(out.length)];
+}
+/**
+* ECMA-376 §18.8.3 `<color theme>` — the index into the workbook theme's colour
+* scheme. Excel's order is NOT the order the theme part declares them in: the
+* first two slots are swapped, so `theme="0"` is the light background and
+* `theme="1"` the dark text, while `theme1.xml` writes `dk1` before `lt1`.
+*/
+var THEME_SLOTS = [
+	"lt1",
+	"dk1",
+	"lt2",
+	"dk2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+/**
+* §18.8.19 `tint` — lighten (positive) or darken (negative) a theme colour by
+* scaling its HSL luminance. Excel writes it on nearly every theme colour it
+* uses, so ignoring it is not much better than ignoring the colour: a `theme="2"
+* tint="-0.5"` band is half as light as its slot.
+*/
+function applyTint(hex, tint) {
+	if (!Number.isFinite(tint) || tint === 0) return hex;
+	return tint < 0 ? applyColorMods(hex, [{
+		kind: "lumMod",
+		val: 1 + tint
+	}]) : applyColorMods(hex, [{
+		kind: "lumMod",
+		val: 1 - tint
+	}, {
+		kind: "lumOff",
+		val: tint
+	}]);
 }
 //#endregion
-export { EMPTY_XLSX_STYLES, parseXlsxStyles };
+export { EMPTY_XLSX_STYLES, parseDxf, parseXlsxStyles };

package/dist/esm/excel/table-parser.js

@@ -3,6 +3,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/excel/table-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,

package/dist/esm/excel/vml-drawing.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Where a VML shape sits, in points from the sheet's top-left — read from the
+ * CSS `style` attribute (`margin-left`/`margin-top`/`width`/`height`).
+ *
+ * The same rectangle is also expressed by `<x:ClientData><x:Anchor>` as
+ * (column, offset px, row, offset px) pairs, which needs the sheet's column
+ * widths and row heights to resolve. The style is already absolute, and the two
+ * agree exactly in every file checked, so this reads the simpler one.
+ */
+export interface VmlShapeBox {
+    readonly xPt: number;
+    readonly yPt: number;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+/** A form control declared by a legacy VML shape's `<x:ClientData>`. */
+export interface VmlFormControl {
+    /** `ST_ObjectType` — `Radio`, `CheckBox`, `GBox`, `Button`, `Drop`, … */
+    readonly objectType: string;
+    /** The shape id (`o:spid` without its `_x0000_s` prefix), pairing with `<control shapeId>`. */
+    readonly shapeId?: string;
+    /** The visible label, from the shape's `<v:textbox>`. */
+    readonly caption?: string;
+    /** `<x:Checked>` — set on a checked check/option button, absent otherwise. */
+    readonly checked?: boolean;
+    /** `<x:FirstButton/>` — this option button starts a new group. */
+    readonly firstButton?: boolean;
+    /** Where the control sits, from the shape's `style` (§{@link VmlShapeBox}). */
+    readonly box?: VmlShapeBox;
+    /** `<v:textbox><font size>` — twentieths of a point, so 160 is 8pt. */
+    readonly fontSizePt?: number;
+}
+/** A parsed legacy VML drawing: its form controls plus every shape's box. */
+export interface VmlDrawing {
+    readonly controls: ReadonlyArray<VmlFormControl>;
+    /**
+     * Shape id (`o:spid` without its `_x0000_s` prefix) → box, for EVERY shape in
+     * the part, controls or not. An ActiveX control's box lives nowhere else: its
+     * `activeX#.xml` carries only a class id and its `<control>` element carries
+     * no anchor, so the `ObjectType="Pict"` shape that shares its `shapeId` is
+     * the one thing that says where it goes.
+     */
+    readonly boxes: ReadonlyMap<string, VmlShapeBox>;
+    /**
+     * Shape ids whose `<x:ClientData>` clears `<x:PrintObject>` — Excel's "Print
+     * object" checkbox, the legacy spelling of §18.3.1.20 `<controlPr print>`.
+     * Such a shape is on screen only, and the `<control>` that shares its id must
+     * not be drawn either.
+     */
+    readonly nonPrinting: ReadonlySet<string>;
+}
+/**
+ * Read the form controls out of a legacy VML drawing part.
+ *
+ * Shapes with no `<x:ClientData>`, or whose object type is not a control (a
+ * comment, a text box, a picture), are skipped — this is not a general VML
+ * shape reader, only the control channel. See {@link CONTROL_TYPES}.
+ *
+ * @param data The raw `vmlDrawing#.vml` bytes.
+ * @returns One entry per control shape, in document order.
+ */
+export declare function parseVmlFormControls(data: Uint8Array): Array<VmlFormControl>;
+/**
+ * Read a legacy VML drawing part: its form controls and every shape's box.
+ *
+ * @param data The raw `vmlDrawing#.vml` bytes.
+ */
+export declare function parseVmlDrawing(data: Uint8Array): VmlDrawing;

package/dist/esm/excel/vml-drawing.js

@@ -0,0 +1,158 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/vml-drawing.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	htmlEntities: true,
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	removeNSPrefix: true
+});
+var SPID_PREFIX = /^_x0000_s/;
+/**
+* The `x:ObjectType` values that name a FORM CONTROL.
+*
+* Not everything with an `<x:ClientData>` is one — a cell comment is a VML
+* shape with `ObjectType="Note"`, and so are text boxes, pictures and movies.
+* Taking the element's presence as the test listed every comment in the
+* document as a form control.
+*/
+var CONTROL_TYPES = new Set([
+	"Button",
+	"Checkbox",
+	"CheckBox",
+	"Dialog",
+	"Drop",
+	"Edit",
+	"EditBox",
+	"GBox",
+	"Label",
+	"List",
+	"Radio",
+	"Scroll",
+	"Spin"
+]);
+/**
+* Read a legacy VML drawing part: its form controls and every shape's box.
+*
+* @param data The raw `vmlDrawing#.vml` bytes.
+*/
+function parseVmlDrawing(data) {
+	const tree = parser.parse(decoder.decode(data));
+	const root = asObject(tree["xml"]) ?? tree;
+	const out = [];
+	const boxes = /* @__PURE__ */ new Map();
+	const nonPrinting = /* @__PURE__ */ new Set();
+	for (const raw of asArray(root["shape"])) {
+		const shape = asObject(raw);
+		if (!shape) continue;
+		const idAttr = strAttr(shape, "id");
+		const shapeId = (strAttr(shape, "spid") ?? (idAttr !== void 0 && SPID_PREFIX.test(idAttr) ? idAttr : void 0))?.replace(SPID_PREFIX, "");
+		const box = shapeBox(strAttr(shape, "style"));
+		if (shapeId && box) boxes.set(shapeId, box);
+		const client = asObject(shape["ClientData"]);
+		if (!client) continue;
+		if (!(flatText(client["PrintObject"])?.toLowerCase() !== "false")) {
+			if (shapeId) nonPrinting.add(shapeId);
+			continue;
+		}
+		const objectType = strAttr(client, "ObjectType");
+		if (!objectType || !CONTROL_TYPES.has(objectType)) continue;
+		const control = { objectType };
+		if (shapeId) control.shapeId = shapeId;
+		if (box) control.box = box;
+		const caption = textboxText(shape["textbox"]);
+		if (caption) control.caption = caption;
+		const fontSizePt = textboxFontSizePt(shape["textbox"]);
+		if (fontSizePt !== void 0) control.fontSizePt = fontSizePt;
+		if (flatText(client["Checked"]) === "1") control.checked = true;
+		if ("FirstButton" in client) control.firstButton = true;
+		out.push(control);
+	}
+	return {
+		controls: out,
+		boxes,
+		nonPrinting
+	};
+}
+/** CSS length → points. A bare number is pixels, VML's implicit unit. */
+var CSS_UNITS = new Map([
+	["pt", 1],
+	["px", .75],
+	["in", 72],
+	["cm", 72 / 2.54],
+	["mm", 7.2 / 2.54],
+	["pc", 12]
+]);
+function cssLengthPt(value) {
+	if (value === void 0) return void 0;
+	const m = /^\s*(-?[\d.]+)\s*([a-z]*)\s*$/i.exec(value);
+	if (!m) return void 0;
+	const n = Number(m[1]);
+	if (!Number.isFinite(n)) return void 0;
+	const unit = m[2].toLowerCase();
+	const factor = unit === "" ? .75 : CSS_UNITS.get(unit);
+	return factor === void 0 ? void 0 : n * factor;
+}
+/** The shape's rectangle from its `style` declaration; undefined if incomplete. */
+function shapeBox(style) {
+	if (style === void 0) return void 0;
+	const props = /* @__PURE__ */ new Map();
+	for (const decl of style.split(";")) {
+		const i = decl.indexOf(":");
+		if (i < 0) continue;
+		props.set(decl.slice(0, i).trim().toLowerCase(), decl.slice(i + 1).trim());
+	}
+	const widthPt = cssLengthPt(props.get("width"));
+	const heightPt = cssLengthPt(props.get("height"));
+	if (widthPt === void 0 || heightPt === void 0) return void 0;
+	return {
+		xPt: cssLengthPt(props.get("margin-left")) ?? 0,
+		yPt: cssLengthPt(props.get("margin-top")) ?? 0,
+		widthPt,
+		heightPt
+	};
+}
+/** `<v:textbox>`'s `<font size>` — twentieths of a point (160 ⇒ 8pt). */
+function textboxFontSizePt(node) {
+	const box = asObject(node);
+	const font = asObject(((box ? asObject(box["div"]) : void 0) ?? box)?.["font"]);
+	const size = font ? strAttr(font, "size") : void 0;
+	const twips = size === void 0 ? NaN : Number(size);
+	return Number.isFinite(twips) && twips > 0 ? twips / 20 : void 0;
+}
+/** The visible text of a `<v:textbox>`, whose content is an HTML fragment. */
+function textboxText(node) {
+	const text = flatText(node);
+	if (text === void 0) return void 0;
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	return collapsed.length > 0 ? collapsed : void 0;
+}
+/** Every text node under `node`, concatenated — the element tree flattened. */
+function flatText(node) {
+	if (node === void 0 || node === null) return void 0;
+	if (typeof node === "string") return node;
+	if (typeof node === "number" || typeof node === "boolean") return String(node);
+	if (Array.isArray(node)) return node.map((n) => flatText(n) ?? "").join("");
+	if (typeof node !== "object") return void 0;
+	let out = "";
+	for (const [key, value] of Object.entries(node)) {
+		if (key.startsWith("@_")) continue;
+		out += flatText(value) ?? "";
+	}
+	return out;
+}
+function asObject(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+	return Array.isArray(value) ? value : value === void 0 ? [] : [value];
+}
+function strAttr(obj, name) {
+	const v = obj[`@_${name}`];
+	return typeof v === "string" ? v : typeof v === "number" ? String(v) : void 0;
+}
+//#endregion
+export { parseVmlDrawing };

package/dist/esm/excel/workbook-parser.d.ts

@@ -7,6 +7,11 @@ export interface SheetReference {
     readonly sheetId: string;
     /** The relationship id (`r:id`) resolving to the sheet's worksheet part. */
     readonly relationshipId: string;
+    /**
+     * §18.2.19 `@state` — `hidden` or `veryHidden` when the tab is not shown.
+     * Excel and LibreOffice print only visible sheets.
+     */
+    readonly hidden?: boolean;
 }
 /** The parsed `workbook.xml`: the ordered sheet list, the date epoch and defined names. */
 export interface ParsedWorkbook {

package/dist/esm/excel/workbook-parser.js

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/excel/workbook-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	textNodeName: "#text",
@@ -42,10 +43,13 @@ function parseWorkbook(data) {
 		const sheetId = strAttr(obj, "sheetId");
 		const rId = strAttr(obj, "r:id") ?? strAttr(obj, "id");
 		if (!name || !rId) continue;
+		const state = strAttr(obj, "state");
+		const hidden = state === "hidden" || state === "veryHidden";
 		out.push({
 			name,
 			sheetId: sheetId ?? "",
-			relationshipId: rId
+			relationshipId: rId,
+			...hidden ? { hidden } : {}
 		});
 	}
 	return {