reamkit 1.15.3 → 1.16.0

package/dist/esm/core/opc/alternate-content.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Replace every `<mc:AlternateContent>` with the markup its `<mc:Fallback>`
+ * holds, so the part reaching the XML parser is plain OOXML in its original
+ * element order. A block with no Fallback resolves to nothing — which is what
+ * §10.2 of the Markup Compatibility spec asks of a reader that understands
+ * none of the offered choices.
+ *
+ * Text with no AlternateContent is returned unchanged, which is most files.
+ *
+ * @param xml The decoded part, as read from the package.
+ * @returns The part with its compatibility blocks resolved.
+ */
+export declare function resolveAlternateContent(xml: string): string;

package/dist/esm/core/opc/alternate-content.js

@@ -0,0 +1,72 @@
+//#region src/core/opc/alternate-content.ts
+/** Deepest nesting of one AlternateContent inside another that we will unwrap. */
+var MAX_DEPTH = 8;
+var OPEN = /<(?:[A-Za-z_][\w.-]*:)?AlternateContent(?=[\s/>])/g;
+/**
+* Find the element starting at `from` (the index of its `<`) and return the
+* span of its content plus the index just past its closing tag. Returns
+* undefined for an unclosed element — malformed markup we leave alone.
+*/
+function elementAt(xml, from, local) {
+	const nameEnd = xml.indexOf(">", from);
+	if (nameEnd < 0) return void 0;
+	if (xml[nameEnd - 1] === "/") return {
+		inner: "",
+		end: nameEnd + 1
+	};
+	const open = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${local}(?=[\\s/>])`, "g");
+	const close = new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${local}\\s*>`, "g");
+	let depth = 1;
+	let cursor = nameEnd + 1;
+	while (depth > 0) {
+		close.lastIndex = cursor;
+		const shut = close.exec(xml);
+		if (!shut) return void 0;
+		open.lastIndex = cursor;
+		for (let o = open.exec(xml); o && o.index < shut.index; o = open.exec(xml)) if (xml[xml.indexOf(">", o.index) - 1] !== "/") depth++;
+		depth--;
+		cursor = shut.index + shut[0].length;
+		if (depth === 0) return {
+			inner: xml.slice(nameEnd + 1, shut.index),
+			end: cursor
+		};
+	}
+}
+/** The content of the first `<mc:Fallback>` directly inside `inner`, or ''. */
+function fallbackOf(inner) {
+	const at = (/* @__PURE__ */ new RegExp("<(?:[A-Za-z_][\\w.-]*:)?Fallback(?=[\\s/>])")).exec(inner);
+	if (!at) return "";
+	return elementAt(inner, at.index, "Fallback")?.inner ?? "";
+}
+/**
+* Replace every `<mc:AlternateContent>` with the markup its `<mc:Fallback>`
+* holds, so the part reaching the XML parser is plain OOXML in its original
+* element order. A block with no Fallback resolves to nothing — which is what
+* §10.2 of the Markup Compatibility spec asks of a reader that understands
+* none of the offered choices.
+*
+* Text with no AlternateContent is returned unchanged, which is most files.
+*
+* @param xml The decoded part, as read from the package.
+* @returns The part with its compatibility blocks resolved.
+*/
+function resolveAlternateContent(xml) {
+	let out = xml;
+	for (let pass = 0; pass < MAX_DEPTH; pass++) {
+		if (!out.includes("AlternateContent")) return out;
+		let cursor = 0;
+		let next = "";
+		OPEN.lastIndex = 0;
+		for (let found = OPEN.exec(out); found; found = OPEN.exec(out)) {
+			const el = elementAt(out, found.index, "AlternateContent");
+			if (!el) break;
+			next += out.slice(cursor, found.index) + fallbackOf(el.inner);
+			cursor = el.end;
+			OPEN.lastIndex = cursor;
+		}
+		out = next + out.slice(cursor);
+	}
+	return out;
+}
+//#endregion
+export { resolveAlternateContent };

package/dist/esm/core/opc/core-properties.js

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/core/opc/core-properties.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	textNodeName: "#text",

package/dist/esm/core/opc/package.d.ts

@@ -28,6 +28,7 @@ export declare class OpcPackage {
      */
     private constructor();
     private readonly relsCache;
+    private folded;
     /**
      * Unzip and validate a package's bytes. Rejects an OLE compound file (an
      * encrypted OOXML container or a legacy binary `.doc`/`.xls`) and enforces the
@@ -37,8 +38,20 @@ export declare class OpcPackage {
      *         `_rels/.rels` is missing.
      */
     static open(buffer: Uint8Array, options?: OpcOpenOptions): OpcPackage;
-    /** The bytes of the part at `path`, or undefined when absent. */
+    /**
+     * The bytes of the part at `path`, or undefined when absent.
+     *
+     * OPC part names are compared case-insensitively (ISO/IEC 29500-2 §9.1.1.1),
+     * so two names differing only in case are the SAME part. Producers do mix
+     * them: 123233_charts.xlsx writes `xl/worksheets/Sheet1.xml` and its
+     * relationships as `_rels/sheet1.xml.rels`, and an exact lookup found no
+     * relationships for that sheet at all — which cost it four charts, silently,
+     * because a sheet with no drawing rel is indistinguishable from one with no
+     * drawing. An exact hit still wins; the fold is only a fallback.
+     */
     getPart(path: string): Uint8Array | undefined;
+    /** Parts keyed by their case-folded path, built once on first miss. */
+    private foldedParts;
     /**
      * The bytes of the part at `path`.
      *

package/dist/esm/core/opc/package.js

@@ -19,6 +19,7 @@ var OpcPackage = class OpcPackage {
 		this.rootRelationships = rootRelationships;
 	}
 	relsCache = /* @__PURE__ */ new Map();
+	folded;
 	/**
 	* Unzip and validate a package's bytes. Rejects an OLE compound file (an
 	* encrypted OOXML container or a legacy binary `.doc`/`.xls`) and enforces the
@@ -37,7 +38,7 @@ var OpcPackage = class OpcPackage {
 		let total = 0;
 		let count = 0;
 		let violation;
-		const entries = unzipSync(buffer, { filter: (info) => {
+		const entries = unzipGuarded(buffer, { filter: (info) => {
 			if (++count > maxEntries) {
 				violation ??= `more than ${maxEntries} entries`;
 				return false;
@@ -61,9 +62,32 @@ var OpcPackage = class OpcPackage {
 		if (!relsBytes) throw new Error(`OPC package missing ${ROOT_RELS_PATH}`);
 		return new OpcPackage(parts, parseRelationships(relsBytes));
 	}
-	/** The bytes of the part at `path`, or undefined when absent. */
+	/**
+	* The bytes of the part at `path`, or undefined when absent.
+	*
+	* OPC part names are compared case-insensitively (ISO/IEC 29500-2 §9.1.1.1),
+	* so two names differing only in case are the SAME part. Producers do mix
+	* them: 123233_charts.xlsx writes `xl/worksheets/Sheet1.xml` and its
+	* relationships as `_rels/sheet1.xml.rels`, and an exact lookup found no
+	* relationships for that sheet at all — which cost it four charts, silently,
+	* because a sheet with no drawing rel is indistinguishable from one with no
+	* drawing. An exact hit still wins; the fold is only a fallback.
+	*/
 	getPart(path) {
-		return this.parts.get(normalizePath(path));
+		const normalized = normalizePath(path);
+		return this.parts.get(normalized) ?? this.foldedParts().get(normalized.toLowerCase());
+	}
+	/** Parts keyed by their case-folded path, built once on first miss. */
+	foldedParts() {
+		if (!this.folded) {
+			const folded = /* @__PURE__ */ new Map();
+			for (const [path, data] of this.parts) {
+				const key = path.toLowerCase();
+				if (!folded.has(key)) folded.set(key, data);
+			}
+			this.folded = folded;
+		}
+		return this.folded;
 	}
 	/**
 	* The bytes of the part at `path`.
@@ -92,7 +116,7 @@ var OpcPackage = class OpcPackage {
 		const dir = slash >= 0 ? normalized.substring(0, slash) : "";
 		const base = slash >= 0 ? normalized.substring(slash + 1) : normalized;
 		const relsPath = dir.length > 0 ? `${dir}/_rels/${base}.rels` : `_rels/${base}.rels`;
-		const data = this.parts.get(relsPath);
+		const data = this.getPart(relsPath);
 		const rels = data ? parseRelationships(data) : [];
 		this.relsCache.set(normalized, rels);
 		return rels;
@@ -162,5 +186,20 @@ function collapseDotSegments(p) {
 	}
 	return out.join("/");
 }
+/**
+* {@link unzipSync}, with a decompression failure turned into a named refusal.
+*
+* @param buffer  The archive bytes.
+* @param options The fflate options (the zip-bomb entry filter).
+* @returns The decompressed entries.
+* @throws Error naming the archive as invalid when inflation fails.
+*/
+function unzipGuarded(buffer, options) {
+	try {
+		return unzipSync(buffer, options);
+	} catch (e) {
+		throw new Error(`invalid zip data: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
 //#endregion
 export { OpcPackage };

package/dist/esm/core/opc/relationships.js

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

package/dist/esm/core/opc/xml-entities.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolve the entities an internal DTD subset declares and remove the subset,
+ * so what reaches the XML parser is a well-formed part with no `&name;` left
+ * to leak. Markup inside an entity value is escaped to text rather than
+ * spliced in — an entity that opens a tag is a document we will not build.
+ *
+ * Text with no `<!DOCTYPE` is returned unchanged, which is every real file.
+ *
+ * @param xml The decoded part, as read from the package.
+ * @returns The part with its internal subset resolved and stripped.
+ */
+export declare function resolveInternalEntities(xml: string): string;

package/dist/esm/core/opc/xml-entities.js

@@ -0,0 +1,91 @@
+//#region src/core/opc/xml-entities.ts
+/** Longest text any one declared entity may expand to. */
+var MAX_EXPANSION = 65536;
+/** Longest total the substitutions may add to one part. */
+var MAX_TOTAL = 1048576;
+var DOCTYPE = /<!DOCTYPE\s[^[>]*(?:\[[\s\S]*?\]\s*)?>/;
+var ENTITY_DECL = /<!ENTITY\s+([^\s%<>&;]+)\s+(?:"([^"]*)"|'([^']*)')\s*>/g;
+var REFERENCE = /&([^\s;&<>]+);/g;
+/** The five entities XML predefines; a declaration never overrides them. */
+var PREDEFINED = new Set([
+	"lt",
+	"gt",
+	"amp",
+	"apos",
+	"quot"
+]);
+/** Escape resolved text so it re-enters the document as characters, not markup. */
+function escape(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+* Substitute every entity reference in `text` using `valueOf`, leaving the
+* predefined and numeric references for the XML parser. Returns undefined once
+* the result passes `cap` — the caller drops what it was building.
+*/
+function substitute(text, cap, valueOf) {
+	if (!text.includes("&")) return text.length > cap ? void 0 : text;
+	let out = "";
+	let last = 0;
+	for (const m of text.matchAll(REFERENCE)) {
+		const name = m[1] ?? "";
+		out += text.slice(last, m.index);
+		last = m.index + m[0].length;
+		out += PREDEFINED.has(name) || name.startsWith("#") ? m[0] : valueOf(name);
+		if (out.length > cap) return void 0;
+	}
+	out += text.slice(last);
+	return out.length > cap ? void 0 : out;
+}
+/**
+* Expand each declaration once, so a name referenced ten thousand times costs
+* one expansion rather than ten thousand. A cycle, an undeclared name and a
+* value that outgrows MAX_EXPANSION all resolve to the empty string: XML says
+* such a document is in error, and drawing the reference's own spelling is the
+* one answer that is certainly wrong.
+*/
+function expander(declared) {
+	const done = /* @__PURE__ */ new Map();
+	const active = /* @__PURE__ */ new Set();
+	const valueOf = (name) => {
+		const memo = done.get(name);
+		if (memo !== void 0) return memo;
+		if (active.has(name)) return "";
+		const raw = declared.get(name);
+		if (raw === void 0) return "";
+		active.add(name);
+		const out = substitute(raw, MAX_EXPANSION, valueOf) ?? "";
+		active.delete(name);
+		done.set(name, out);
+		return out;
+	};
+	return valueOf;
+}
+/**
+* Resolve the entities an internal DTD subset declares and remove the subset,
+* so what reaches the XML parser is a well-formed part with no `&name;` left
+* to leak. Markup inside an entity value is escaped to text rather than
+* spliced in — an entity that opens a tag is a document we will not build.
+*
+* Text with no `<!DOCTYPE` is returned unchanged, which is every real file.
+*
+* @param xml The decoded part, as read from the package.
+* @returns The part with its internal subset resolved and stripped.
+*/
+function resolveInternalEntities(xml) {
+	if (!xml.includes("<!DOCTYPE")) return xml;
+	const doctype = DOCTYPE.exec(xml);
+	if (!doctype) return xml;
+	const declared = /* @__PURE__ */ new Map();
+	for (const decl of doctype[0].matchAll(ENTITY_DECL)) {
+		const name = decl[1];
+		if (name === void 0 || name.startsWith("%") || PREDEFINED.has(name)) continue;
+		if (!declared.has(name)) declared.set(name, decl[2] ?? decl[3] ?? "");
+	}
+	const body = xml.slice(0, doctype.index) + xml.slice(doctype.index + doctype[0].length);
+	if (!body.includes("&")) return body;
+	const valueOf = expander(declared);
+	return substitute(body, MAX_TOTAL, (name) => escape(valueOf(name))) ?? substitute(body, MAX_TOTAL, () => "") ?? body;
+}
+//#endregion
+export { resolveInternalEntities };

package/dist/esm/core/spreadsheet-model/index.d.ts

@@ -1 +1 @@
-export type { CellType, WorksheetCell, ColumnWidth, MergedRange, RowHeight, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, ParsedWorksheet, XlsxFont, XlsxFill, XlsxBorderStyleName, XlsxBorderEdge, XlsxBorder, XlsxHorizontalAlign, XlsxVerticalAlign, XlsxCellAlignment, XlsxCellXf, XlsxStyles, DefinedName, Dxf, CfOperator, CfRuleCellIs, CfvoType, Cfvo, CfRuleColorScale, CfRuleDataBar, CfRuleIconSet, CfRuleTop10, CfRuleAboveAverage, CfRuleDupUnique, CfRuleText, CfRuleExpression, CfRuleTimePeriod, TimePeriodKind, CfRule, ConditionalFormat, DataValidationType, DataValidation, HyperlinkRef, HeaderFooter, FormControlRef, OleObjectRef, SheetRichRun, SparklineKind, ParsedSparkline, ExcelTable, PivotTable, SheetPane, } from './types.js';
+export type { CellType, WorksheetCell, ColumnStyle, ColumnWidth, MergedRange, RowHeight, RowStyle, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, ParsedWorksheet, XlsxFont, XlsxFill, XlsxBorderStyleName, XlsxBorderEdge, XlsxBorder, XlsxHorizontalAlign, XlsxVerticalAlign, XlsxCellAlignment, XlsxCellXf, XlsxStyles, DefinedName, Dxf, CfOperator, CfRuleCellIs, CfvoType, Cfvo, CfRuleColorScale, CfRuleDataBar, CfRuleIconSet, CfRuleTop10, CfRuleAboveAverage, CfRuleDupUnique, CfRuleText, CfRuleExpression, CfRuleTimePeriod, TimePeriodKind, CfRule, ConditionalFormat, DataValidationType, DataValidation, HyperlinkRef, HeaderFooter, FormControlRef, OleObjectRef, SheetRichRun, SparklineKind, ParsedSparkline, ExcelTable, PivotTable, SheetPane, } from './types.js';

package/dist/esm/core/spreadsheet-model/types.d.ts

@@ -11,12 +11,40 @@ export interface WorksheetCell {
     readonly inlineText?: string;
     /** Index into the workbook's `cellXfs` (`xl/styles.xml`). 0 means default style. */
     readonly styleIndex?: number;
+    /**
+     * §18.3.1.4 `vm` — 1-based index into `xl/metadata.xml`'s `<valueMetadata>`.
+     * A cell whose value is a rich value stores a legacy error in `<v>` for
+     * readers that predate the feature, and points here for the real one.
+     */
+    readonly valueMetadataIndex?: number;
 }
 /** §18.3.1.13 `<col>` — a width (in character units) for the column span `min..max`. */
 export interface ColumnWidth {
     readonly min: number;
     readonly max: number;
     readonly widthChars: number;
+    /** §18.3.1.13 `hidden` — Excel and LibreOffice print neither the column nor its cells. */
+    readonly hidden?: boolean;
+}
+/**
+ * §18.3.1.13 `<col style>` / §18.3.1.73 `<row s customFormat>` — the style a
+ * cell takes when the file gives it none of its own.
+ *
+ * A spreadsheet formats whole columns and whole rows without writing a `<c>`
+ * for each one: 51710.xlsx paints its column A grey with a single `<col
+ * min="1" max="1" style="1"/>`, and 588 of its rows carry no A cell at all.
+ * The band is on the page in Excel and in LibreOffice, so the default has to
+ * reach the paint even where there is nothing to paint it on.
+ */
+export interface ColumnStyle {
+    readonly min: number;
+    readonly max: number;
+    readonly styleIndex: number;
+}
+/** §18.3.1.73 — the style a row hands to its unwritten cells. */
+export interface RowStyle {
+    readonly row: number;
+    readonly styleIndex: number;
 }
 /** §18.3.1.55 `<mergeCell>` — a merged cell rectangle (0-indexed, inclusive bounds). */
 export interface MergedRange {
@@ -34,6 +62,8 @@ export interface RowHeight {
     readonly row: number;
     readonly heightPt: number;
     readonly customHeight: boolean;
+    /** §18.3.1.73 `hidden` — the row is not printed at all. */
+    readonly hidden?: boolean;
 }
 /** ECMA-376 Part 1 §18.3.1.62 — `<pageMargins>`. All attributes are in inches. */
 export interface XlsxPageMargins {
@@ -59,6 +89,18 @@ export interface XlsxPageSetup {
     readonly fitToWidth?: number;
     /** Number of pages tall to fit to; default 1. */
     readonly fitToHeight?: number;
+    /**
+     * `r:id` of the sheet's `printerSettings` part. When `paperSize` is absent the
+     * paper is whatever that part's DEVMODE says, which is how Excel records the
+     * choice made in the print dialog rather than in the sheet.
+     */
+    readonly printerSettingsRelId?: string;
+    /**
+     * §18.3.1.63 `cellComments` — where the sheet's notes are printed:
+     * `none` (the default) prints none of them, `asDisplayed` prints them where
+     * they float, `atEnd` gathers them after the grid.
+     */
+    readonly cellComments?: 'none' | 'asDisplayed' | 'atEnd';
 }
 /**
  * ECMA-376 Part 1 §18.3.1.70 — `<printOptions>`. Controls what is rendered when
@@ -68,6 +110,11 @@ export interface XlsxPageSetup {
  */
 export interface XlsxPrintOptions {
     readonly gridLines?: boolean;
+    /**
+     * §18.3.1.70 `headings` — print the column letters across the top and the row
+     * numbers down the left, the way the sheet looks on screen. Off by default.
+     */
+    readonly headings?: boolean;
     readonly horizontalCentered?: boolean;
     readonly verticalCentered?: boolean;
 }
@@ -83,6 +130,10 @@ export interface ParsedWorksheet {
     readonly columns: ReadonlyArray<ColumnWidth>;
     readonly merges: ReadonlyArray<MergedRange>;
     readonly rowHeights: ReadonlyArray<RowHeight>;
+    /** §18.3.1.13 `<col style>` — the default style of a whole column span. */
+    readonly columnStyles?: ReadonlyArray<ColumnStyle>;
+    /** §18.3.1.73 `<row s customFormat="1">` — the default style of a whole row. */
+    readonly rowStyles?: ReadonlyArray<RowStyle>;
     /**
      * ECMA-376 §18.3.1.81 `<sheetFormatPr defaultRowHeight>` — the height, in
      * points, of every row that carries no `ht` of its own. A row in a
@@ -120,6 +171,12 @@ export interface ParsedWorksheet {
     readonly colBreaks?: ReadonlyArray<number>;
     /** §18.3.1.36 `<drawing r:id>` — the sheet's drawing part (charts/shapes). */
     readonly drawingRelId?: string;
+    /**
+     * §18.3.1.36 `<legacyDrawing r:id>` — the relationship to the sheet's VML
+     * drawing part. A form control put on the sheet by Excel's Forms toolbar is
+     * declared there and nowhere else.
+     */
+    readonly legacyDrawingRelId?: string;
     /** §18.3.1.18 `<conditionalFormatting>` — value-driven cell formats (E-SHEET SC1). */
     readonly conditionalFormats?: ReadonlyArray<ConditionalFormat>;
     /**
@@ -254,6 +311,8 @@ export interface XlsxFont {
     readonly bold?: boolean;
     readonly italic?: boolean;
     readonly underline?: boolean;
+    /** §18.8.37 `<strike/>` — the font is struck through. */
+    readonly strike?: boolean;
     readonly colorHex?: string;
     readonly name?: string;
 }
@@ -341,6 +400,18 @@ export interface XlsxStyles {
 export interface Dxf {
     readonly font?: XlsxFont;
     readonly fill?: XlsxFill;
+    /**
+     * §18.8.9 `<border>` inside a dxf — a rule may format a cell with nothing but
+     * an edge, and half the differential formats in a real workbook do exactly
+     * that (a rule under every year boundary, a box around a total).
+     */
+    readonly border?: XlsxBorder;
+    /**
+     * §18.8.9 `<numFmt formatCode>` — a rule may change how the VALUE reads, not
+     * just how the cell looks: two decimals where a threshold is crossed. Every
+     * dxf in new_cond_format_test.xlsx is one of these and nothing else.
+     */
+    readonly numberFormat?: string;
 }
 /**
  * ECMA-376 Part 1 §18.2.5 — `<definedName>`. A workbook-scoped (or sheet-scoped,
@@ -364,6 +435,12 @@ export interface CfRuleCellIs {
     readonly operator: CfOperator;
     readonly formulas: ReadonlyArray<string>;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
 }
 /**
  * §18.3.1.11 ST_CfvoType — how a `<cfvo>` stop's threshold is derived.
@@ -406,6 +483,12 @@ export interface CfRuleDataBar {
     readonly colorHex: string;
     readonly minLength?: number;
     readonly maxLength?: number;
+    /**
+     * §18.3.1.28 `showValue` — false means the cell shows the BAR ONLY, with its
+     * number hidden. Excel's "Show Bar Only" checkbox; a dashboard uses it so the
+     * figure does not sit on top of its own gauge.
+     */
+    readonly showValue?: boolean;
 }
 /**
  * §18.3.1.49 `<cfRule type="iconSet">` — picks one glyph per cell from a named
@@ -432,6 +515,12 @@ export interface CfRuleTop10 {
     readonly percent: boolean;
     readonly bottom: boolean;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
 }
 /**
  * §18.3.1.10 `<cfRule type="aboveAverage">` — cells above (default) or below the
@@ -445,6 +534,12 @@ export interface CfRuleAboveAverage {
     readonly equalAverage: boolean;
     readonly stdDev?: number;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
 }
 /**
  * §18.3.1.10 `<cfRule type="duplicateValues" | "uniqueValues">` — cells whose
@@ -456,6 +551,12 @@ export interface CfRuleDupUnique {
     readonly type: 'duplicateValues' | 'uniqueValues';
     readonly priority: number;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
 }
 /**
  * §18.3.1.10 `<cfRule type="containsText" | "notContainsText" | "beginsWith" |
@@ -468,6 +569,12 @@ export interface CfRuleText {
     readonly priority: number;
     readonly text: string;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
     readonly formula?: string;
 }
 /**
@@ -483,6 +590,12 @@ export interface CfRuleExpression {
     readonly priority: number;
     readonly formula: string;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
 }
 /** §18.18.82 ST_TimePeriod — the clock-relative window a `timePeriod` rule tests. */
 export type TimePeriodKind = 'today' | 'yesterday' | 'tomorrow' | 'last7Days' | 'thisWeek' | 'lastWeek' | 'nextWeek' | 'thisMonth' | 'lastMonth' | 'nextMonth';
@@ -499,6 +612,12 @@ export interface CfRuleTimePeriod {
     readonly priority: number;
     readonly timePeriod: TimePeriodKind;
     readonly dxfId: number;
+    /**
+     * The format itself, when the rule carries it instead of pointing at the
+     * workbook's table — the 2009 extension (`<x14:cfRule><x14:dxf>`) writes it
+     * inline, and `dxfId` names nothing there. Takes precedence when present.
+     */
+    readonly dxf?: Dxf;
     readonly formula?: string;
 }
 /** One conditional-format rule (`<cfRule>`): the union over the supported `type`s. */
@@ -542,6 +661,18 @@ export interface HeaderFooter {
 export interface FormControlRef {
     readonly name?: string;
     readonly relId: string;
+    /**
+     * §18.3.1.19 `@shapeId` — the id of this control's shape in the sheet's legacy
+     * VML drawing. It is what tells an ActiveX control's VML shape apart from a
+     * Forms-toolbar control that has no `<control>` entry at all.
+     */
+    readonly shapeId?: string;
+    /**
+     * §18.3.1.20 `<controlPr print>` — Excel's "Print object" checkbox. It
+     * defaults to true, and a control that clears it is on screen only: neither
+     * Excel nor Calc puts it on the page.
+     */
+    readonly print?: boolean;
 }
 /**
  * §18.3.* `<oleObjects><oleObject progId r:id>` — an embedded OLE / ActiveX
@@ -567,6 +698,12 @@ export interface SheetRichRun {
     readonly bold?: boolean;
     readonly italic?: boolean;
     readonly underline?: boolean;
+    /**
+     * §18.8.37 `<strike/>` on the run — struck-through text inside a cell that is
+     * otherwise not. 58315.xlsx crosses out the middle of "320-338 350", which is
+     * the whole point of the cell.
+     */
+    readonly strike?: boolean;
     readonly colorHex?: string;
     readonly sizePt?: number;
     /** §18.4.2 `<vertAlign>` — superscript / subscript within the cell text. */

package/dist/esm/core/vector.d.ts

@@ -82,6 +82,19 @@ export interface VectorShape {
     readonly fillGradient?: ShapeGradient;
     /** Stroke description. Omitted = no stroke. */
     readonly stroke?: StrokeStyle;
+    /**
+     * §20.1.8.40 — a drop shadow drawn UNDER this shape: the same paths, offset
+     * by `(dxPt, dyPt)` in the page's own frame (y down), filled in `colorHex` at
+     * `alpha`. `blurPt` is the softness the source asked for; writers that cannot
+     * blur draw a hard edge.
+     */
+    readonly shadow?: {
+        readonly dxPt: number;
+        readonly dyPt: number;
+        readonly blurPt: number;
+        readonly colorHex: string;
+        readonly alpha: number;
+    };
     /**
      * CTM applied via `cm` (§8.3.4): maps the local frame onto the page. The
      * 6-tuple is `[a b c d e f]` of the matrix `[[a b 0][c d 0][e f 1]]`.

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

@@ -22,6 +22,15 @@ export declare function parseActiveX(data: Uint8Array): ActiveXProps;
  * unknown progId falls back to a generic `'control'`.
  */
 export declare function activeXType(progId: string | undefined): string;
+/**
+ * The affordance key for an `<ax:ocx ax:classid>`, for controls reached through
+ * §18.3.1.19 `<control>` rather than `<oleObject progId>` — the `<control>`
+ * element carries no progId, so the class id is all there is to type it by.
+ *
+ * @param xmlData The `activeX#.xml` part bytes.
+ * @returns The affordance key, or `'control'` when the class id is unknown.
+ */
+export declare function activeXTypeFromPart(xmlData: Uint8Array): string;
 /**
  * The `<ax:ocx r:id>` of a control whose state is persisted to a binary stream
  * (`persistStreamInit` / `persistStream` / `persistStorage`) rather than to

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

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/excel/activex-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,
@@ -62,6 +63,20 @@ function strAttr(obj, key) {
 	const v = obj[`@_${key}`];
 	return typeof v === "string" ? v : void 0;
 }
+var ACTIVEX_CLASS_TYPES = new Map([["8BD21D40-EC42-11CE-9E0D-00AA006002F3", "checkbox"], ["8BD21D50-EC42-11CE-9E0D-00AA006002F3", "option"]]);
+/**
+* The affordance key for an `<ax:ocx ax:classid>`, for controls reached through
+* §18.3.1.19 `<control>` rather than `<oleObject progId>` — the `<control>`
+* element carries no progId, so the class id is all there is to type it by.
+*
+* @param xmlData The `activeX#.xml` part bytes.
+* @returns The affordance key, or `'control'` when the class id is unknown.
+*/
+function activeXTypeFromPart(xmlData) {
+	const ocx = asObject(parser.parse(decoder.decode(xmlData))["ocx"]);
+	const key = (ocx ? strAttr(ocx, "classid") : void 0)?.replace(/[{}]/g, "").toUpperCase() ?? "";
+	return ACTIVEX_CLASS_TYPES.get(key) ?? "control";
+}
 /**
 * The `<ax:ocx r:id>` of a control whose state is persisted to a binary stream
 * (`persistStreamInit` / `persistStream` / `persistStorage`) rather than to
@@ -209,4 +224,4 @@ function parseActiveXBin(data) {
 	};
 }
 //#endregion
-export { activeXBinRelId, activeXType, parseActiveX, parseActiveXBin };
+export { activeXBinRelId, activeXType, activeXTypeFromPart, parseActiveX, parseActiveXBin };