reamkit 1.0.1 → 1.1.0

package/README.md

@@ -33,6 +33,7 @@ const bytes = new Uint8Array(await file.arrayBuffer());
 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
 
 // Hand the bytes to the browser: preview, download, upload, …
 const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
@@ -147,7 +148,7 @@ automatically from the document's `docProps/core.xml`), `attachments`
 
 ### Lower-level APIs
 
-- `docxReader` / `xlsxReader`, `svgWriter` — the `@experimental` reader/writer
+- `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.
@@ -163,7 +164,7 @@ 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), tagged PDF, PDF/A-1/2/3 (a/b/u), digital signatures
-(PKCS#7/ECDSA/PAdES/RFC 3161), SVG page preview.
+(PKCS#7/ECDSA/PAdES/RFC 3161), SVG page preview, flowed HTML export.
 
 See `handoff.md` for the full feature matrix and known limitations.
 

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

@@ -1 +1,2 @@
+export declare function toBase64(bytes: Uint8Array): string;
 export declare function bytesInclude(haystack: Uint8Array, needle: string): boolean;

package/dist/esm/core/bytes.js

@@ -1,4 +1,9 @@
 //#region src/core/bytes.ts
+function toBase64(bytes) {
+	let bin = "";
+	for (const b of bytes) bin += String.fromCharCode(b);
+	return btoa(bin);
+}
 function bytesInclude(haystack, needle) {
 	const n = new TextEncoder().encode(needle);
 	outer: for (let i = 0; i + n.length <= haystack.length; i++) {
@@ -8,4 +13,4 @@ function bytesInclude(haystack, needle) {
 	return false;
 }
 //#endregion
-export { bytesInclude };
+export { bytesInclude, toBase64 };

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

@@ -5,8 +5,8 @@ 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 format: 'pdf' (default) or 'svg' (page-stack preview). */
-    readonly to?: 'pdf' | 'svg';
+    /** Target: 'pdf' (default), 'svg' (page-stack preview) or 'html' (flowed). */
+    readonly to?: 'pdf' | 'svg' | 'html';
     /**
      * Strict mode (handoff v1 §5): throw ConversionLossError on the first
      * recorded loss instead of returning it in the report.

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

@@ -6,6 +6,7 @@ import { docxReader } from "../../word/docx-reader.js";
 import { xlsxReader } from "../../excel/xlsx-reader.js";
 import { chainProviders } from "../fonts/provider.js";
 import { flowRenderOptions } from "./project.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";
@@ -19,6 +20,17 @@ 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 === "html") {
+			const { doc: flow, losses: readLosses } = reader.read(bytes);
+			losses.push(...readLosses);
+			const html = writeHtml(flow);
+			losses.push(...html.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: html.bytes,
+				losses
+			};
+		}
 		let conv = rest;
 		if (fontProviders && fontProviders.length > 0 && !rest.fonts && !rest.fontBytes) {
 			const { fonts, loss } = await resolveFontsViaChain(fontProviders);

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

@@ -6,7 +6,7 @@ import { Loss } from '../ir/index.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
 import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
-export type ReamTarget = 'pdf' | 'svg';
+export type ReamTarget = 'pdf' | 'svg' | 'html';
 export interface ReamParseOptions {
     readonly readers?: ReadonlyArray<DocumentReader>;
 }

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

@@ -6,6 +6,7 @@ import { signPdf } from "../../pdf/signature.js";
 import { renderStyledPdf } from "../../pdf/styled-page-renderer.js";
 import "../../pdf/index.js";
 import { flowRenderOptions } from "./project.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";
@@ -36,6 +37,15 @@ var Ream = class Ream {
 	}
 	async convertWithReport(to, options = {}) {
 		const losses = [...this.losses];
+		if (to === "html") {
+			const html = writeHtml(this.flow);
+			losses.push(...html.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: html.bytes,
+				losses
+			};
+		}
 		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
 		const registry = FontRegistry.fromBytes(fonts);
 		if (to === "svg") {

package/dist/esm/core/style-cascade/resolver.d.ts

@@ -3,5 +3,5 @@ import { ResolvedParagraphProperties, ResolvedRunProperties } from './types.js';
 export declare const EMPTY_STYLE_SHEET: StyleSheet;
 export declare function resolveRunProperties(runDirect: RunProperties, paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedRunProperties;
 export declare function resolveParagraphProperties(paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedParagraphProperties;
-export declare function resolveBodyStyles(body: ReadonlyArray<BodyElement>, sheet: StyleSheet): Array<BodyElement>;
+export declare function resolveBodyStyles(body: ReadonlyArray<BodyElement>, sheet: StyleSheet): ReadonlyArray<BodyElement>;
 export declare function resolveHeadersFootersStyles(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>>, sheet: StyleSheet): ReadonlyMap<string, ReadonlyArray<BodyElement>>;

package/dist/esm/core/style-cascade/resolver.js

@@ -35,7 +35,20 @@ function computeRunProperties(runDirect, paragraphDirect, sheet) {
 	}
 	return mergeRun(acc, runDirect);
 }
+var paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
 function resolveParagraphProperties(paragraphDirect, sheet) {
+	let bySheet = paragraphCascadeCache.get(sheet);
+	if (!bySheet) {
+		bySheet = /* @__PURE__ */ new WeakMap();
+		paragraphCascadeCache.set(sheet, bySheet);
+	}
+	const hit = bySheet.get(paragraphDirect);
+	if (hit) return hit;
+	const resolved = computeParagraphProperties(paragraphDirect, sheet);
+	bySheet.set(paragraphDirect, resolved);
+	return resolved;
+}
+function computeParagraphProperties(paragraphDirect, sheet) {
 	let acc = mergePar(DEFAULT_RESOLVED_PARAGRAPH, sheet.defaultParagraphProperties);
 	if (paragraphDirect.styleId) {
 		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
@@ -117,52 +130,45 @@ function copyDefined(base, override) {
 	}
 	return out;
 }
+function primeResolvedFixpoint(run, para) {
+	let bySheet = runCascadeCache.get(EMPTY_STYLE_SHEET);
+	if (!bySheet) {
+		bySheet = /* @__PURE__ */ new WeakMap();
+		runCascadeCache.set(EMPTY_STYLE_SHEET, bySheet);
+	}
+	let byRun = bySheet.get(run);
+	if (!byRun) {
+		byRun = /* @__PURE__ */ new WeakMap();
+		bySheet.set(run, byRun);
+	}
+	if (!byRun.has(para)) byRun.set(para, run);
+}
+function primeParagraphFixpoint(para) {
+	let bySheet = paragraphCascadeCache.get(EMPTY_STYLE_SHEET);
+	if (!bySheet) {
+		bySheet = /* @__PURE__ */ new WeakMap();
+		paragraphCascadeCache.set(EMPTY_STYLE_SHEET, bySheet);
+	}
+	if (!bySheet.has(para)) bySheet.set(para, para);
+}
 function resolveBodyStyles(body, sheet) {
-	const visitParagraph = (p) => ({
-		...p,
-		properties: resolveParagraphProperties(p.properties, sheet),
-		runs: p.runs.map((r) => ({
-			...r,
-			properties: resolveRunProperties(r.properties, p.properties, sheet)
-		}))
-	});
+	const visitParagraph = (p) => {
+		for (const r of p.runs) r.properties = resolveRunProperties(r.properties, p.properties, sheet);
+		p.properties = resolveParagraphProperties(p.properties, sheet);
+		primeParagraphFixpoint(p.properties);
+		for (const r of p.runs) primeResolvedFixpoint(r.properties, p.properties);
+	};
 	const visit = (el) => {
-		if (el.kind === "paragraph") return {
-			kind: "paragraph",
-			paragraph: visitParagraph(el.paragraph)
-		};
-		if (el.kind === "table") return {
-			kind: "table",
-			table: {
-				...el.table,
-				rows: el.table.rows.map((row) => ({
-					...row,
-					cells: row.cells.map((cell) => ({
-						...cell,
-						content: cell.content.map(visit)
-					}))
-				}))
-			}
-		};
-		if (el.kind === "shape" && el.shape.text) return {
-			kind: "shape",
-			shape: {
-				...el.shape,
-				text: {
-					...el.shape.text,
-					content: el.shape.text.content.map(visit)
-				}
-			}
-		};
-		return el;
+		if (el.kind === "paragraph") visitParagraph(el.paragraph);
+		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) for (const child of cell.content) visit(child);
+		else if (el.kind === "shape" && el.shape.text) for (const child of el.shape.text.content) visit(child);
 	};
-	return body.map(visit);
+	for (const el of body) visit(el);
+	return body;
 }
 function resolveHeadersFootersStyles(hf, sheet) {
-	if (hf.size === 0) return hf;
-	const out = /* @__PURE__ */ new Map();
-	for (const [key, value] of hf) out.set(key, resolveBodyStyles(value, sheet));
-	return out;
+	for (const value of hf.values()) resolveBodyStyles(value, sheet);
+	return hf;
 }
 //#endregion
 export { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles, resolveParagraphProperties, resolveRunProperties };

package/dist/esm/excel/print-model.js

@@ -169,6 +169,25 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	const scaled = printScale < .999;
 	const breakRows = new Set(worksheet.rowBreaks ?? []);
 	let textBudget = MAX_SHEET_TEXT_CHARS;
+	const runPropsByXf = /* @__PURE__ */ new Map();
+	const cellRunProps = (xf) => {
+		let props = runPropsByXf.get(xf);
+		if (props === void 0) {
+			const base = xf ? runPropsFromXf(xf, styles) : {};
+			props = scaled ? scaleRunFont(base, printScale) : base;
+			runPropsByXf.set(xf, props);
+		}
+		return props;
+	};
+	const paraPropsByAlignment = /* @__PURE__ */ new Map();
+	const cellParaProps = (alignment) => {
+		let props = paraPropsByAlignment.get(alignment);
+		if (props === void 0) {
+			props = alignment ? { alignment } : {};
+			paraPropsByAlignment.set(alignment, props);
+		}
+		return props;
+	};
 	const rows = [];
 	for (let r = 0; r < rowCount; r++) {
 		const absR = r + rowStart;
@@ -186,8 +205,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 			if (text.length > textBudget) text = text.slice(0, Math.max(0, textBudget));
 			textBudget -= text.length;
 			const xf = ws && ws.styleIndex !== void 0 ? styles.cellXfs[ws.styleIndex] : void 0;
-			const baseRunProps = xf ? runPropsFromXf(xf, styles) : {};
-			const runProps = scaled ? scaleRunFont(baseRunProps, printScale) : baseRunProps;
+			const runProps = cellRunProps(xf);
 			const alignment = xf ? alignmentFromXf(xf) : void 0;
 			const shading = xf ? shadingFromXf(xf, styles) : void 0;
 			const borders = xf ? bordersFromXf(xf, styles) : void 0;
@@ -210,7 +228,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				...shading ? { shading } : {},
 				...borders ? { borders } : {}
 			};
-			const paragraphProps = alignment ? { alignment } : {};
+			const paragraphProps = cellParaProps(alignment);
 			cells.push({
 				properties,
 				content: [{

package/dist/esm/html/html-writer.d.ts

@@ -0,0 +1,4 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function writeHtml(flow: FlowDoc): WriteResult;
+export declare const htmlWriter: DocumentWriter<FlowDoc>;

package/dist/esm/html/html-writer.js

@@ -0,0 +1,292 @@
+import { FEATURES } from "../core/ir/features.js";
+import { detectImageFormat } from "../core/images.js";
+import { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { toBase64 } from "../core/bytes.js";
+//#region src/html/html-writer.ts
+function writeHtml(flow) {
+	const losses = [];
+	const out = [];
+	const ctx = {
+		resources: flow.resources,
+		losses
+	};
+	const lang = flow.language ?? "en-US";
+	const title = flow.info?.title ?? "Document";
+	out.push("<!DOCTYPE html>");
+	out.push(`<html lang="${escapeAttr(lang)}">`);
+	out.push("<head>");
+	out.push("<meta charset=\"utf-8\"/>");
+	out.push("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/>");
+	out.push(`<title>${escapeText(title)}</title>`);
+	out.push(`<style>${BASE_CSS}</style>`);
+	out.push("</head>");
+	out.push("<body>");
+	out.push(`<article style="max-width: ${fmt(contentWidthPt(flow))}pt">`);
+	if (flow.headersFooters && flow.headersFooters.size > 0) losses.push({
+		severity: "dropped",
+		feature: FEATURES.headersFooters,
+		detail: "headers/footers have no fixed pages to band onto in flowed HTML"
+	});
+	for (const el of flow.body) emitBlock(out, el, ctx);
+	out.push("</article>");
+	out.push("</body>");
+	out.push("</html>");
+	return {
+		bytes: new TextEncoder().encode(out.join("\n")),
+		losses
+	};
+}
+var htmlWriter = {
+	id: "html",
+	consumes: "flow",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.tablesNested,
+		FEATURES.lists,
+		FEATURES.images,
+		FEATURES.rtl,
+		FEATURES.trackedChanges
+	]),
+	write: (doc) => writeHtml(doc)
+};
+var BASE_CSS = [
+	"body{margin:24pt;color:#000;background:#fff}",
+	"article{margin:0 auto}",
+	"p,h1,h2,h3,h4,h5,h6,figure{margin:0}",
+	"table{border-collapse:collapse}",
+	"td,th{vertical-align:top}",
+	"th{text-align:inherit}",
+	".tab{display:inline-block;min-width:18pt}",
+	"img{vertical-align:baseline}"
+].join("");
+function emitBlock(out, el, ctx) {
+	if (el.kind === "paragraph") emitParagraph(out, el.paragraph, ctx);
+	else if (el.kind === "table") emitTable(out, el.table, ctx);
+	else if (el.kind === "image") emitImageBlock(out, el.image, ctx);
+	else if (el.kind === "chart") ctx.losses.push({
+		severity: "dropped",
+		feature: FEATURES.charts,
+		detail: "chart not rendered by the HTML writer (v0)"
+	});
+	else {
+		ctx.losses.push({
+			severity: "dropped",
+			feature: FEATURES.shapes,
+			detail: "shape geometry not rendered by the HTML writer (v0)"
+		});
+		if (el.shape.text) {
+			out.push("<div>");
+			for (const child of el.shape.text.content) emitBlock(out, child, ctx);
+			out.push("</div>");
+		}
+	}
+}
+function emitParagraph(out, p, ctx) {
+	const resolved = resolveParagraphProperties(p.properties, EMPTY_STYLE_SHEET);
+	const lvl = resolved.outlineLevel;
+	const tag = lvl !== void 0 && lvl >= 0 && lvl <= 8 ? `h${Math.min(lvl, 5) + 1}` : "p";
+	const style = paragraphCss(resolved);
+	const open = `<${tag}${resolved.bidi ? " dir=\"rtl\"" : ""}${style ? ` style="${style}"` : ""}>`;
+	const parts = [];
+	for (const run of p.runs) parts.push(runHtml(run, p, ctx));
+	out.push(`${open}${parts.join("") || "&nbsp;"}</${tag}>`);
+}
+function paragraphCss(r) {
+	const css = [];
+	if (r.alignment === "center" || r.alignment === "right") css.push(`text-align:${r.alignment}`);
+	else if (r.alignment === "both" || r.alignment === "distribute") css.push("text-align:justify");
+	if (r.spacingBefore > 0) css.push(`margin-top:${fmt(r.spacingBefore)}pt`);
+	if (r.spacingAfter > 0) css.push(`margin-bottom:${fmt(r.spacingAfter)}pt`);
+	if (r.indentLeft !== 0) css.push(`margin-left:${fmt(r.indentLeft)}pt`);
+	if (r.indentRight !== 0) css.push(`margin-right:${fmt(r.indentRight)}pt`);
+	if (r.indentFirstLine !== 0) css.push(`text-indent:${fmt(r.indentFirstLine)}pt`);
+	if (r.spacingLine > 0) if (r.spacingLineRule === "auto") css.push(`line-height:${fmt(r.spacingLine / 12)}`);
+	else css.push(`line-height:${fmt(r.spacingLine)}pt`);
+	if (r.pageBreakBefore) css.push("break-before:page");
+	return css.join(";");
+}
+function runHtml(run, p, ctx) {
+	if (run.math !== void 0) {
+		ctx.losses.push({
+			severity: "dropped",
+			feature: FEATURES.math,
+			detail: "inline math not rendered by the HTML writer (v0)"
+		});
+		return "";
+	}
+	if (run.inlineImage) {
+		const img = run.inlineImage;
+		const src = dataUri(img.resource, ctx.resources);
+		if (!src) return "";
+		return `<img src="${src}" style="width:${fmt(img.width)}pt;height:${fmt(img.height)}pt" alt=""/>`;
+	}
+	if (run.text.length === 0) return "";
+	const resolved = resolveRunProperties(run.properties, p.properties, EMPTY_STYLE_SHEET);
+	const style = runCss(resolved);
+	let html = `<span${resolved.rtl ? " dir=\"rtl\"" : ""}${style ? ` style="${style}"` : ""}>${textHtml(run.text)}</span>`;
+	if (resolved.verticalAlign === "superscript") html = `<sup>${html}</sup>`;
+	else if (resolved.verticalAlign === "subscript") html = `<sub>${html}</sub>`;
+	return html;
+}
+function runCss(r) {
+	const css = [];
+	const family = r.fontFamily.ascii;
+	if (family) css.push(`font-family:${JSON.stringify(family)}`);
+	css.push(`font-size:${fmt(r.fontSizePt)}pt`);
+	if (r.bold) css.push("font-weight:700");
+	if (r.italic) css.push("font-style:italic");
+	const deco = [];
+	const underlined = r.underline !== "none";
+	if (underlined) deco.push("underline");
+	if (r.strike) deco.push("line-through");
+	if (deco.length > 0) {
+		css.push(`text-decoration-line:${deco.join(" ")}`);
+		const style = underlined ? decorationStyle(r.underline) : void 0;
+		if (style) css.push(`text-decoration-style:${style}`);
+	}
+	if (r.colorHex !== "000000") css.push(`color:#${r.colorHex}`);
+	return css.join(";");
+}
+function decorationStyle(u) {
+	switch (u) {
+		case "double": return "double";
+		case "dotted":
+		case "dottedHeavy": return "dotted";
+		case "dash":
+		case "dashHeavy": return "dashed";
+		case "wave": return "wavy";
+		default: return;
+	}
+}
+function textHtml(text) {
+	return escapeText(text).replaceAll("	", "<span class=\"tab\"></span>").replaceAll("\n", "<br/>");
+}
+function emitTable(out, table, ctx) {
+	const css = [];
+	if (table.properties.widthPt !== void 0) css.push(`width:${fmt(table.properties.widthPt)}pt`);
+	else if (table.properties.widthFraction !== void 0) css.push(`width:${fmt(table.properties.widthFraction * 100)}%`);
+	if (table.properties.alignment === "center") css.push("margin-left:auto;margin-right:auto");
+	else if (table.properties.alignment === "right") css.push("margin-left:auto");
+	out.push(`<table${css.length > 0 ? ` style="${css.join(";")}"` : ""}>`);
+	if (table.grid.length > 0) {
+		out.push("<colgroup>");
+		for (const w of table.grid) out.push(`<col style="width:${fmt(w)}pt"/>`);
+		out.push("</colgroup>");
+	}
+	const colStarts = table.rows.map((row) => {
+		let col = 0;
+		return row.cells.map((cell) => {
+			const start = col;
+			col += cell.properties.colSpan ?? 1;
+			return start;
+		});
+	});
+	for (let ri = 0; ri < table.rows.length; ri++) {
+		const row = table.rows[ri];
+		out.push("<tr>");
+		for (let ci = 0; ci < row.cells.length; ci++) {
+			const cell = row.cells[ci];
+			const merge = cell.properties.merge;
+			if (merge === "middle" || merge === "end") continue;
+			const rowSpan = merge === "start" ? mergeRowSpan(table, colStarts, ri, colStarts[ri][ci]) : 1;
+			emitCell(out, cell, table, ctx, {
+				isHeader: row.properties.isHeader === true,
+				firstRow: ri === 0,
+				lastRow: ri === table.rows.length - 1,
+				firstCol: colStarts[ri][ci] === 0,
+				lastCol: colStarts[ri][ci] + (cell.properties.colSpan ?? 1) >= table.grid.length,
+				rowSpan
+			});
+		}
+		out.push("</tr>");
+	}
+	out.push("</table>");
+}
+function mergeRowSpan(table, colStarts, startRow, colStart) {
+	let span = 1;
+	for (let r = startRow + 1; r < table.rows.length; r++) {
+		const row = table.rows[r];
+		const idx = colStarts[r].findIndex((c) => c === colStart);
+		const merge = (idx >= 0 ? row.cells[idx] : void 0)?.properties.merge;
+		if (merge !== "middle" && merge !== "end") break;
+		span++;
+		if (merge === "end") break;
+	}
+	return span;
+}
+function emitCell(out, cell, table, ctx, pos) {
+	const tag = pos.isHeader ? "th" : "td";
+	const attrs = [];
+	const colSpan = cell.properties.colSpan ?? 1;
+	if (colSpan > 1) attrs.push(`colspan="${colSpan}"`);
+	if (pos.rowSpan > 1) attrs.push(`rowspan="${pos.rowSpan}"`);
+	const css = [];
+	const t = table.properties.borders;
+	const c = cell.properties.borders;
+	pushBorder(css, "top", c?.top ?? (pos.firstRow ? t?.top : t?.insideH));
+	pushBorder(css, "bottom", c?.bottom ?? (pos.lastRow ? t?.bottom : t?.insideH));
+	pushBorder(css, "left", c?.left ?? (pos.firstCol ? t?.left : t?.insideV));
+	pushBorder(css, "right", c?.right ?? (pos.lastCol ? t?.right : t?.insideV));
+	if (cell.properties.shading) css.push(`background-color:#${cell.properties.shading.colorHex}`);
+	const margins = cell.properties.margins ?? table.properties.defaultCellMargins;
+	const padTop = margins?.top ?? 0;
+	const padRight = margins?.right ?? 5.4;
+	const padBottom = margins?.bottom ?? 0;
+	const padLeft = margins?.left ?? 5.4;
+	css.push(`padding:${fmt(padTop)}pt ${fmt(padRight)}pt ${fmt(padBottom)}pt ${fmt(padLeft)}pt`);
+	out.push(`<${tag}${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""} style="${css.join(";")}">`);
+	for (const child of cell.content) emitBlock(out, child, ctx);
+	out.push(`</${tag}>`);
+}
+function pushBorder(css, side, border) {
+	if (!border || border.style === "none") return;
+	const width = border.width ?? .5;
+	const style = border.style === "double" ? "double" : border.style === "dotted" ? "dotted" : border.style === "dashed" ? "dashed" : "solid";
+	css.push(`border-${side}:${fmt(width)}pt ${style} #${border.colorHex ?? "000000"}`);
+}
+function emitImageBlock(out, image, ctx) {
+	const src = dataUri(image.resource, ctx.resources);
+	if (!src) return;
+	const pp = image.paragraphProperties;
+	const align = pp.alignment === "center" || pp.alignment === "right" ? pp.alignment : void 0;
+	const css = [];
+	if (align) css.push(`text-align:${align}`);
+	if (pp.spacingBefore !== void 0 && pp.spacingBefore > 0) css.push(`margin-top:${fmt(pp.spacingBefore)}pt`);
+	if (pp.spacingAfter !== void 0 && pp.spacingAfter > 0) css.push(`margin-bottom:${fmt(pp.spacingAfter)}pt`);
+	const alt = image.altText ?? "";
+	out.push(`<figure${css.length > 0 ? ` style="${css.join(";")}"` : ""}><img src="${src}" style="width:${fmt(image.width)}pt;height:${fmt(image.height)}pt" alt="${escapeAttr(alt)}"/></figure>`);
+}
+var MIME_BY_FORMAT = {
+	jpeg: "image/jpeg",
+	png: "image/png",
+	jpeg2000: "image/jp2"
+};
+function dataUri(resource, store) {
+	if (resource === void 0) return void 0;
+	const bytes = store.get(resource);
+	if (!bytes) return void 0;
+	const format = detectImageFormat(bytes);
+	if (!format) return void 0;
+	return `data:${MIME_BY_FORMAT[format]};base64,${toBase64(bytes)}`;
+}
+function contentWidthPt(flow) {
+	const props = flow.sections[0]?.properties ?? flow.section;
+	const pageWidth = props?.pageSize?.width ?? 595;
+	const left = props?.margins?.left ?? 72;
+	const right = props?.margins?.right ?? 72;
+	return Math.max(72, pageWidth - left - right);
+}
+function escapeText(s) {
+	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(s) {
+	return escapeText(s).replaceAll("\"", "&quot;");
+}
+function fmt(n) {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+//#endregion
+export { htmlWriter, writeHtml };

package/dist/esm/index.d.ts

@@ -23,5 +23,6 @@ export { chainProviders, callerFontProvider, embeddedDocFontProvider, remoteFont
 export type { FontProvider, FontRequest, FontAnswer } from './core/fonts/provider.js';
 export { svgWriter, writeSvg } from './svg/svg-writer.js';
 export type { SvgWriteOptions } from './svg/svg-writer.js';
+export { htmlWriter, writeHtml } from './html/html-writer.js';
 export { layoutStyledDocument } from './layout/styled-layout.js';
 export type { LaidOutDocument } from './layout/page-doc.js';

package/dist/esm/index.js

@@ -15,7 +15,8 @@ import { createLanguageHyphenator, getHyphenator } from "./core/hyphenation/inde
 import { docxReader, readDocx } from "./word/docx-reader.js";
 import { readXlsx, xlsxReader } from "./excel/xlsx-reader.js";
 import { NO_FONT, callerFontProvider, chainProviders, embeddedDocFontProvider, isEmbeddingRestricted, localFontProvider, readOs2FsType, remoteFontProvider } from "./core/fonts/provider.js";
+import { htmlWriter, writeHtml } from "./html/html-writer.js";
 import { svgWriter, writeSvg } from "./svg/svg-writer.js";
 import { createConverter } from "./core/converter/facade.js";
 import { Ream } from "./core/converter/ream.js";
-export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, inchToPt, isEmbeddingRestricted, layoutStyledDocument, localFontProvider, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeSvg, xlsxReader };
+export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, layoutStyledDocument, localFontProvider, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeHtml, writeSvg, xlsxReader };

package/dist/esm/svg/svg-writer.js

@@ -1,5 +1,6 @@
 import { FEATURES } from "../core/ir/features.js";
 import { paintPlan } from "../layout/page-doc.js";
+import { toBase64 } from "../core/bytes.js";
 //#region src/svg/svg-writer.ts
 var PAGE_GAP = 12;
 function writeSvg(laid, opts = {}) {
@@ -121,11 +122,6 @@ function imageHref(resourceName, laid) {
 		return `data:${res.prepared.mimeType};base64,${toBase64(bytes)}`;
 	}
 }
-function toBase64(bytes) {
-	let bin = "";
-	for (const b of bytes) bin += String.fromCharCode(b);
-	return btoa(bin);
-}
 function escapeXml(s) {
 	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "reamkit",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Ream — DOCX/XLSX to PDF (and SVG), built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
-  "author": "Alex Krassavin",
+  "author": "Alex Krassavin <info@reamkit.dev>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/alex-krassavin/reamkit.git"