reamkit 1.4.0 → 1.5.0

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

@@ -0,0 +1,51 @@
+import { parseAreaRef } from "./defined-name-ref.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/table-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	removeNSPrefix: true
+});
+function parseTablePart(data) {
+	const t = asObj(parser.parse(decoder.decode(data))["table"]);
+	if (!t) return void 0;
+	const refStr = strAttr(t, "ref");
+	const ref = refStr ? parseAreaRef(refStr) : void 0;
+	if (!ref) return void 0;
+	const si = asObj(t["tableStyleInfo"]);
+	const name = strAttr(t, "name");
+	const styleName = si ? strAttr(si, "name") : void 0;
+	return {
+		ref,
+		...name ? { name } : {},
+		...styleName ? { styleName } : {},
+		headerRowCount: numAttr(t, "headerRowCount") ?? 1,
+		showRowStripes: si ? boolAttr(si, "showRowStripes") : false,
+		showColumnStripes: si ? boolAttr(si, "showColumnStripes") : false,
+		showFirstColumn: si ? boolAttr(si, "showFirstColumn") : false,
+		showLastColumn: si ? boolAttr(si, "showLastColumn") : false,
+		autoFilter: asObj(t["autoFilter"]) !== void 0
+	};
+}
+function asObj(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function strAttr(obj, name) {
+	const v = obj[`@_${name}`];
+	return typeof v === "string" ? v : void 0;
+}
+function numAttr(obj, name) {
+	const v = strAttr(obj, name);
+	if (v === void 0) return void 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : void 0;
+}
+function boolAttr(obj, name) {
+	const v = strAttr(obj, name);
+	return v === "1" || v === "true";
+}
+//#endregion
+export { parseTablePart };

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

@@ -1,13 +1,9 @@
+import { DefinedName } from '../core/spreadsheet-model/index.js';
 export interface SheetReference {
     readonly name: string;
     readonly sheetId: string;
     readonly relationshipId: string;
 }
-export interface DefinedName {
-    readonly name: string;
-    readonly localSheetId?: number;
-    readonly value: string;
-}
 export interface ParsedWorkbook {
     readonly sheets: ReadonlyArray<SheetReference>;
     readonly date1904: boolean;

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

@@ -1,61 +1,2 @@
-export type CellType = 'n' | 's' | 'str' | 'b' | 'd' | 'e' | 'inlineStr';
-export interface WorksheetCell {
-    readonly column: number;
-    readonly row: number;
-    readonly type: CellType;
-    readonly rawValue: string;
-    readonly inlineText?: string;
-    readonly styleIndex?: number;
-}
-export interface ColumnWidth {
-    readonly min: number;
-    readonly max: number;
-    readonly widthChars: number;
-}
-export interface MergedRange {
-    readonly startColumn: number;
-    readonly startRow: number;
-    readonly endColumn: number;
-    readonly endRow: number;
-}
-export interface RowHeight {
-    readonly row: number;
-    readonly heightPt: number;
-    readonly customHeight: boolean;
-}
-export interface XlsxPageMargins {
-    readonly leftInches: number;
-    readonly rightInches: number;
-    readonly topInches: number;
-    readonly bottomInches: number;
-    readonly headerInches?: number;
-    readonly footerInches?: number;
-}
-export interface XlsxPageSetup {
-    readonly paperSize?: number;
-    readonly orientation?: 'portrait' | 'landscape' | 'default';
-    readonly scale?: number;
-    readonly fitToWidth?: number;
-    readonly fitToHeight?: number;
-}
-export interface XlsxPrintOptions {
-    readonly gridLines?: boolean;
-    readonly horizontalCentered?: boolean;
-    readonly verticalCentered?: boolean;
-}
-export interface ParsedWorksheet {
-    readonly cells: ReadonlyArray<WorksheetCell>;
-    readonly maxRow: number;
-    readonly maxColumn: number;
-    readonly columns: ReadonlyArray<ColumnWidth>;
-    readonly merges: ReadonlyArray<MergedRange>;
-    readonly rowHeights: ReadonlyArray<RowHeight>;
-    readonly pageMargins?: XlsxPageMargins;
-    readonly pageSetup?: XlsxPageSetup;
-    readonly fitToPage?: boolean;
-    readonly printOptions?: XlsxPrintOptions;
-    readonly rowBreaks?: ReadonlyArray<number>;
-    readonly colBreaks?: ReadonlyArray<number>;
-    readonly drawingRelId?: string;
-}
+import { ParsedWorksheet } from '../core/spreadsheet-model/index.js';
 export declare function parseWorksheet(data: Uint8Array): ParsedWorksheet;

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

@@ -1,4 +1,5 @@
 import { parseCellRef } from "./cell-reference.js";
+import { parseAreaRef } from "./defined-name-ref.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/worksheet-parser.ts
 var decoder = new TextDecoder("utf-8");
@@ -34,6 +35,9 @@ function parseWorksheet(data) {
 	const colBreaks = parseBreaks(wsObj, "colBreaks");
 	const drawingNode = wsObj["drawing"];
 	const drawingRelId = drawingNode && typeof drawingNode === "object" ? strAttr(drawingNode, "id") : void 0;
+	const conditionalFormats = parseConditionalFormatting(wsObj);
+	const sparklines = parseSparklines(wsObj);
+	const tablePartRelIds = parseTableParts(wsObj);
 	const printModel = {
 		...pageMargins ? { pageMargins } : {},
 		...pageSetup ? { pageSetup } : {},
@@ -41,7 +45,10 @@ function parseWorksheet(data) {
 		...printOptions ? { printOptions } : {},
 		...rowBreaks.length > 0 ? { rowBreaks } : {},
 		...colBreaks.length > 0 ? { colBreaks } : {},
-		...drawingRelId !== void 0 ? { drawingRelId } : {}
+		...drawingRelId !== void 0 ? { drawingRelId } : {},
+		...conditionalFormats.length > 0 ? { conditionalFormats } : {},
+		...sparklines.length > 0 ? { sparklines } : {},
+		...tablePartRelIds.length > 0 ? { tablePartRelIds } : {}
 	};
 	const sheetData = wsObj["sheetData"];
 	if (!sheetData || typeof sheetData !== "object") return {
@@ -239,6 +246,237 @@ function parseMerges(ws) {
 	}
 	return out;
 }
+function parseConditionalFormatting(ws) {
+	const raw = ws["conditionalFormatting"];
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const sqref = strAttr(obj, "sqref");
+		if (!sqref) continue;
+		const ranges = parseSqref(sqref);
+		if (ranges.length === 0) continue;
+		const ruleRaw = obj["cfRule"];
+		const ruleItems = Array.isArray(ruleRaw) ? ruleRaw : ruleRaw !== void 0 ? [ruleRaw] : [];
+		const rules = [];
+		for (const rn of ruleItems) {
+			if (!rn || typeof rn !== "object") continue;
+			const rule = parseCfRule(rn);
+			if (rule) rules.push(rule);
+		}
+		if (rules.length > 0) out.push({
+			ranges,
+			rules
+		});
+	}
+	return out;
+}
+function parseSqref(sqref) {
+	const out = [];
+	for (const token of sqref.split(/\s+/)) {
+		if (!token) continue;
+		const r = parseAreaRef(token);
+		if (r) out.push({
+			startColumn: r.startColumn,
+			startRow: r.startRow,
+			endColumn: r.endColumn,
+			endRow: r.endRow
+		});
+	}
+	return out;
+}
+var CF_OPERATORS = new Set([
+	"lessThan",
+	"lessThanOrEqual",
+	"equal",
+	"notEqual",
+	"greaterThanOrEqual",
+	"greaterThan",
+	"between",
+	"notBetween"
+]);
+function parseCfRule(obj) {
+	const priority = parseNumericAttr(obj, "priority") ?? 0;
+	switch (strAttr(obj, "type")) {
+		case "cellIs": return parseCellIsRule(obj, priority);
+		case "colorScale": return parseColorScaleRule(obj, priority);
+		case "dataBar": return parseDataBarRule(obj, priority);
+		case "iconSet": return parseIconSetRule(obj, priority);
+		default: return;
+	}
+}
+function parseIconSetRule(obj, priority) {
+	const is = obj["iconSet"];
+	if (!is || typeof is !== "object") return void 0;
+	const isObj = is;
+	const cfvos = parseCfvos(isObj["cfvo"]);
+	if (cfvos.length < 3) return void 0;
+	const iconSet = strAttr(isObj, "iconSet") ?? "3TrafficLights1";
+	const reverseRaw = strAttr(isObj, "reverse");
+	const reverse = reverseRaw === "1" || reverseRaw === "true";
+	return {
+		type: "iconSet",
+		priority,
+		iconSet,
+		cfvos,
+		...reverse ? { reverse } : {}
+	};
+}
+function parseDataBarRule(obj, priority) {
+	const db = obj["dataBar"];
+	if (!db || typeof db !== "object") return void 0;
+	const dbObj = db;
+	const cfvos = parseCfvos(dbObj["cfvo"]);
+	if (cfvos.length < 2) return void 0;
+	const colorHex = colorRgbHex(dbObj["color"]);
+	if (!colorHex) return void 0;
+	const minLength = parseNumericAttr(dbObj, "minLength");
+	const maxLength = parseNumericAttr(dbObj, "maxLength");
+	return {
+		type: "dataBar",
+		priority,
+		cfvos,
+		colorHex,
+		...minLength !== void 0 ? { minLength } : {},
+		...maxLength !== void 0 ? { maxLength } : {}
+	};
+}
+function parseCellIsRule(obj, priority) {
+	const operator = strAttr(obj, "operator");
+	if (!operator || !CF_OPERATORS.has(operator)) return void 0;
+	const dxfId = parseNumericAttr(obj, "dxfId");
+	if (dxfId === void 0) return void 0;
+	const fRaw = obj["formula"];
+	const fItems = Array.isArray(fRaw) ? fRaw : fRaw !== void 0 ? [fRaw] : [];
+	const formulas = [];
+	for (const f of fItems) {
+		const text = formulaText(f);
+		if (text !== void 0) formulas.push(text);
+	}
+	if (formulas.length === 0) return void 0;
+	return {
+		type: "cellIs",
+		priority,
+		operator,
+		formulas,
+		dxfId
+	};
+}
+var CFVO_TYPES = new Set([
+	"num",
+	"percent",
+	"max",
+	"min",
+	"percentile",
+	"formula",
+	"autoMin",
+	"autoMax"
+]);
+function parseColorScaleRule(obj, priority) {
+	const cs = obj["colorScale"];
+	if (!cs || typeof cs !== "object") return void 0;
+	const csObj = cs;
+	const cfvos = parseCfvos(csObj["cfvo"]);
+	const colorsHex = parseScaleColors(csObj["color"]);
+	if (cfvos.length < 2 || cfvos.length !== colorsHex.length) return void 0;
+	return {
+		type: "colorScale",
+		priority,
+		cfvos,
+		colorsHex
+	};
+}
+function parseCfvos(raw) {
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const it of items) {
+		if (!it || typeof it !== "object") continue;
+		const o = it;
+		const type = strAttr(o, "type");
+		if (!type || !CFVO_TYPES.has(type)) return [];
+		const val = strAttr(o, "val");
+		out.push(val !== void 0 ? {
+			type,
+			val
+		} : { type });
+	}
+	return out;
+}
+function parseScaleColors(raw) {
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const it of items) {
+		const hex = colorRgbHex(it);
+		if (!hex) return [];
+		out.push(hex);
+	}
+	return out;
+}
+function colorRgbHex(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const rgb = strAttr(node, "rgb");
+	if (!rgb) return void 0;
+	if (/^[0-9A-Fa-f]{8}$/.test(rgb)) return rgb.substring(2).toUpperCase();
+	if (/^[0-9A-Fa-f]{6}$/.test(rgb)) return rgb.toUpperCase();
+}
+function formulaText(node) {
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	if (node && typeof node === "object") {
+		const t = node["#text"];
+		if (typeof t === "string") return t;
+		if (typeof t === "number") return String(t);
+	}
+}
+function toArray(v) {
+	return Array.isArray(v) ? v : v === void 0 || v === null ? [] : [v];
+}
+function parseSparklines(ws) {
+	const extLst = asObjectNode(ws["extLst"]);
+	if (!extLst) return [];
+	const out = [];
+	for (const ext of toArray(extLst["ext"])) {
+		const groupsNode = asObjectNode(asObjectNode(ext)?.["sparklineGroups"]);
+		if (!groupsNode) continue;
+		for (const g of toArray(groupsNode["sparklineGroup"])) {
+			const group = asObjectNode(g);
+			if (!group) continue;
+			const typeStr = strAttr(group, "type");
+			const kind = typeStr === "column" ? "column" : typeStr === "stacked" ? "winLoss" : "line";
+			const colorHex = colorRgbHex(group["colorSeries"]);
+			const slNode = asObjectNode(group["sparklines"]);
+			if (!slNode) continue;
+			for (const sl of toArray(slNode["sparkline"])) {
+				const spark = asObjectNode(sl);
+				if (!spark) continue;
+				const dataRange = formulaText(spark["f"]);
+				const sqref = formulaText(spark["sqref"]);
+				if (dataRange && sqref) out.push({
+					kind,
+					dataRange,
+					sqref,
+					...colorHex ? { colorHex } : {}
+				});
+			}
+		}
+	}
+	return out;
+}
+function asObjectNode(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function parseTableParts(ws) {
+	const node = asObjectNode(ws["tableParts"]);
+	if (!node) return [];
+	const out = [];
+	for (const tp of toArray(node["tablePart"])) {
+		const obj = asObjectNode(tp);
+		const rid = obj ? strAttr(obj, "id") : void 0;
+		if (rid) out.push(rid);
+	}
+	return out;
+}
 function parseCell(c, fallbackRow, fallbackCol) {
 	if (!c || typeof c !== "object") return null;
 	const obj = c;

package/dist/esm/excel/xlsx-reader.d.ts

@@ -1,4 +1,6 @@
 import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
 import { FlowDoc } from '../core/ir/flow.js';
+import { SheetDoc } from '../core/ir/sheet.js';
 export declare function readXlsx(xlsx: Uint8Array): ReadResult<FlowDoc>;
-export declare const xlsxReader: DocumentReader<FlowDoc>;
+export declare function readXlsxToSheetDoc(xlsx: Uint8Array): SheetDoc;
+export declare const xlsxReader: DocumentReader<SheetDoc>;

package/dist/esm/excel/xlsx-reader.js

@@ -1,8 +1,5 @@
-import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { FEATURES } from "../core/ir/features.js";
-import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
-import "../core/style-cascade/index.js";
 import { bytesInclude } from "../core/bytes.js";
 import { DEFAULT_THEME_PALETTE, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
@@ -16,14 +13,21 @@ import { parseWorkbook } from "./workbook-parser.js";
 import { parseWorksheet } from "./worksheet-parser.js";
 import { EMPTY_XLSX_STYLES, parseXlsxStyles } from "./styles-parser.js";
 import "./index.js";
-import { resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, worksheetToBody } from "./print-model.js";
 import { parseSheetDrawing } from "./sheet-drawing.js";
+import { parseTablePart } from "./table-parser.js";
+import { projectSheetDoc } from "./sheet-to-flow.js";
 //#region src/excel/xlsx-reader.ts
 var WORKBOOK_PART = "xl/workbook.xml";
 var SHARED_STRINGS_PART = "xl/sharedStrings.xml";
 var STYLES_PART = "xl/styles.xml";
 var CORE_PROPS_PART = "docProps/core.xml";
 function readXlsx(xlsx) {
+	return {
+		doc: projectSheetDoc(readXlsxToSheetDoc(xlsx)),
+		losses: []
+	};
+}
+function readXlsxToSheetDoc(xlsx) {
 	const pkg = OpcPackage.open(xlsx);
 	const workbookData = pkg.getPart(WORKBOOK_PART);
 	if (!workbookData) throw new Error("Not a valid xlsx: missing xl/workbook.xml");
@@ -34,10 +38,10 @@ function readXlsx(xlsx) {
 	const stylesData = pkg.getPart(STYLES_PART);
 	const styles = stylesData ? parseXlsxStyles(stylesData) : EMPTY_XLSX_STYLES;
 	const workbookRels = pkg.getPartRelationships(WORKBOOK_PART);
-	const body = [];
-	const charts = /* @__PURE__ */ new Map();
-	const resolveColor = buildXlsxColorResolver(pkg, workbookRels);
-	let firstSheetSection;
+	const chartData = /* @__PURE__ */ new Map();
+	const palette = buildThemePalette(pkg, workbookRels);
+	const resolveColor = makeColorResolver(palette);
+	const sheetsOut = [];
 	for (let sheetIdx = 0; sheetIdx < sheets.length; sheetIdx++) {
 		const sheet = sheets[sheetIdx];
 		const sheetRel = workbookRels.find((r) => r.id === sheet.relationshipId);
@@ -45,61 +49,61 @@ function readXlsx(xlsx) {
 		const resolved = pkg.resolveRelatedPart(WORKBOOK_PART, sheetRel);
 		if (!resolved) continue;
 		const worksheet = parseWorksheet(resolved.data);
-		if (sheetIdx === 0) firstSheetSection = sectionFromWorksheet(worksheet);
-		if (sheetIdx > 0) body.push({
-			kind: "paragraph",
-			paragraph: {
-				properties: { pageBreakBefore: true },
-				runs: []
-			}
-		});
-		const printArea = resolvePrintArea(definedNames, sheetIdx);
-		const titleRows = resolvePrintTitleRows(definedNames, sheetIdx);
-		const gridLines = worksheet.printOptions?.gridLines === true;
-		body.push(...worksheetToBody(worksheet, sharedStrings, styles, date1904, {
-			...printArea ? { printArea } : {},
-			...titleRows ? { titleRows } : {},
-			gridLines
-		}));
+		const charts = [];
 		if (worksheet.drawingRelId) {
 			const drawingRel = pkg.getPartRelationships(resolved.path).find((r) => r.id === worksheet.drawingRelId);
 			const drawing = drawingRel ? pkg.resolveRelatedPart(resolved.path, drawingRel) : void 0;
 			if (drawing) for (const ref of parseSheetDrawing(drawing.data, drawing.path, pkg, worksheet)) {
-				if (!charts.has(ref.chartPartPath)) {
-					const chartData = pkg.getPart(ref.chartPartPath);
-					const parsed = chartData ? parseChart(chartData, resolveColor) : null;
+				if (!chartData.has(ref.chartPartPath)) {
+					const chartXml = pkg.getPart(ref.chartPartPath);
+					const parsed = chartXml ? parseChart(chartXml, resolveColor) : null;
 					if (!parsed) continue;
-					charts.set(ref.chartPartPath, withChartColorStyle(parsed, pkg, ref.chartPartPath, resolveColor));
+					chartData.set(ref.chartPartPath, withChartColorStyle(parsed, pkg, ref.chartPartPath, resolveColor));
 				}
-				body.push({
-					kind: "chart",
-					chart: {
-						chartRelId: ref.chartPartPath,
-						width: pt(ref.widthPt),
-						height: pt(ref.heightPt),
-						paragraphProperties: {}
-					}
+				charts.push({
+					chartPartPath: ref.chartPartPath,
+					widthPt: ref.widthPt,
+					heightPt: ref.heightPt
 				});
 			}
 		}
+		let tables;
+		if (worksheet.tablePartRelIds && worksheet.tablePartRelIds.length > 0) {
+			const wsRels = pkg.getPartRelationships(resolved.path);
+			const resolvedTables = [];
+			for (const rid of worksheet.tablePartRelIds) {
+				const rel = wsRels.find((r) => r.id === rid);
+				const part = rel ? pkg.resolveRelatedPart(resolved.path, rel) : void 0;
+				const parsed = part ? parseTablePart(part.data) : void 0;
+				if (parsed) resolvedTables.push(resolveTableStyle(parsed, palette));
+			}
+			if (resolvedTables.length > 0) tables = resolvedTables;
+		}
+		const grid = tables ? {
+			...worksheet,
+			tables
+		} : worksheet;
+		sheetsOut.push({
+			name: sheet.name,
+			grid,
+			...charts.length > 0 ? { charts } : {}
+		});
 	}
 	const coreData = pkg.getPart(CORE_PROPS_PART);
 	const info = infoFromCore(coreData ? parseCoreProperties(coreData) : void 0);
 	return {
-		doc: {
-			kind: "flow",
-			body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
-			sections: [],
-			...firstSheetSection ? { section: firstSheetSection } : {},
-			styles: EMPTY_STYLE_SHEET,
-			resources: new ResourceStore(),
-			...charts.size > 0 ? { charts } : {},
-			...info ? { info } : {}
-		},
-		losses: []
+		kind: "sheet",
+		sheets: sheetsOut,
+		styles,
+		sharedStrings,
+		definedNames,
+		date1904,
+		...chartData.size > 0 ? { chartData } : {},
+		resources: new ResourceStore(),
+		...info ? { info } : {}
 	};
 }
-function buildXlsxColorResolver(pkg, workbookRels) {
+function buildThemePalette(pkg, workbookRels) {
 	const palette = new Map(DEFAULT_THEME_PALETTE);
 	for (const rel of workbookRels) {
 		if (!isOoxmlRel(rel.type, "theme")) continue;
@@ -108,14 +112,45 @@ function buildXlsxColorResolver(pkg, workbookRels) {
 		for (const [slot, hex] of parseTheme(resolved.data)) palette.set(slot, hex);
 		break;
 	}
-	return makeColorResolver(palette);
+	return palette;
+}
+function resolveTableStyle(t, palette) {
+	const m = t.styleName ? /TableStyle(Light|Medium|Dark)(\d+)/i.exec(t.styleName) : null;
+	if (!m) return t;
+	const kind = m[1].toLowerCase();
+	const column = (Number(m[2]) - 1) % 7;
+	const base = column === 0 ? "7F7F7F" : palette.get(`accent${column}`) ?? "4472C4";
+	if (kind === "light") return {
+		...t,
+		headerHex: lighten(base, .6),
+		bandHex: lighten(base, .85)
+	};
+	return {
+		...t,
+		headerHex: base,
+		bandHex: lighten(base, .8),
+		headerTextHex: "FFFFFF"
+	};
+}
+function lighten(hex, amount) {
+	const m = /^#?([0-9a-fA-F]{6})$/.exec(hex);
+	const n = m ? parseInt(m[1], 16) : 4485828;
+	const ch = (shift) => {
+		const c = n >> shift & 255;
+		return Math.round(c + (255 - c) * amount);
+	};
+	const hx = (c) => c.toString(16).padStart(2, "0").toUpperCase();
+	return `${hx(ch(16))}${hx(ch(8))}${hx(ch(0))}`;
 }
 var xlsxReader = {
 	id: "xlsx",
-	produces: "flow",
+	produces: "sheet",
 	supports: new Set([FEATURES.text, FEATURES.tables]),
 	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "xl/workbook.xml"),
-	read: (bytes) => readXlsx(bytes)
+	read: (bytes) => ({
+		doc: readXlsxToSheetDoc(bytes),
+		losses: []
+	})
 };
 function infoFromCore(core) {
 	if (!core) return void 0;

package/dist/esm/excel/xlsx-writer.d.ts

@@ -0,0 +1,4 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { SheetDoc } from '../core/ir/sheet.js';
+export declare function writeXlsx(sheet: SheetDoc): WriteResult;
+export declare const xlsxWriter: DocumentWriter<SheetDoc>;