reamkit 1.14.0 → 1.15.0

package/README.md

@@ -1,12 +1,20 @@
 # Ream
 
-> DOCX & XLSX → PDF, from scratch — no LibreOffice, no headless Office, no commercial SDK.
-
-Convert Word (`.docx`) and Excel (`.xlsx`) documents to PDF, **in the browser** —
-implemented from the **ECMA-376** (OOXML) and **ISO 32000** (PDF) specifications,
-with no wrapper around LibreOffice, headless Office, or any commercial SDK. Pure
-TypeScript/JavaScript working on `Uint8Array` in and `Uint8Array` out, so it also
-runs unchanged in Node.js, serverless, and edge runtimes.
+> Read Word, Excel, PowerPoint and PDF — and convert any of them to PDF, SVG, HTML, DOCX or XLSX. From scratch, in the browser. No LibreOffice, no headless Office, no commercial SDK.
+
+Ream parses **seven document formats** — the modern Office Open XML trio (`.docx`,
+`.xlsx`, `.pptx`), `.pdf`, and the legacy binary `.doc` / `.xls` / `.ppt` — into one
+format-neutral interlayer, then renders that to **PDF, SVG, HTML, DOCX or XLSX**.
+It is implemented directly from the **ECMA-376** (OOXML), **ISO 32000 / 19005**
+(PDF / PDF/A), and Microsoft's binary-format specifications — no wrapper around
+LibreOffice, headless Office, or any commercial SDK. Pure TypeScript/JavaScript on
+`Uint8Array` in and `Uint8Array` out, so the same code runs unchanged in the browser,
+Node.js, serverless and edge runtimes.
+
+|            |                                                                                             |
+| ---------- | ------------------------------------------------------------------------------------------- |
+| **Reads**  | `.docx` · `.xlsx` · `.pptx` · `.pdf` · legacy `.doc` · `.xls` · `.ppt`                       |
+| **Writes** | `.pdf` (incl. PDF/A-1/2/3, PDF/UA-1, signed, encrypted) · `.svg` · `.html` · `.docx` · `.xlsx` |
 
 ## Install
 
@@ -168,7 +176,8 @@ fields)/footnotes and endnotes/hyperlinks and bookmarks/floating drawings/
 images/tracked changes, SpreadsheetML grids,
 number formats and the print model (gridlines, print area, fit-to-page,
 repeated titles, page breaks), **conditional formatting** (color scales, data
-bars, icon sets), **sparklines** and **Excel tables**, DrawingML shapes and
+bars, icon sets, and `expression` rules evaluated by a ~140-function formula
+engine), **sparklines** and **Excel tables**, DrawingML shapes and
 charts, OMML math, Type0+CIDFontType2 embedding with subsetting, Knuth-Plass
 line breaking, Liang hyphenation, OpenType ligatures/kerning + Arabic cursive
 joining, BiDi (UAX #9), hyperlinks (PDF link annotations + HTML anchors,
@@ -193,6 +202,23 @@ bullets and indents), layout/master placeholders, pictures, shapes, DrawingML
 tables, embedded charts, theme colours, slide backgrounds, grouped shapes and
 hyperlinks — then converts onward to PDF, SVG, HTML or DOCX like any source.
 
+**Reads legacy `.doc`, `.xls` and `.ppt`, too.** The binary Word / Excel /
+PowerPoint 97–2003 formats (OLE2/CFB) parse through a shared container reader: a
+`.doc` yields its text with run and paragraph formatting, tables (with cell
+borders, vertical merges and background shading), inline images, fields,
+headers/footers and lists (numbered or bulleted, in their number format);
+an `.xls` yields the grid with styling, embedded
+images, charts, drawing shapes, cell hyperlinks, the page-setup print model,
+defined names (named ranges, print area, repeated titles), cell comments, data
+validation, frozen panes, custom row heights and conditional formatting (the
+classic cellIs / expression rules **and** the 2007 colour-scale / data-bar /
+icon-set extensions); a `.ppt` yields each slide's
+text (with run and paragraph formatting), embedded images, per-shape placement
+(anchored text boxes and pictures at their slide rectangles) and decorative
+autoshapes (preset or exact freeform geometry, with fill / line colours resolved
+through the slide's colour scheme), one page per slide — all convert onward to PDF,
+SVG, HTML, or back to `.docx` / `.xlsx` like any source.
+
 See [`CHANGELOG.md`](./CHANGELOG.md) for the release history; the docs
 [**Scope**](https://reamkit.dev/guides/scope/) guide has the full feature matrix
 and known limitations.

package/dist/esm/core/converter/facade.d.ts

@@ -5,6 +5,7 @@ import { SheetDoc } from '../ir/sheet.js';
 import { FontProvider } from '../fonts/provider.js';
 import { Loss, LossReport } from '../ir/index.js';
 import { FontBytesByVariant } from '../font/index.js';
+import { ProjectSheetOptions } from '../../excel/sheet-to-flow.js';
 export interface ConvertOptions extends ConvertDocxOptions {
     /**
      * Target: 'pdf' (default), 'svg' (page-stack preview), 'html'/'docx' (flowed),
@@ -16,6 +17,12 @@ export interface ConvertOptions extends ConvertDocxOptions {
      * recorded loss instead of returning it in the report.
      */
     readonly strict?: boolean;
+    /**
+     * E-SHEET W9 — reference date for conditional-format `timePeriod` rules and
+     * TODAY()/NOW() in `expression` rules (spreadsheet input). An explicit input,
+     * never the wall clock; omitted ⇒ those clock-relative rules no-op.
+     */
+    readonly now?: Date;
     /**
      * Font resolution chain (ir-design §8). When set (and no caller `fonts`),
      * the facade resolves the default font set through these providers — e.g.
@@ -31,7 +38,7 @@ export interface ConvertResult {
     readonly losses: LossReport;
 }
 export type SourceDoc = FlowDoc | SheetDoc;
-export declare function toFlowDoc(doc: SourceDoc): FlowDoc;
+export declare function toFlowDoc(doc: SourceDoc, options?: ProjectSheetOptions): FlowDoc;
 export interface Converter {
     /** The registered readers, in sniffing order. */
     readonly readers: ReadonlyArray<DocumentReader<SourceDoc>>;

package/dist/esm/core/converter/facade.js

@@ -1,7 +1,10 @@
+import { fetchFontSet } from "../fonts/remote-fonts.js";
 import { FontRegistry } from "../font/font-registry.js";
 import { FEATURES } from "../ir/features.js";
 import { ConversionLossError } from "../ir/loss.js";
 import { layoutStyledDocument } from "../../layout/styled-layout.js";
+import { renderStyledPdf } from "../../pdf/styled-page-renderer.js";
+import "../../pdf/index.js";
 import { pptxReader } from "../../pptx/pptx-reader.js";
 import { docxReader } from "../../word/docx-reader.js";
 import { projectSheetDoc } from "../../excel/sheet-to-flow.js";
@@ -14,22 +17,28 @@ import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
 import { convertXlsxToPdf } from "../../excel/xlsx-to-pdf.js";
+import { docReader } from "../../word/doc/doc-reader.js";
+import { xlsReader } from "../../excel/xls/xls-reader.js";
+import { pptReader } from "../../pptx/ppt/ppt-reader.js";
 import { pdfReader } from "../../pdf-reader/reader.js";
 //#region src/core/converter/facade.ts
-function toFlowDoc(doc) {
-	return doc.kind === "sheet" ? projectSheetDoc(doc) : doc;
+function toFlowDoc(doc, options = {}) {
+	return doc.kind === "sheet" ? projectSheetDoc(doc, options) : doc;
 }
-function readToFlow(reader, bytes) {
+function readToFlow(reader, bytes, options = {}) {
 	const { doc, losses } = reader.read(bytes);
 	return {
-		doc: toFlowDoc(doc),
+		doc: toFlowDoc(doc, options),
 		losses
 	};
 }
 var DEFAULT_READERS = [
 	docxReader,
+	docReader,
 	xlsxReader,
+	xlsReader,
 	pptxReader,
+	pptReader,
 	pdfReader
 ];
 function createConverter(opts = {}) {
@@ -41,7 +50,7 @@ function createConverter(opts = {}) {
 		if (!reader) throw new Error("Unrecognized input format (no registered reader sniffs these bytes)");
 		const losses = [];
 		if (to === "docx") {
-			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes, rest.now ? { now: rest.now } : void 0);
 			losses.push(...readLosses);
 			const out = writeDocx(flow);
 			losses.push(...out.losses);
@@ -52,7 +61,7 @@ function createConverter(opts = {}) {
 			};
 		}
 		if (to === "html") {
-			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes, rest.now ? { now: rest.now } : void 0);
 			losses.push(...readLosses);
 			const html = writeHtml(flow);
 			losses.push(...html.losses);
@@ -86,7 +95,7 @@ function createConverter(opts = {}) {
 		if (to === "svg") {
 			const fonts = conv.fonts ?? (conv.fontBytes ? { regular: conv.fontBytes } : void 0);
 			if (!fonts) throw new Error("to: 'svg' requires options.fonts/fontBytes or fontProviders");
-			const { doc: flow } = readToFlow(reader, bytes);
+			const { doc: flow } = readToFlow(reader, bytes, rest.now ? { now: rest.now } : void 0);
 			const svg = writeSvg(layoutStyledDocument(flow.body, {
 				registry: FontRegistry.fromBytes(fonts),
 				...flowRenderOptions(flow)
@@ -98,7 +107,10 @@ function createConverter(opts = {}) {
 				losses
 			};
 		}
-		const pdf = reader.id === "xlsx" ? await convertXlsxToPdf(bytes, conv) : await convertDocxToPdf(bytes, conv);
+		let pdf;
+		if (reader.id === "xlsx") pdf = await convertXlsxToPdf(bytes, conv);
+		else if (reader.produces === "sheet") pdf = await renderSheetReaderToPdf(reader, bytes, conv, rest.now);
+		else pdf = await convertDocxToPdf(bytes, conv);
 		if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
 		return {
 			bytes: pdf,
@@ -111,6 +123,20 @@ function createConverter(opts = {}) {
 		convert
 	};
 }
+async function renderSheetReaderToPdf(reader, bytes, conv, now) {
+	const fonts = conv.fonts ?? (conv.fontBytes ? { regular: conv.fontBytes } : await fetchFontSet({
+		...conv.fontFamily ? { family: conv.fontFamily } : {},
+		...conv.fontFetch ? { fetch: conv.fontFetch } : {}
+	}));
+	const { doc: flow } = readToFlow(reader, bytes, now ? { now } : void 0);
+	return renderStyledPdf(flow.body, {
+		registry: FontRegistry.fromBytes(fonts),
+		...flowRenderOptions(flow),
+		...conv.pdfA ? { pdfA: conv.pdfA } : {},
+		...conv.info ? { info: conv.info } : {},
+		...conv.section ? { section: conv.section } : {}
+	});
+}
 async function resolveFontsViaChain(providers) {
 	const chain = chainProviders(providers);
 	const ask = (bold, italic) => chain.resolve({

package/dist/esm/core/converter/ream.d.ts

@@ -21,6 +21,7 @@ export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry'
     readonly strict?: boolean;
     readonly embedSource?: boolean;
     readonly signature?: SignatureOptions;
+    readonly now?: Date;
 }
 export declare class Ream {
     readonly flow: FlowDoc;

package/dist/esm/core/converter/ream.js

@@ -5,6 +5,7 @@ import { layoutStyledDocument } from "../../layout/styled-layout.js";
 import { signPdf } from "../../pdf/signature.js";
 import { renderStyledPdf, renderStyledPdfEncrypted } from "../../pdf/styled-page-renderer.js";
 import "../../pdf/index.js";
+import { projectSheetDoc } from "../../excel/sheet-to-flow.js";
 import { flowRenderOptions } from "./project.js";
 import { writeDocx } from "../../word/docx-writer.js";
 import { writeXlsx } from "../../excel/xlsx-writer.js";
@@ -15,8 +16,11 @@ import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 //#region src/core/converter/ream.ts
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	doc: "application/msword",
 	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	xls: "application/vnd.ms-excel",
 	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	ppt: "application/vnd.ms-powerpoint",
 	pdf: "application/pdf"
 };
 var Ream = class Ream {
@@ -43,8 +47,9 @@ var Ream = class Ream {
 	}
 	async convertWithReport(to, options = {}) {
 		const losses = [...this.losses];
+		const flow = this.sheet && options.now ? projectSheetDoc(this.sheet, { now: options.now }) : this.flow;
 		if (to === "html") {
-			const html = writeHtml(this.flow);
+			const html = writeHtml(flow);
 			losses.push(...html.losses);
 			this.enforceStrict(options, losses);
 			return {
@@ -53,7 +58,7 @@ var Ream = class Ream {
 			};
 		}
 		if (to === "docx") {
-			const docx = writeDocx(this.flow);
+			const docx = writeDocx(flow);
 			losses.push(...docx.losses);
 			this.enforceStrict(options, losses);
 			return {
@@ -74,9 +79,9 @@ var Ream = class Ream {
 		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
 		const registry = FontRegistry.fromBytes(fonts);
 		if (to === "svg") {
-			const svg = writeSvg(layoutStyledDocument(this.flow.body, {
+			const svg = writeSvg(layoutStyledDocument(flow.body, {
 				registry,
-				...flowRenderOptions(this.flow)
+				...flowRenderOptions(flow)
 			}));
 			losses.push(...svg.losses);
 			this.enforceStrict(options, losses);
@@ -86,8 +91,8 @@ var Ream = class Ream {
 			};
 		}
 		const { fonts: _a, fontBytes: _b, fontFamily: _c, fontFetch: _d, fontProviders: _e, strict: _f, embedSource, signature, info: callerInfo, attachments: callerAttachments, ...renderOptions } = options;
-		const info = this.flow.info || callerInfo ? {
-			...this.flow.info,
+		const info = flow.info || callerInfo ? {
+			...flow.info,
 			...callerInfo
 		} : void 0;
 		const attachments = [...callerAttachments ?? []];
@@ -101,13 +106,13 @@ var Ream = class Ream {
 		const styled = {
 			registry,
 			...registriesByFamily ? { registriesByFamily } : {},
-			...flowRenderOptions(this.flow),
+			...flowRenderOptions(flow),
 			...info ? { info } : {},
 			...attachments.length > 0 ? { attachments } : {},
 			...signature ? { signaturePlaceholder: signature } : {},
 			...renderOptions
 		};
-		let pdf = styled.encrypt ? await renderStyledPdfEncrypted(this.flow.body, styled) : renderStyledPdf(this.flow.body, styled);
+		let pdf = styled.encrypt ? await renderStyledPdfEncrypted(flow.body, styled) : renderStyledPdf(flow.body, styled);
 		if (signature) pdf = await signPdf(pdf, signature);
 		this.enforceStrict(options, losses);
 		return {

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

@@ -3,6 +3,7 @@ export declare const FEATURES: {
     readonly text: "text";
     readonly tables: "tables";
     readonly tablesNested: "tables.nested";
+    readonly cellFormatting: "cellFormatting";
     readonly lists: "lists";
     readonly sections: "sections";
     readonly headersFooters: "headersFooters";

package/dist/esm/core/ir/features.js

@@ -3,6 +3,7 @@ var FEATURES = {
 	text: "text",
 	tables: "tables",
 	tablesNested: "tables.nested",
+	cellFormatting: "cellFormatting",
 	lists: "lists",
 	sections: "sections",
 	headersFooters: "headersFooters",

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

@@ -40,6 +40,12 @@ export interface SheetFormControl {
     readonly checked?: boolean;
     readonly value?: number;
 }
+export interface SheetActiveXControl {
+    readonly type: string;
+    readonly caption?: string;
+    readonly value?: string;
+    readonly groupName?: string;
+}
 export interface Sheet {
     readonly name: string;
     readonly grid: ParsedWorksheet;
@@ -50,6 +56,7 @@ export interface Sheet {
     readonly slicers?: ReadonlyArray<SheetSlicer>;
     readonly comments?: ReadonlyArray<SheetComment>;
     readonly formControls?: ReadonlyArray<SheetFormControl>;
+    readonly activeXControls?: ReadonlyArray<SheetActiveXControl>;
 }
 export interface SheetDoc {
     readonly kind: 'sheet';

package/dist/esm/core/ole/cfb.d.ts

@@ -0,0 +1,19 @@
+export type CfbEntryType = 'root' | 'storage' | 'stream' | 'unknown';
+export interface CfbEntry {
+    readonly name: string;
+    readonly type: CfbEntryType;
+    readonly startSector: number;
+    readonly size: number;
+}
+export declare class CfbError extends Error {
+}
+export interface Cfb {
+    /** Every directory entry, in directory order (index 0 is the root storage). */
+    readonly entries: ReadonlyArray<CfbEntry>;
+    /** Read a stream's bytes by entry name (case-insensitive), or undefined. */
+    readStream: (name: string) => Uint8Array | undefined;
+    /** Whether a stream entry with that name exists (case-insensitive). */
+    hasStream: (name: string) => boolean;
+}
+export declare function isCfb(bytes: Uint8Array): boolean;
+export declare function openCfb(bytes: Uint8Array): Cfb;

package/dist/esm/core/ole/cfb.js

@@ -0,0 +1,158 @@
+//#region src/core/ole/cfb.ts
+var SIGNATURE = [
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+];
+var ENDOFCHAIN = 4294967294;
+var FREESECT = 4294967295;
+var HEADER_SIZE = 512;
+var DIR_ENTRY_SIZE = 128;
+var MAX_TOTAL_BYTES = 512 * 1024 * 1024;
+var CfbError = class extends Error {};
+function isCfb(bytes) {
+	if (bytes.length < HEADER_SIZE) return false;
+	for (let i = 0; i < SIGNATURE.length; i++) if (bytes[i] !== SIGNATURE[i]) return false;
+	return true;
+}
+function openCfb(bytes) {
+	if (!isCfb(bytes)) throw new CfbError("not a compound file (bad signature)");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const sectorShift = view.getUint16(30, true);
+	const miniSectorShift = view.getUint16(32, true);
+	if (sectorShift !== 9 && sectorShift !== 12) throw new CfbError(`unsupported sector shift ${sectorShift}`);
+	if (miniSectorShift !== 6) throw new CfbError(`unsupported mini-sector shift ${miniSectorShift}`);
+	const sectorSize = 1 << sectorShift;
+	const miniSectorSize = 1 << miniSectorShift;
+	const miniCutoff = view.getUint32(56, true);
+	const totalSectors = Math.floor((bytes.length - HEADER_SIZE) / sectorSize);
+	const sectorOffset = (sector) => {
+		if (sector < 0 || sector >= totalSectors) throw new CfbError(`sector ${sector} out of range`);
+		return HEADER_SIZE + sector * sectorSize;
+	};
+	const firstDirSector = view.getUint32(48, true);
+	const firstMiniFatSector = view.getUint32(60, true);
+	const firstDifatSector = view.getUint32(68, true);
+	const numDifatSectors = view.getUint32(72, true);
+	const fatSectorLocs = [];
+	for (let i = 0; i < 109; i++) {
+		const loc = view.getUint32(76 + i * 4, true);
+		if (loc !== FREESECT && loc < totalSectors) fatSectorLocs.push(loc);
+	}
+	const perDifat = sectorSize / 4 - 1;
+	let difatSector = firstDifatSector;
+	for (let guard = 0; difatSector !== ENDOFCHAIN && difatSector !== FREESECT; guard++) {
+		if (guard > numDifatSectors || guard > totalSectors) throw new CfbError("DIFAT chain too long (corrupt)");
+		const off = sectorOffset(difatSector);
+		for (let i = 0; i < perDifat; i++) {
+			const loc = view.getUint32(off + i * 4, true);
+			if (loc !== FREESECT && loc < totalSectors) fatSectorLocs.push(loc);
+		}
+		difatSector = view.getUint32(off + perDifat * 4, true);
+	}
+	const entriesPerSector = sectorSize / 4;
+	const fat = new Uint32Array(fatSectorLocs.length * entriesPerSector);
+	for (let s = 0; s < fatSectorLocs.length; s++) {
+		const off = sectorOffset(fatSectorLocs[s]);
+		for (let i = 0; i < entriesPerSector; i++) fat[s * entriesPerSector + i] = view.getUint32(off + i * 4, true);
+	}
+	const followChain = (start) => {
+		const out = [];
+		let s = start;
+		while (s !== ENDOFCHAIN && s !== FREESECT) {
+			if (s >= totalSectors || out.length > totalSectors) throw new CfbError("FAT chain corrupt (out of range or cyclic)");
+			out.push(s);
+			s = fat[s] ?? ENDOFCHAIN;
+		}
+		return out;
+	};
+	const readChainBytes = (start, limit) => {
+		const sectors = followChain(start);
+		const total = sectors.length * sectorSize;
+		if (total > limit) throw new CfbError("stream exceeds size limit");
+		const out = new Uint8Array(total);
+		for (let i = 0; i < sectors.length; i++) {
+			const off = sectorOffset(sectors[i]);
+			out.set(bytes.subarray(off, off + sectorSize), i * sectorSize);
+		}
+		return out;
+	};
+	const dirBytes = readChainBytes(firstDirSector, MAX_TOTAL_BYTES);
+	const dirView = new DataView(dirBytes.buffer, dirBytes.byteOffset, dirBytes.byteLength);
+	const entries = [];
+	const entryCount = Math.floor(dirBytes.length / DIR_ENTRY_SIZE);
+	for (let i = 0; i < entryCount; i++) {
+		const base = i * DIR_ENTRY_SIZE;
+		const objType = dirView.getUint8(base + 66);
+		if (objType !== 1 && objType !== 2 && objType !== 5) continue;
+		const name = decodeName(dirBytes, base, dirView.getUint16(base + 64, true));
+		const sizeLow = dirView.getUint32(base + 120, true);
+		const size = dirView.getUint32(base + 124, true) * 4294967296 + sizeLow;
+		entries.push({
+			name,
+			type: objType === 5 ? "root" : objType === 1 ? "storage" : "stream",
+			startSector: dirView.getUint32(base + 116, true),
+			size
+		});
+	}
+	const root = entries.find((e) => e.type === "root");
+	if (!root) throw new CfbError("compound file has no root entry");
+	let miniStream;
+	let miniFat;
+	const ensureMini = () => {
+		if (miniStream && miniFat) return;
+		miniStream = readChainBytes(root.startSector, MAX_TOTAL_BYTES).subarray(0, root.size);
+		const mfBytes = firstMiniFatSector === ENDOFCHAIN ? new Uint8Array(0) : readChainBytes(firstMiniFatSector, MAX_TOTAL_BYTES);
+		const mfView = new DataView(mfBytes.buffer, mfBytes.byteOffset, mfBytes.byteLength);
+		miniFat = new Uint32Array(Math.floor(mfBytes.length / 4));
+		for (let i = 0; i < miniFat.length; i++) miniFat[i] = mfView.getUint32(i * 4, true);
+	};
+	const readMiniStream = (entry) => {
+		ensureMini();
+		const stream = miniStream;
+		const mfat = miniFat;
+		const maxMini = Math.floor(stream.length / miniSectorSize);
+		const out = new Uint8Array(entry.size);
+		let mini = entry.startSector;
+		let written = 0;
+		let guard = 0;
+		while (mini !== ENDOFCHAIN && mini !== FREESECT && written < entry.size) {
+			if (mini >= maxMini || guard++ > mfat.length) throw new CfbError("mini-FAT chain corrupt (out of range or cyclic)");
+			const off = mini * miniSectorSize;
+			const n = Math.min(miniSectorSize, entry.size - written);
+			out.set(stream.subarray(off, off + n), written);
+			written += n;
+			mini = mfat[mini] ?? ENDOFCHAIN;
+		}
+		return out;
+	};
+	const readEntry = (entry) => {
+		if (entry.size === 0) return new Uint8Array(0);
+		if (entry.size > MAX_TOTAL_BYTES) throw new CfbError("stream exceeds size limit");
+		if (entry.size >= miniCutoff) return readChainBytes(entry.startSector, MAX_TOTAL_BYTES).subarray(0, entry.size);
+		return readMiniStream(entry);
+	};
+	const byName = /* @__PURE__ */ new Map();
+	for (const e of entries) if (e.type === "stream" && !byName.has(e.name.toLowerCase())) byName.set(e.name.toLowerCase(), e);
+	return {
+		entries,
+		hasStream: (name) => byName.has(name.toLowerCase()),
+		readStream: (name) => {
+			const e = byName.get(name.toLowerCase());
+			return e ? readEntry(e) : void 0;
+		}
+	};
+}
+function decodeName(dir, base, nameLen) {
+	const len = Math.max(0, Math.min(64, nameLen) - 2);
+	let out = "";
+	for (let i = 0; i < len; i += 2) out += String.fromCharCode(dir[base + i] | dir[base + i + 1] << 8);
+	return out;
+}
+//#endregion
+export { isCfb, openCfb };

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, CfRule, ConditionalFormat, DataValidationType, DataValidation, HyperlinkRef, HeaderFooter, FormControlRef, SheetRichRun, SparklineKind, ParsedSparkline, ExcelTable, PivotTable, SheetPane, } from './types.js';
+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';

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

@@ -62,6 +62,7 @@ export interface ParsedWorksheet {
     readonly hyperlinks?: ReadonlyArray<HyperlinkRef>;
     readonly headerFooter?: HeaderFooter;
     readonly formControls?: ReadonlyArray<FormControlRef>;
+    readonly oleObjects?: ReadonlyArray<OleObjectRef>;
     readonly sparklines?: ReadonlyArray<ParsedSparkline>;
     readonly tablePartRelIds?: ReadonlyArray<string>;
     readonly tables?: ReadonlyArray<ExcelTable>;
@@ -236,7 +237,21 @@ export interface CfRuleText {
     readonly dxfId: number;
     readonly formula?: string;
 }
-export type CfRule = CfRuleCellIs | CfRuleColorScale | CfRuleDataBar | CfRuleIconSet | CfRuleTop10 | CfRuleAboveAverage | CfRuleDupUnique | CfRuleText;
+export interface CfRuleExpression {
+    readonly type: 'expression';
+    readonly priority: number;
+    readonly formula: string;
+    readonly dxfId: number;
+}
+export type TimePeriodKind = 'today' | 'yesterday' | 'tomorrow' | 'last7Days' | 'thisWeek' | 'lastWeek' | 'nextWeek' | 'thisMonth' | 'lastMonth' | 'nextMonth';
+export interface CfRuleTimePeriod {
+    readonly type: 'timePeriod';
+    readonly priority: number;
+    readonly timePeriod: TimePeriodKind;
+    readonly dxfId: number;
+    readonly formula?: string;
+}
+export type CfRule = CfRuleCellIs | CfRuleColorScale | CfRuleDataBar | CfRuleIconSet | CfRuleTop10 | CfRuleAboveAverage | CfRuleDupUnique | CfRuleText | CfRuleExpression | CfRuleTimePeriod;
 export interface ConditionalFormat {
     readonly ranges: ReadonlyArray<MergedRange>;
     readonly rules: ReadonlyArray<CfRule>;
@@ -256,6 +271,10 @@ export interface FormControlRef {
     readonly name?: string;
     readonly relId: string;
 }
+export interface OleObjectRef {
+    readonly progId?: string;
+    readonly relId: string;
+}
 export interface SheetRichRun {
     readonly text: string;
     readonly bold?: boolean;

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

@@ -0,0 +1,9 @@
+export interface ActiveXProps {
+    readonly caption?: string;
+    readonly value?: string;
+    readonly groupName?: string;
+}
+export declare function parseActiveX(data: Uint8Array): ActiveXProps;
+export declare function activeXType(progId: string | undefined): string;
+export declare function activeXBinRelId(xmlData: Uint8Array): string | undefined;
+export declare function parseActiveXBin(data: Uint8Array): ActiveXProps;