reamkit 1.4.0 → 1.6.0

package/README.md

@@ -30,11 +30,12 @@ import { Ream } from 'reamkit';
 // e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
 const bytes = new Uint8Array(await file.arrayBuffer());
 
-const doc = Ream.parse(bytes);            // docx or xlsx — sniffed
+const doc = Ream.parse(bytes);            // docx, xlsx or pdf — sniffed
 const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
 const docx = await doc.convert('docx');   // write WordprocessingML back out
+const xlsx = await doc.convert('xlsx');   // write SpreadsheetML back (xlsx source)
 
 // Hand the bytes to the browser: preview, download, upload, …
 const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
@@ -129,7 +130,7 @@ rendering — inspect or analyze it without converting:
 
 ```ts
 const doc = Ream.parse(bytes);
-doc.format;     // 'docx' | 'xlsx'
+doc.format;     // 'docx' | 'xlsx' | 'pdf'
 doc.flow.body;  // paragraphs / tables / images / charts …
 doc.losses;     // read-time losses
 ```
@@ -166,14 +167,15 @@ multi-section and multi-column layout/headers-footers (incl. PAGE/NUMPAGES
 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), 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,
+repeated titles, page breaks), **conditional formatting** (color scales, data
+bars, icon sets), **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,
 scheme-allowlisted), tagged PDF, PDF/A-1/2/3 (a/b/u), PDF/UA-1, AES-256
 encryption, digital signatures (PKCS#7/ECDSA/PAdES/RFC 3161), SVG page
-preview, flowed HTML export, and **docx output** (write WordprocessingML back
-out, incl. docx → docx). Reads OOXML Transitional and Strict.
+preview, flowed HTML export, and **docx + xlsx output** (write WordprocessingML
+/ SpreadsheetML back out, incl. round-trips). Reads OOXML Transitional and Strict.
 
 See `handoff.md` for the full feature matrix and known limitations.
 

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

@@ -1,12 +1,16 @@
 import { ConvertDocxOptions } from '../../word/docx-to-pdf.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
+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';
 export interface ConvertOptions extends ConvertDocxOptions {
-    /** Target: 'pdf' (default), 'svg' (page-stack preview), 'html' or 'docx' (flowed). */
-    readonly to?: 'pdf' | 'svg' | 'html' | 'docx';
+    /**
+     * Target: 'pdf' (default), 'svg' (page-stack preview), 'html'/'docx' (flowed),
+     * or 'xlsx' (the native grid writer — spreadsheet input only).
+     */
+    readonly to?: 'pdf' | 'svg' | 'html' | 'docx' | 'xlsx';
     /**
      * Strict mode (handoff v1 §5): throw ConversionLossError on the first
      * recorded loss instead of returning it in the report.
@@ -26,18 +30,20 @@ export interface ConvertResult {
     readonly bytes: Uint8Array;
     readonly losses: LossReport;
 }
+export type SourceDoc = FlowDoc | SheetDoc;
+export declare function toFlowDoc(doc: SourceDoc): FlowDoc;
 export interface Converter {
     /** The registered readers, in sniffing order. */
-    readonly readers: ReadonlyArray<DocumentReader<FlowDoc>>;
+    readonly readers: ReadonlyArray<DocumentReader<SourceDoc>>;
     /** Detect the input format by reader sniffing; undefined when unknown. */
-    detect: (bytes: Uint8Array) => DocumentReader<FlowDoc> | undefined;
+    detect: (bytes: Uint8Array) => DocumentReader<SourceDoc> | undefined;
     convert: (bytes: Uint8Array, options?: ConvertOptions) => Promise<ConvertResult>;
 }
 export interface CreateConverterOptions {
     /** Override / extend the reader registry (defaults to docx + xlsx). */
-    readonly readers?: ReadonlyArray<DocumentReader<FlowDoc>>;
+    readonly readers?: ReadonlyArray<DocumentReader<SourceDoc>>;
 }
-export declare const DEFAULT_READERS: ReadonlyArray<DocumentReader<FlowDoc>>;
+export declare const DEFAULT_READERS: ReadonlyArray<DocumentReader<SourceDoc>>;
 export declare function createConverter(opts?: CreateConverterOptions): Converter;
 export declare function resolveFontsViaChain(providers: ReadonlyArray<FontProvider>): Promise<{
     fonts?: FontBytesByVariant;

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

@@ -3,16 +3,33 @@ import { FEATURES } from "../ir/features.js";
 import { ConversionLossError } from "../ir/loss.js";
 import { layoutStyledDocument } from "../../layout/styled-layout.js";
 import { docxReader } from "../../word/docx-reader.js";
+import { projectSheetDoc } from "../../excel/sheet-to-flow.js";
 import { xlsxReader } from "../../excel/xlsx-reader.js";
 import { chainProviders } from "../fonts/provider.js";
 import { flowRenderOptions } from "./project.js";
 import { writeDocx } from "../../word/docx-writer.js";
+import { writeXlsx } from "../../excel/xlsx-writer.js";
 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 { pdfReader } from "../../pdf-reader/reader.js";
 //#region src/core/converter/facade.ts
-var DEFAULT_READERS = [docxReader, xlsxReader];
+function toFlowDoc(doc) {
+	return doc.kind === "sheet" ? projectSheetDoc(doc) : doc;
+}
+function readToFlow(reader, bytes) {
+	const { doc, losses } = reader.read(bytes);
+	return {
+		doc: toFlowDoc(doc),
+		losses
+	};
+}
+var DEFAULT_READERS = [
+	docxReader,
+	xlsxReader,
+	pdfReader
+];
 function createConverter(opts = {}) {
 	const readers = opts.readers ?? DEFAULT_READERS;
 	const detect = (bytes) => readers.find((r) => r.sniff(bytes));
@@ -22,7 +39,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 } = reader.read(bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
 			losses.push(...readLosses);
 			const out = writeDocx(flow);
 			losses.push(...out.losses);
@@ -33,7 +50,7 @@ function createConverter(opts = {}) {
 			};
 		}
 		if (to === "html") {
-			const { doc: flow, losses: readLosses } = reader.read(bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
 			losses.push(...readLosses);
 			const html = writeHtml(flow);
 			losses.push(...html.losses);
@@ -43,6 +60,18 @@ function createConverter(opts = {}) {
 				losses
 			};
 		}
+		if (to === "xlsx") {
+			const { doc, losses: readLosses } = reader.read(bytes);
+			losses.push(...readLosses);
+			if (doc.kind !== "sheet") throw new Error("to: 'xlsx' requires a spreadsheet input; a flow document has no grid");
+			const out = writeXlsx(doc);
+			losses.push(...out.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: out.bytes,
+				losses
+			};
+		}
 		let conv = rest;
 		if (fontProviders && fontProviders.length > 0 && !rest.fonts && !rest.fontBytes) {
 			const { fonts, loss } = await resolveFontsViaChain(fontProviders);
@@ -55,7 +84,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 } = reader.read(bytes);
+			const { doc: flow } = readToFlow(reader, bytes);
 			const svg = writeSvg(layoutStyledDocument(flow.body, {
 				registry: FontRegistry.fromBytes(fonts),
 				...flowRenderOptions(flow)
@@ -110,4 +139,4 @@ async function resolveFontsViaChain(providers) {
 	};
 }
 //#endregion
-export { DEFAULT_READERS, createConverter, resolveFontsViaChain };
+export { DEFAULT_READERS, createConverter, resolveFontsViaChain, toFlowDoc };

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

@@ -1,14 +1,15 @@
-import { ConvertResult } from './facade.js';
+import { ConvertResult, SourceDoc } from './facade.js';
 import { FontBytesByVariant } from '../font/index.js';
 import { FetchLike } from '../fonts/index.js';
 import { FontProvider } from '../fonts/provider.js';
 import { Loss } from '../ir/index.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
+import { SheetDoc } from '../ir/sheet.js';
 import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
-export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx';
+export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx' | 'xlsx';
 export interface ReamParseOptions {
-    readonly readers?: ReadonlyArray<DocumentReader>;
+    readonly readers?: ReadonlyArray<DocumentReader<SourceDoc>>;
 }
 export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
     readonly fonts?: FontBytesByVariant;
@@ -22,6 +23,7 @@ export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry'
 }
 export declare class Ream {
     readonly flow: FlowDoc;
+    readonly sheet: SheetDoc | undefined;
     readonly losses: ReadonlyArray<Loss>;
     private readonly source;
     private readonly readerId;

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

@@ -7,18 +7,21 @@ import { renderStyledPdf, renderStyledPdfEncrypted } from "../../pdf/styled-page
 import "../../pdf/index.js";
 import { flowRenderOptions } from "./project.js";
 import { writeDocx } from "../../word/docx-writer.js";
+import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
-import { DEFAULT_READERS, resolveFontsViaChain } from "./facade.js";
+import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 //#region src/core/converter/ream.ts
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	pdf: "application/pdf"
 };
 var Ream = class Ream {
-	constructor(flow, losses, source, readerId) {
+	constructor(flow, sheet, losses, source, readerId) {
 		this.flow = flow;
+		this.sheet = sheet;
 		this.losses = losses;
 		this.source = source;
 		this.readerId = readerId;
@@ -28,7 +31,8 @@ var Ream = class Ream {
 		const reader = readers.find((r) => r.sniff(bytes));
 		if (!reader) throw new Error(`Unrecognized document format (readers: ${readers.map((r) => r.id).join(", ")})`);
 		const { doc, losses } = reader.read(bytes);
-		return new Ream(doc, losses, bytes, reader.id);
+		const sheet = doc.kind === "sheet" ? doc : void 0;
+		return new Ream(toFlowDoc(doc), sheet, losses, bytes, reader.id);
 	}
 	get format() {
 		return this.readerId;
@@ -56,6 +60,16 @@ var Ream = class Ream {
 				losses
 			};
 		}
+		if (to === "xlsx") {
+			if (!this.sheet) throw new Error("convert('xlsx') requires a spreadsheet source; this document has no grid");
+			const xlsx = writeXlsx(this.sheet);
+			losses.push(...xlsx.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: xlsx.bytes,
+				losses
+			};
+		}
 		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
 		const registry = FontRegistry.fromBytes(fonts);
 		if (to === "svg") {

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

@@ -1 +1 @@
-export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';
+export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, CellDataBar, CellIcon, CellIconShape, CellSparkline, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';

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

@@ -221,6 +221,25 @@ export interface CellMargins {
 export interface CellShading {
     readonly colorHex: string;
 }
+export interface CellDataBar {
+    readonly fraction: number;
+    readonly colorHex: string;
+    readonly startFraction?: number;
+}
+export type CellIconShape = 'circle' | 'square' | 'diamond' | 'triangleUp' | 'triangleDown' | 'triangleRight' | 'check' | 'cross' | 'exclamation' | 'bars' | 'pie';
+export interface CellIcon {
+    readonly shape: CellIconShape;
+    readonly colorHex: string;
+    readonly fill?: {
+        readonly filled: number;
+        readonly levels: number;
+    };
+}
+export interface CellSparkline {
+    readonly kind: 'line' | 'column' | 'winLoss';
+    readonly values: ReadonlyArray<number | null>;
+    readonly colorHex?: string;
+}
 export type CellMerge = 'start' | 'middle' | 'end';
 export interface CellProperties {
     readonly width?: Pt;
@@ -229,6 +248,9 @@ export interface CellProperties {
     readonly borders?: CellBorders;
     readonly margins?: CellMargins;
     readonly shading?: CellShading;
+    readonly dataBar?: CellDataBar;
+    readonly icon?: CellIcon;
+    readonly sparkline?: CellSparkline;
 }
 export interface RowProperties {
     readonly height?: Pt;
@@ -255,6 +277,10 @@ export interface TableProperties {
     readonly defaultCellMargins?: CellMargins;
     readonly borders?: CellBorders;
     readonly alignment?: 'left' | 'center' | 'right';
+    readonly frozen?: {
+        readonly rows: number;
+        readonly cols: number;
+    };
 }
 export interface TableCell {
     readonly properties: CellProperties;

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

@@ -0,0 +1,8 @@
+import { StrokeStyle, VectorPath } from '../vector.js';
+export type SparklineKind = 'line' | 'column' | 'winLoss';
+export interface SparklinePrim {
+    readonly paths: ReadonlyArray<VectorPath>;
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+}
+export declare function buildSparkline(kind: SparklineKind, values: ReadonlyArray<number | null>, width: number, height: number, colorHex?: string): Array<SparklinePrim>;

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

@@ -0,0 +1,111 @@
+import { PathBuilder } from "../vector.js";
+//#region src/core/drawingml/sparkline-geometry.ts
+var DEFAULT_SERIES_HEX = "376092";
+var LOSS_HEX = "D00000";
+function buildSparkline(kind, values, width, height, colorHex) {
+	if (width <= 0 || height <= 0 || values.every((v) => v === null)) return [];
+	const color = colorHex ?? DEFAULT_SERIES_HEX;
+	switch (kind) {
+		case "line": return lineSpark(values, width, height, color);
+		case "column": return columnSpark(values, width, height, color);
+		case "winLoss": return winLossSpark(values, width, height, color);
+	}
+}
+function lineSpark(values, w, h, color) {
+	const n = values.length;
+	const pad = Math.min(1, h * .12);
+	const { min, span } = extent(values);
+	const x = (i) => n === 1 ? w / 2 : i / (n - 1) * w;
+	const y = (v) => pad + (v - min) / span * (h - 2 * pad);
+	const b = new PathBuilder();
+	let penDown = false;
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0) {
+			penDown = false;
+			continue;
+		}
+		if (penDown) b.lineTo(x(i), y(v));
+		else {
+			b.moveTo(x(i), y(v));
+			penDown = true;
+		}
+	}
+	return [{
+		paths: [b.build()],
+		stroke: {
+			colorHex: color,
+			widthPt: .75,
+			join: "round"
+		}
+	}];
+}
+function columnSpark(values, w, h, color) {
+	const n = values.length;
+	const { min, span } = extent(values);
+	const slot = w / n;
+	const bw = slot * .72;
+	const off = (slot - bw) / 2;
+	const pad = h * .06;
+	const paths = [];
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0) continue;
+		const frac = (v - min) / span;
+		const bh = Math.max(.4, pad + frac * (h - pad));
+		paths.push(rectPath(i * slot + off, 0, bw, bh));
+	}
+	return paths.length > 0 ? [{
+		paths,
+		fillColorHex: color
+	}] : [];
+}
+function winLossSpark(values, w, h, color) {
+	const n = values.length;
+	const slot = w / n;
+	const bw = slot * .72;
+	const off = (slot - bw) / 2;
+	const mid = h / 2;
+	const barH = h * .4;
+	const wins = [];
+	const losses = [];
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0 || v === 0) continue;
+		const x = i * slot + off;
+		if (v > 0) wins.push(rectPath(x, mid, bw, barH));
+		else losses.push(rectPath(x, mid - barH, bw, barH));
+	}
+	const out = [];
+	if (wins.length > 0) out.push({
+		paths: wins,
+		fillColorHex: color
+	});
+	if (losses.length > 0) out.push({
+		paths: losses,
+		fillColorHex: LOSS_HEX
+	});
+	return out;
+}
+function extent(values) {
+	let min = Infinity;
+	let max = -Infinity;
+	for (const v of values) {
+		if (v === null) continue;
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	if (min === Infinity) return {
+		min: 0,
+		span: 1
+	};
+	return {
+		min,
+		span: max - min || 1
+	};
+}
+function rectPath(x, y, w, h) {
+	return new PathBuilder().moveTo(x, y).lineTo(x + w, y).lineTo(x + w, y + h).lineTo(x, y + h).close().build();
+}
+//#endregion
+export { buildSparkline };

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

@@ -12,8 +12,8 @@ export interface ReadResult<TDoc> {
 export interface DocumentReader<TDoc = FlowDoc> {
     /** Format id: 'docx', 'xlsx', 'pdf', … */
     readonly id: string;
-    /** Which tree this reader produces. */
-    readonly produces: 'flow' | 'page';
+    /** Which tree this reader produces ('sheet' projects to flow at the boundary). */
+    readonly produces: 'flow' | 'page' | 'sheet';
     /** Feature vocabulary this reader understands (capability matrix source). */
     readonly supports: ReadonlySet<Feature>;
     /** Cheap format detection (magic bytes / container markers). */
@@ -28,10 +28,10 @@ export interface WriteResult {
     readonly losses: LossReport;
 }
 export interface DocumentWriter<TDoc> {
-    /** Output format id: 'pdf', 'svg', 'html', 'docx', … */
+    /** Output format id: 'pdf', 'svg', 'html', 'docx', 'xlsx', … */
     readonly id: string;
-    /** Which tree this writer consumes. */
-    readonly consumes: 'flow' | 'page';
+    /** Which tree this writer consumes ('sheet' for the native grid writer). */
+    readonly consumes: 'flow' | 'page' | 'sheet';
     readonly supports: ReadonlySet<Feature>;
     write: (doc: TDoc, opts?: WriteOptions) => WriteResult;
 }

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

@@ -0,0 +1,31 @@
+import { Chart, DocumentInfo } from '../document-model/index.js';
+import { DefinedName, ParsedWorksheet, XlsxStyles } from '../spreadsheet-model/index.js';
+import { ResourceStore } from './resources.js';
+export interface SheetChartRef {
+    readonly chartPartPath: string;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+export interface Sheet {
+    readonly name: string;
+    readonly grid: ParsedWorksheet;
+    readonly charts?: ReadonlyArray<SheetChartRef>;
+}
+export interface SheetDoc {
+    readonly kind: 'sheet';
+    readonly sheets: ReadonlyArray<Sheet>;
+    /** §18.8 workbook style table (cellXfs + fonts/fills/borders/numFmts). */
+    readonly styles: XlsxStyles;
+    /** §18.4 shared string table; a cell with type 's' indexes into it. */
+    readonly sharedStrings: ReadonlyArray<string>;
+    /** §18.2.5 workbook defined names (print areas/titles, named ranges). */
+    readonly definedNames: ReadonlyArray<DefinedName>;
+    /** §18.2.28 1904 date system (serial-to-date epoch). */
+    readonly date1904: boolean;
+    /** Parsed charts keyed by part path (SheetChartRef.chartPartPath). */
+    readonly chartData?: ReadonlyMap<string, Chart>;
+    /** Content-addressed binary resources (sheet images). */
+    readonly resources: ResourceStore;
+    /** Document metadata from docProps/core.xml. */
+    readonly info?: DocumentInfo;
+}

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

@@ -6,6 +6,7 @@ var parser = new XMLParser({
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,
 	trimValues: false,
+	removeNSPrefix: true,
 	isArray: (tagName) => tagName === "Relationship"
 });
 function parseRelationships(data) {

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

@@ -0,0 +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, CfRule, ConditionalFormat, SparklineKind, ParsedSparkline, ExcelTable, SheetPane, } from './types.js';