reamkit 1.14.0 → 1.15.0

package/dist/esm/word/doc/doc-reader.d.ts

@@ -0,0 +1,4 @@
+import { DocumentReader, ReadResult } from '../../core/ir/adapters.js';
+import { FlowDoc } from '../../core/ir/flow.js';
+export declare function readDoc(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const docReader: DocumentReader<FlowDoc>;

package/dist/esm/word/doc/doc-reader.js

@@ -0,0 +1,421 @@
+import { pt, twipsToPt } 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 { isCfb, openCfb } from "../../core/ole/cfb.js";
+import { extractDocContent } from "./doc-text.js";
+//#region src/word/doc/doc-reader.ts
+var ZERO_WIDTH_SPACE = "​";
+var CONTENT_WIDTH_PT = 468;
+var LIST_BULLETS = [
+	"•",
+	"◦",
+	"▪"
+];
+var LIST_INDENT_PT = 18;
+var TABLE_BORDER = {
+	style: "single",
+	width: pt(.5),
+	colorHex: "000000"
+};
+var TABLE_BORDERS = {
+	top: TABLE_BORDER,
+	right: TABLE_BORDER,
+	bottom: TABLE_BORDER,
+	left: TABLE_BORDER,
+	insideH: TABLE_BORDER,
+	insideV: TABLE_BORDER
+};
+function createListMarkers(tables) {
+	const counters = /* @__PURE__ */ new Map();
+	const resolve = (ilfo, ilvl) => {
+		if (!tables || ilfo < 1 || ilfo > tables.lfoLsids.length) return void 0;
+		const lsid = tables.lfoLsids[ilfo - 1];
+		const list = tables.lists.get(lsid);
+		const lvl = list?.levels[list.simple ? 0 : ilvl];
+		return list && lvl ? {
+			lsid,
+			lvl
+		} : void 0;
+	};
+	return { marker(ilfo, ilvl) {
+		const r = resolve(ilfo, ilvl);
+		if (!r) return void 0;
+		const { lsid, lvl } = r;
+		if (lvl.nfc === 23 || lvl.nfc === 255 || !lvl.xst.some((cu) => cu <= 8)) return lvl.xst.map((cu) => String.fromCharCode(cu)).join("");
+		const col = counters.get(lsid) ?? [];
+		col[ilvl] = (col[ilvl] ?? lvl.iStartAt - 1) + 1;
+		for (let l = ilvl + 1; l < col.length; l++) col[l] = void 0;
+		counters.set(lsid, col);
+		let out = "";
+		for (const cu of lvl.xst) if (cu <= 8) {
+			const other = resolve(ilfo, cu);
+			out += formatListNumber(other?.lvl.nfc ?? 0, col[cu] ?? other?.lvl.iStartAt ?? 1);
+		} else out += String.fromCharCode(cu);
+		return out;
+	} };
+}
+function formatListNumber(nfc, n) {
+	switch (nfc) {
+		case 1: return toRoman(n);
+		case 2: return toRoman(n).toLowerCase();
+		case 3: return toLetters(n);
+		case 4: return toLetters(n).toLowerCase();
+		case 22: return n < 10 ? `0${n}` : String(n);
+		default: return String(n);
+	}
+}
+function toLetters(n) {
+	let s = "";
+	while (n > 0) {
+		n--;
+		s = String.fromCharCode(65 + n % 26) + s;
+		n = Math.floor(n / 26);
+	}
+	return s;
+}
+var ROMAN = [
+	[1e3, "M"],
+	[900, "CM"],
+	[500, "D"],
+	[400, "CD"],
+	[100, "C"],
+	[90, "XC"],
+	[50, "L"],
+	[40, "XL"],
+	[10, "X"],
+	[9, "IX"],
+	[5, "V"],
+	[4, "IV"],
+	[1, "I"]
+];
+function toRoman(n) {
+	if (n <= 0) return String(n);
+	let out = "";
+	for (const [v, sym] of ROMAN) while (n >= v) out += sym, n -= v;
+	return out;
+}
+function looksLikeDoc(bytes) {
+	if (!isCfb(bytes)) return false;
+	try {
+		return openCfb(bytes).hasStream("WordDocument");
+	} catch {
+		return false;
+	}
+}
+var DOC_TEXT_LOSS = {
+	severity: "degraded",
+	feature: FEATURES.text,
+	detail: "legacy .doc: the document text, run formatting (bold/italic/underline/size), paragraph formatting (alignment/indent/spacing), tables (with column widths, cell borders, vertical merges and cell background shading), inline images, fields, the section's headers/footers and list items (with their number format / bullet) are read; drawing shapes / text boxes and comments are not (re-save as .docx for full fidelity)"
+};
+var DOC_ENCRYPTED_LOSS = {
+	severity: "dropped",
+	feature: FEATURES.text,
+	detail: "legacy .doc is encrypted/obfuscated — its text cannot be read"
+};
+function readDoc(bytes) {
+	const content = extractDocContent(bytes);
+	const resources = new ResourceStore();
+	const body = buildBody(content, resources);
+	const headersFooters = /* @__PURE__ */ new Map();
+	const headers = [];
+	const footers = [];
+	const addStory = (story, kind, type) => {
+		if (!story) return;
+		const id = `${kind}-${type}`;
+		const els = resolveBodyStyles(story.flatMap((p) => mapParagraph(p, resources)), EMPTY_STYLE_SHEET);
+		headersFooters.set(id, els);
+		(kind === "header" ? headers : footers).push({
+			type,
+			relationshipId: id
+		});
+	};
+	const hf = content.headerFooters;
+	if (hf) {
+		addStory(hf.defaultHeader, "header", "default");
+		addStory(hf.firstHeader, "header", "first");
+		addStory(hf.evenHeader, "header", "even");
+		addStory(hf.defaultFooter, "footer", "default");
+		addStory(hf.firstFooter, "footer", "first");
+		addStory(hf.evenFooter, "footer", "even");
+	}
+	return {
+		doc: {
+			kind: "flow",
+			body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
+			sections: [],
+			section: {
+				pageSize: {
+					width: pt(612),
+					height: pt(792)
+				},
+				margins: {
+					top: pt(72),
+					right: pt(72),
+					bottom: pt(72),
+					left: pt(72)
+				},
+				headers,
+				footers
+			},
+			styles: EMPTY_STYLE_SHEET,
+			resources,
+			...headersFooters.size > 0 ? { headersFooters } : {}
+		},
+		losses: [content.encrypted ? DOC_ENCRYPTED_LOSS : DOC_TEXT_LOSS]
+	};
+}
+function buildBody(content, resources) {
+	const markers = createListMarkers(content.listTables);
+	const body = groupTables(content.paragraphs, resources, markers);
+	while (body.length > 1 && isEmptyParagraph(body[body.length - 1])) body.pop();
+	if (body.length === 0) body.push(emptyParagraph());
+	return body;
+}
+function groupTables(paras, resources, markers) {
+	const out = [];
+	let i = 0;
+	while (i < paras.length) if (paras[i].props.inTable) {
+		const group = [];
+		while (i < paras.length && paras[i].props.inTable) group.push(paras[i++]);
+		out.push({
+			kind: "table",
+			table: buildTable(group, resources, markers)
+		});
+	} else out.push(...mapParagraph(paras[i++], resources, markers));
+	return out;
+}
+function buildTable(group, resources, markers) {
+	const edges = group.find((p) => p.props.cellEdgesTwips)?.props.cellEdgesTwips;
+	const rawRows = [];
+	let rowParas = [];
+	for (const p of group) {
+		rowParas.push(p);
+		if (p.props.rowEnd) {
+			rawRows.push(buildRawRow(rowParas, resources, edges, markers));
+			rowParas = [];
+		}
+	}
+	if (rowParas.length > 0) rawRows.push(buildRawRow(rowParas, resources, edges, markers));
+	resolveVerticalMerges(rawRows);
+	const rows = rawRows.map((cells) => ({
+		properties: {},
+		cells: cells.map(toTableCell)
+	}));
+	return {
+		properties: {
+			borders: TABLE_BORDERS,
+			layout: "fixed"
+		},
+		grid: columnWidths(edges, rows),
+		rows
+	};
+}
+function columnWidths(edges, rows) {
+	if (edges && edges.length >= 2) {
+		const widths = [];
+		for (let i = 0; i + 1 < edges.length; i++) widths.push(twipsToPt(Math.max(0, edges[i + 1] - edges[i])));
+		return widths;
+	}
+	const cols = Math.max(1, ...rows.map((r) => r.cells.length));
+	const even = pt(CONTENT_WIDTH_PT / cols);
+	return Array.from({ length: cols }, () => even);
+}
+function buildRawRow(rowParas, resources, edges, markers) {
+	const descriptors = rowParas.find((p) => p.props.cellDescriptors)?.props.cellDescriptors;
+	const shadings = rowParas.find((p) => p.props.cellShadings)?.props.cellShadings;
+	const cells = [];
+	let col = 0;
+	for (const p of rowParas) {
+		if (p.props.rowEnd && isBlank(p)) continue;
+		const tc = descriptors?.[col];
+		cells.push({
+			content: mapParagraph(p, resources, markers),
+			width: cellWidth(edges, col),
+			borders: tc?.borders ? toCellBorders(tc.borders) : void 0,
+			shading: shadings?.[col],
+			vMergeRaw: tc?.vMerge
+		});
+		col++;
+	}
+	if (cells.length === 0) cells.push({
+		content: [emptyParagraph()],
+		width: void 0,
+		borders: void 0,
+		shading: void 0,
+		vMergeRaw: void 0
+	});
+	return cells;
+}
+function resolveVerticalMerges(rows) {
+	const maxCols = Math.max(0, ...rows.map((r) => r.length));
+	for (let c = 0; c < maxCols; c++) {
+		let span = [];
+		const close = () => {
+			if (span.length >= 2) {
+				span[0].merge = "start";
+				span[span.length - 1].merge = "end";
+				for (let k = 1; k < span.length - 1; k++) span[k].merge = "middle";
+			}
+			span = [];
+		};
+		for (const row of rows) {
+			const cell = row[c];
+			if (cell?.vMergeRaw === "restart") {
+				close();
+				span = [cell];
+			} else if (cell?.vMergeRaw === "continue" && span.length > 0) span.push(cell);
+			else close();
+		}
+		close();
+	}
+}
+function toTableCell(raw) {
+	return {
+		properties: {
+			...raw.width ? { width: raw.width } : {},
+			...raw.borders ? { borders: raw.borders } : {},
+			...raw.shading ? { shading: { colorHex: raw.shading } } : {},
+			...raw.merge ? { merge: raw.merge } : {}
+		},
+		content: raw.content
+	};
+}
+function toCellBorders(b) {
+	const edge = (db) => db ? {
+		style: db.double ? "double" : "single",
+		width: pt(db.widthPt),
+		colorHex: db.colorHex
+	} : void 0;
+	const top = edge(b.top);
+	const left = edge(b.left);
+	const bottom = edge(b.bottom);
+	const right = edge(b.right);
+	return {
+		...top ? { top } : {},
+		...left ? { left } : {},
+		...bottom ? { bottom } : {},
+		...right ? { right } : {}
+	};
+}
+function cellWidth(edges, col) {
+	if (edges && col + 1 < edges.length) {
+		const w = edges[col + 1] - edges[col];
+		if (w > 0) return twipsToPt(w);
+	}
+}
+function isBlank(p) {
+	return p.runs.every((r) => r.text.length === 0 && r.picture === void 0);
+}
+function mapParagraph(p, resources, markers) {
+	const out = [];
+	const textRuns = p.runs.filter((r) => r.picture === void 0);
+	const ilvl = p.props.listIlvl ?? 0;
+	const isList = (p.props.listIlfo ?? 0) > 0;
+	if (textRuns.some((r) => r.text.length > 0) || isList) {
+		const runs = textRuns.map((r) => ({
+			text: r.text,
+			properties: toRunProperties(r.props)
+		}));
+		let properties = toParaProperties(p.props);
+		if (isList) {
+			const marker = markers?.marker(p.props.listIlfo, ilvl) ?? LIST_BULLETS[ilvl % LIST_BULLETS.length];
+			runs.unshift({
+				text: `${marker} `,
+				properties: {}
+			});
+			properties = {
+				...properties,
+				indentLeft: pt((ilvl + 1) * LIST_INDENT_PT)
+			};
+		}
+		out.push({
+			kind: "paragraph",
+			paragraph: {
+				properties,
+				runs: runs.length > 0 ? runs : [{
+					text: ZERO_WIDTH_SPACE,
+					properties: {}
+				}]
+			}
+		});
+	}
+	for (const r of p.runs) if (r.picture) out.push(imageBlock(r.picture, resources, toParaProperties(p.props)));
+	if (out.length === 0) out.push(emptyParagraph());
+	return out;
+}
+function imageBlock(pic, resources, paragraphProperties) {
+	return {
+		kind: "image",
+		image: {
+			resource: resources.put(pic.bytes),
+			width: twipsToPt(pic.widthTwips),
+			height: twipsToPt(pic.heightTwips),
+			paragraphProperties
+		}
+	};
+}
+function emptyParagraph() {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: {},
+			runs: [{
+				text: ZERO_WIDTH_SPACE,
+				properties: {}
+			}]
+		}
+	};
+}
+function isEmptyParagraph(el) {
+	return el.kind === "paragraph" && el.paragraph.runs.length === 1 && el.paragraph.runs[0].text === ZERO_WIDTH_SPACE;
+}
+function toRunProperties(p) {
+	const underline = p.underlineKul ? underlineStyle(p.underlineKul) : void 0;
+	const size = p.sizeHalfPts && p.sizeHalfPts > 0 ? pt(p.sizeHalfPts / 2) : void 0;
+	return {
+		...p.bold ? { bold: true } : {},
+		...p.italic ? { italic: true } : {},
+		...underline ? { underline } : {},
+		...size ? { fontSizePt: size } : {}
+	};
+}
+function toParaProperties(p) {
+	const alignment = p.jc !== void 0 ? alignmentFromJc(p.jc) : void 0;
+	return {
+		...alignment ? { alignment } : {},
+		...p.indentLeftTwips !== void 0 ? { indentLeft: pt(p.indentLeftTwips / 20) } : {},
+		...p.indentRightTwips !== void 0 ? { indentRight: pt(p.indentRightTwips / 20) } : {},
+		...p.indentFirstTwips !== void 0 ? { indentFirstLine: pt(p.indentFirstTwips / 20) } : {},
+		...p.spaceBeforeTwips !== void 0 ? { spacingBefore: pt(p.spaceBeforeTwips / 20) } : {},
+		...p.spaceAfterTwips !== void 0 ? { spacingAfter: pt(p.spaceAfterTwips / 20) } : {}
+	};
+}
+function underlineStyle(kul) {
+	switch (kul) {
+		case 0: return;
+		case 3: return "double";
+		case 4: return "dotted";
+		case 7: return "dash";
+		default: return "single";
+	}
+}
+function alignmentFromJc(jc) {
+	switch (jc) {
+		case 1: return "center";
+		case 2: return "right";
+		case 3: return "both";
+		case 4: return "distribute";
+		default: return;
+	}
+}
+var docReader = {
+	id: "doc",
+	produces: "flow",
+	supports: new Set([FEATURES.text]),
+	sniff: looksLikeDoc,
+	read: (bytes) => readDoc(bytes)
+};
+//#endregion
+export { docReader };

package/dist/esm/word/doc/doc-text.d.ts

@@ -0,0 +1,79 @@
+export interface DocCharProps {
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underlineKul?: number;
+    readonly sizeHalfPts?: number;
+    readonly fSpec?: boolean;
+    readonly picOffset?: number;
+}
+export interface DocPicture {
+    readonly bytes: Uint8Array;
+    readonly widthTwips: number;
+    readonly heightTwips: number;
+}
+export interface DocBorder {
+    readonly widthPt: number;
+    readonly colorHex: string;
+    readonly double?: boolean;
+}
+export interface DocTc {
+    readonly borders?: {
+        readonly top?: DocBorder;
+        readonly left?: DocBorder;
+        readonly bottom?: DocBorder;
+        readonly right?: DocBorder;
+    };
+    readonly vMerge?: 'restart' | 'continue';
+}
+export interface DocParaProps {
+    readonly jc?: number;
+    readonly indentLeftTwips?: number;
+    readonly indentRightTwips?: number;
+    readonly indentFirstTwips?: number;
+    readonly spaceBeforeTwips?: number;
+    readonly spaceAfterTwips?: number;
+    readonly inTable?: boolean;
+    readonly rowEnd?: boolean;
+    readonly cellEdgesTwips?: ReadonlyArray<number>;
+    readonly cellDescriptors?: ReadonlyArray<DocTc>;
+    readonly cellShadings?: ReadonlyArray<string | undefined>;
+    readonly listIlfo?: number;
+    readonly listIlvl?: number;
+}
+export interface DocRun {
+    readonly text: string;
+    readonly props: DocCharProps;
+    readonly picture?: DocPicture;
+}
+export interface DocParagraph {
+    readonly runs: ReadonlyArray<DocRun>;
+    readonly props: DocParaProps;
+    readonly cellMark?: boolean;
+}
+export interface DocHeaderFooters {
+    readonly defaultHeader?: ReadonlyArray<DocParagraph>;
+    readonly defaultFooter?: ReadonlyArray<DocParagraph>;
+    readonly firstHeader?: ReadonlyArray<DocParagraph>;
+    readonly firstFooter?: ReadonlyArray<DocParagraph>;
+    readonly evenHeader?: ReadonlyArray<DocParagraph>;
+    readonly evenFooter?: ReadonlyArray<DocParagraph>;
+}
+export interface DocLvl {
+    readonly nfc: number;
+    readonly iStartAt: number;
+    readonly xst: ReadonlyArray<number>;
+}
+export interface DocListTables {
+    readonly lfoLsids: ReadonlyArray<number>;
+    readonly lists: ReadonlyMap<number, {
+        readonly simple: boolean;
+        readonly levels: ReadonlyArray<DocLvl>;
+    }>;
+}
+export interface DocContent {
+    readonly paragraphs: ReadonlyArray<DocParagraph>;
+    readonly headerFooters?: DocHeaderFooters;
+    readonly listTables?: DocListTables;
+    readonly encrypted: boolean;
+}
+export declare function extractDocContent(bytes: Uint8Array): DocContent;