reamkit 1.3.0 → 1.5.0

package/README.md

@@ -34,6 +34,8 @@ const doc = Ream.parse(bytes);            // docx or xlsx — 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' }));
@@ -150,10 +152,11 @@ automatically from the document's `docProps/core.xml`), `attachments`
 
 ### Lower-level APIs
 
-- `docxReader` / `xlsxReader`, `svgWriter`, `htmlWriter` — the `@experimental` reader/writer
-  interfaces of the interlayer, for building custom pipelines (and keeping
-  unused formats out of your bundle); `layoutStyledDocument` produces the
-  frozen page model (`PageItem` pages in a top-left `Pt` frame) they consume.
+- `docxReader` / `xlsxReader`, `svgWriter`, `htmlWriter`, `docxWriter` — the `@experimental`
+  reader/writer interfaces of the interlayer, for building custom pipelines (and
+  keeping unused formats out of your bundle); `layoutStyledDocument` produces the
+  frozen page model (`PageItem` pages in a top-left `Pt` frame) the page-based
+  writers consume (`docxWriter` works from the flow model, before layout).
 - `renderStyledPdf` drives the layout engine directly; the typed document
   model is on the `reamkit/document-model` subpath.
 
@@ -164,13 +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. 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) or 'html' (flowed). */
-    readonly to?: 'pdf' | 'svg' | 'html';
+    /**
+     * 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,14 +3,27 @@ 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";
 //#region src/core/converter/facade.ts
+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];
 function createConverter(opts = {}) {
 	const readers = opts.readers ?? DEFAULT_READERS;
@@ -20,8 +33,19 @@ function createConverter(opts = {}) {
 		const reader = detect(bytes);
 		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);
+			losses.push(...readLosses);
+			const out = writeDocx(flow);
+			losses.push(...out.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: out.bytes,
+				losses
+			};
+		}
 		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);
@@ -31,6 +55,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);
@@ -43,7 +79,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)
@@ -98,4 +134,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';
+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

@@ -6,18 +6,21 @@ import { signPdf } from "../../pdf/signature.js";
 import { renderStyledPdf, renderStyledPdfEncrypted } from "../../pdf/styled-page-renderer.js";
 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"
 };
 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;
@@ -27,7 +30,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;
@@ -46,6 +50,25 @@ var Ream = class Ream {
 				losses
 			};
 		}
+		if (to === "docx") {
+			const docx = writeDocx(this.flow);
+			losses.push(...docx.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: docx.bytes,
+				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,21 @@ 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';
+export interface CellIcon {
+    readonly shape: CellIconShape;
+    readonly colorHex: string;
+}
+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 +244,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;

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/index.d.ts

@@ -4,3 +4,5 @@ export { REL_OFFICE_DOCUMENT, REL_CORE_PROPERTIES, REL_EXTENDED_PROPERTIES, } fr
 export { parseCoreProperties } from './core-properties.js';
 export type { CoreProperties } from './core-properties.js';
 export { isOoxmlRel } from './relationship-types.js';
+export { buildOpcPackage, relsPathFor } from './opc-writer.js';
+export type { OpcPart, OpcPartRelationships, OpcWriteOptions } from './opc-writer.js';

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

@@ -1,3 +1,4 @@
 import "./relationship-types.js";
 import "./package.js";
 import "./core-properties.js";
+import "./opc-writer.js";

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

@@ -0,0 +1,28 @@
+import { Relationship } from './relationships.js';
+export interface OpcPart {
+    /** Package path, e.g. 'word/document.xml'. No leading slash. */
+    readonly path: string;
+    readonly data: Uint8Array;
+    /** Content type for the [Content_Types].xml Override (XML parts). */
+    readonly contentType: string;
+}
+export interface OpcPartRelationships {
+    /** The owning part, e.g. 'word/document.xml' (or '' for the package root). */
+    readonly sourcePart: string;
+    readonly relationships: ReadonlyArray<Relationship>;
+}
+export interface OpcWriteOptions {
+    readonly parts: ReadonlyArray<OpcPart>;
+    /** Package-level relationships (_rels/.rels). */
+    readonly rootRelationships: ReadonlyArray<Relationship>;
+    /** Per-part relationships (word/_rels/<part>.rels). */
+    readonly partRelationships?: ReadonlyArray<OpcPartRelationships>;
+    /**
+     * Default content types by lowercase extension, for parts not given an
+     * Override (typically binaries: png, jpeg…). `rels` and `xml` are always
+     * present and need not be repeated.
+     */
+    readonly defaultsByExtension?: Readonly<Record<string, string>>;
+}
+export declare function buildOpcPackage(options: OpcWriteOptions): Uint8Array;
+export declare function relsPathFor(partPath: string): string;

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

@@ -0,0 +1,60 @@
+import { zipSync } from "fflate";
+//#region src/core/opc/opc-writer.ts
+var encoder = new TextEncoder();
+var RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+var CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
+var FIXED_MTIME = Date.UTC(1980, 0, 1, 0, 0, 0);
+function buildOpcPackage(options) {
+	const entries = {};
+	const add = (path, data) => {
+		entries[path] = [data, { mtime: FIXED_MTIME }];
+	};
+	add("[Content_Types].xml", encoder.encode(contentTypesXml(options)));
+	add("_rels/.rels", encoder.encode(relationshipsXml(options.rootRelationships)));
+	for (const part of options.parts) add(part.path, part.data);
+	for (const pr of options.partRelationships ?? []) {
+		if (pr.relationships.length === 0) continue;
+		add(relsPathFor(pr.sourcePart), encoder.encode(relationshipsXml(pr.relationships)));
+	}
+	return zipSync(entries);
+}
+function relsPathFor(partPath) {
+	const slash = partPath.lastIndexOf("/");
+	const dir = slash >= 0 ? partPath.slice(0, slash) : "";
+	const name = slash >= 0 ? partPath.slice(slash + 1) : partPath;
+	return dir ? `${dir}/_rels/${name}.rels` : `_rels/${name}.rels`;
+}
+function contentTypesXml(options) {
+	const defaults = {
+		rels: "application/vnd.openxmlformats-package.relationships+xml",
+		xml: "application/xml",
+		...options.defaultsByExtension ?? {}
+	};
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", `<Types xmlns="${CT_NS}">`];
+	for (const ext of Object.keys(defaults).sort()) lines.push(`<Default Extension="${ext}" ContentType="${escapeAttr(defaults[ext])}"/>`);
+	for (const part of options.parts) {
+		const ext = extensionOf(part.path);
+		if (ext !== void 0 && defaults[ext] === part.contentType) continue;
+		lines.push(`<Override PartName="/${escapeAttr(part.path)}" ContentType="${escapeAttr(part.contentType)}"/>`);
+	}
+	lines.push("</Types>");
+	return lines.join("");
+}
+function relationshipsXml(rels) {
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", `<Relationships xmlns="${RELS_NS}">`];
+	for (const r of rels) {
+		const mode = r.targetMode === "External" ? " TargetMode=\"External\"" : "";
+		lines.push(`<Relationship Id="${escapeAttr(r.id)}" Type="${escapeAttr(r.type)}" Target="${escapeAttr(r.target)}"${mode}/>`);
+	}
+	lines.push("</Relationships>");
+	return lines.join("");
+}
+function extensionOf(path) {
+	const dot = path.lastIndexOf(".");
+	return dot >= 0 ? path.slice(dot + 1).toLowerCase() : void 0;
+}
+function escapeAttr(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//#endregion
+export { buildOpcPackage, relsPathFor };

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, } from './types.js';