reamkit 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Krassavin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# Ream
+
+> DOCX & XLSX → PDF, from scratch — no LibreOffice, no headless Office, no commercial SDK.
+
+Convert Word (`.docx`) and Excel (`.xlsx`) documents to PDF, **in the browser** —
+implemented from the **ECMA-376** (OOXML) and **ISO 32000** (PDF) specifications,
+with no wrapper around LibreOffice, headless Office, or any commercial SDK. Pure
+TypeScript/JavaScript working on `Uint8Array` in and `Uint8Array` out, so it also
+runs unchanged in Node.js, serverless, and edge runtimes.
+
+## Install
+
+```sh
+npm install reamkit
+```
+
+Runtime dependencies are minimal: `fflate` (ZIP/Deflate) and `fast-xml-parser`.
+
+## Usage
+
+Give it the document bytes, get the PDF bytes back. No fonts to wire up — an open
+substitute font (Roboto for sans, Tinos for serif, Cousine for monospace — the
+same families LibreOffice substitutes) is fetched automatically based on the
+document's referenced fonts:
+
+```ts
+import { convertDocxToPdf } from 'reamkit';
+
+// e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
+const docx = new Uint8Array(await file.arrayBuffer());
+
+const pdf = await convertDocxToPdf(docx); // async — fetches a font if needed
+
+// Hand the bytes to the browser: preview, download, upload, …
+const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
+window.open(url);
+```
+
+Excel works the same way via `convertXlsxToPdf`. The input/output are plain
+`Uint8Array`s, so wiring this to files, the network, or disk is up to you.
+
+### Bring your own fonts (synchronous, no network)
+
+To embed specific fonts — or to avoid the network entirely — pass the font bytes
+in and use the synchronous variant:
+
+```ts
+import { convertDocxToPdfSync } from 'reamkit';
+
+const fonts = {
+  regular: new Uint8Array(await fetch('/fonts/MyFont-Regular.ttf').then((r) => r.arrayBuffer())),
+  bold: new Uint8Array(await fetch('/fonts/MyFont-Bold.ttf').then((r) => r.arrayBuffer())),
+};
+const pdf = convertDocxToPdfSync(docx, { fonts });
+```
+
+The async `convertDocxToPdf` also accepts `fonts` (then it does no network I/O),
+plus `fontFamily` to force a substitute and `fontFetch` to inject a custom
+fetch implementation.
+
+### Options
+
+Both converters accept (beyond `fonts` / `fontBytes`):
+
+- `info` — PDF `/Info` metadata (`title`, `author`, `subject`, …). Also read
+  automatically from the document's `docProps/core.xml`.
+- `pdfA: 'PDF/A-1b'` — emit an archival PDF/A-1b file (embedded sRGB
+  OutputIntent, XMP, deterministic `/ID`, subset-tagged fonts, no transparency).
+- `hyphenator` — a Liang hyphenator (see below) for nicer justified text.
+
+### Hyphenation (optional)
+
+```ts
+import { getHyphenator } from 'reamkit';
+const hyphenator = await getHyphenator('en-us'); // or 'ru'
+const pdf = await convertDocxToPdf(docx, { hyphenator });
+```
+
+### Advanced
+
+`renderStyledPdf` drives the layout engine directly. The typed document model is
+available from the `reamkit/document-model` subpath.
+
+## Scope
+
+Implemented: WordprocessingML text/styles/tables/lists/sections/headers-footers/
+images, SpreadsheetML grids/number-formats/dates, Type0+CIDFontType2 font
+embedding with subsetting, Knuth-Plass line breaking, Liang hyphenation,
+OpenType ligatures + kerning, BiDi (UAX #9), and PDF/A-1b.
+
+See `handoff.md` for the full feature matrix and known limitations.
+
+## License
+
+[MIT](./LICENSE) © Alex Krassavin

package/dist/esm/bidi/algorithm.d.ts

@@ -0,0 +1,9 @@
+import { BidiClass } from './char-types.js';
+export type Direction = 'ltr' | 'rtl' | 'auto';
+export interface BidiResult {
+    readonly levels: ReadonlyArray<number>;
+    readonly paragraphLevel: number;
+    readonly types: ReadonlyArray<BidiClass>;
+}
+export declare function computeBidi(codePoints: ReadonlyArray<number>, dir: Direction): BidiResult;
+export declare function reorderVisual(levels: ReadonlyArray<number>): Array<number>;

package/dist/esm/bidi/algorithm.js

@@ -0,0 +1,458 @@
+import { bidiClass } from "./char-types.js";
+//#region src/bidi/algorithm.ts
+var MAX_DEPTH = 125;
+function matchingPDI(types, openIdx) {
+	let depth = 1;
+	for (let i = openIdx + 1; i < types.length; i++) {
+		const t = types[i];
+		if (t === "LRI" || t === "RLI" || t === "FSI") depth++;
+		else if (t === "PDI") {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return types.length;
+}
+function computeBaseLevel(types, start, end) {
+	for (let i = start; i < end; i++) {
+		const t = types[i];
+		if (t === "LRI" || t === "RLI" || t === "FSI") {
+			i = matchingPDI(types, i);
+			continue;
+		}
+		if (t === "L") return 0;
+		if (t === "R" || t === "AL") return 1;
+	}
+	return 0;
+}
+function computeBidi(codePoints, dir) {
+	const n = codePoints.length;
+	const origTypes = new Array(n);
+	for (let i = 0; i < n; i++) origTypes[i] = bidiClass(codePoints[i]);
+	const paragraphLevel = dir === "ltr" ? 0 : dir === "rtl" ? 1 : computeBaseLevel(origTypes, 0, n);
+	const types = origTypes.slice();
+	const levels = new Array(n).fill(paragraphLevel);
+	const stack = [{
+		level: paragraphLevel,
+		override: "neutral",
+		isolate: false
+	}];
+	let overflowIsolate = 0;
+	let overflowEmbedding = 0;
+	let validIsolate = 0;
+	const nextOddLevel = (lvl) => lvl % 2 === 0 ? lvl + 1 : lvl + 2;
+	const nextEvenLevel = (lvl) => lvl % 2 === 0 ? lvl + 2 : lvl + 1;
+	const top = () => stack[stack.length - 1];
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		switch (t) {
+			case "RLE":
+			case "LRE":
+			case "RLO":
+			case "LRO": {
+				const newLevel = t === "RLE" || t === "RLO" ? nextOddLevel(top().level) : nextEvenLevel(top().level);
+				levels[i] = top().level;
+				types[i] = "BN";
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) stack.push({
+					level: newLevel,
+					override: t === "RLO" ? "R" : t === "LRO" ? "L" : "neutral",
+					isolate: false
+				});
+				else if (overflowIsolate === 0) overflowEmbedding++;
+				break;
+			}
+			case "RLI":
+			case "LRI":
+			case "FSI": {
+				const ov = top().override;
+				levels[i] = top().level;
+				if (ov !== "neutral") types[i] = ov;
+				let isRTL = t === "RLI";
+				if (t === "FSI") {
+					const pdi = matchingPDI(types, i);
+					isRTL = computeBaseLevel(types, i + 1, pdi) === 1;
+				}
+				const newLevel = isRTL ? nextOddLevel(top().level) : nextEvenLevel(top().level);
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) {
+					validIsolate++;
+					stack.push({
+						level: newLevel,
+						override: "neutral",
+						isolate: true
+					});
+				} else overflowIsolate++;
+				break;
+			}
+			case "PDI": {
+				if (overflowIsolate > 0) overflowIsolate--;
+				else if (validIsolate > 0) {
+					overflowEmbedding = 0;
+					while (!top().isolate) stack.pop();
+					stack.pop();
+					validIsolate--;
+				}
+				const ov = top().override;
+				levels[i] = top().level;
+				if (ov !== "neutral") types[i] = ov;
+				break;
+			}
+			case "PDF":
+				levels[i] = top().level;
+				types[i] = "BN";
+				if (overflowIsolate > 0) {} else if (overflowEmbedding > 0) overflowEmbedding--;
+				else if (!top().isolate && stack.length >= 2) stack.pop();
+				break;
+			case "B":
+				levels[i] = paragraphLevel;
+				break;
+			default: {
+				const ov = top().override;
+				levels[i] = top().level;
+				if (ov !== "neutral") types[i] = ov;
+				break;
+			}
+		}
+	}
+	const sequences = buildIsolatingRunSequences(types, levels, paragraphLevel);
+	for (const seq of sequences) {
+		resolveWeakTypes(types, seq);
+		resolveNeutralTypes(types, levels, seq, codePoints);
+		resolveImplicitLevels(types, levels, seq);
+	}
+	applyL1(origTypes, types, levels, paragraphLevel);
+	return {
+		levels,
+		paragraphLevel,
+		types
+	};
+}
+function isRemoved(t) {
+	return t === "BN" || t === "RLE" || t === "LRE" || t === "RLO" || t === "LRO" || t === "PDF";
+}
+function buildIsolatingRunSequences(types, levels, paragraphLevel) {
+	const n = types.length;
+	const runs = [];
+	let current = [];
+	let currentLevel = -1;
+	for (let i = 0; i < n; i++) {
+		if (isRemoved(types[i])) continue;
+		if (current.length === 0) {
+			current = [i];
+			currentLevel = levels[i];
+		} else if (levels[i] === currentLevel) current.push(i);
+		else {
+			runs.push(current);
+			current = [i];
+			currentLevel = levels[i];
+		}
+	}
+	if (current.length > 0) runs.push(current);
+	const runByFirst = /* @__PURE__ */ new Map();
+	for (let r = 0; r < runs.length; r++) runByFirst.set(runs[r][0], r);
+	const used = new Array(runs.length).fill(false);
+	const sequences = [];
+	for (let r = 0; r < runs.length; r++) {
+		if (used[r]) continue;
+		const firstIdx = runs[r][0];
+		if (types[firstIdx] === "PDI" && matchesAnInitiator(types, firstIdx)) continue;
+		const seqIndices = [];
+		let cur = r;
+		for (;;) {
+			used[cur] = true;
+			seqIndices.push(...runs[cur]);
+			const lastIdx = runs[cur][runs[cur].length - 1];
+			const lastType = types[lastIdx];
+			if (lastType === "LRI" || lastType === "RLI" || lastType === "FSI") {
+				const pdi = matchingPDI(types, lastIdx);
+				if (pdi < n) {
+					const nextRun = runByFirst.get(pdi);
+					if (nextRun !== void 0 && !used[nextRun]) {
+						cur = nextRun;
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		const seqLevel = levels[seqIndices[0]];
+		const prevLevel = levelBefore(types, levels, seqIndices[0], paragraphLevel);
+		const lastSeqIdx = seqIndices[seqIndices.length - 1];
+		const lastType = types[lastSeqIdx];
+		let nextLevel;
+		if (lastType === "LRI" || lastType === "RLI" || lastType === "FSI") nextLevel = paragraphLevel;
+		else nextLevel = levelAfter(types, levels, lastSeqIdx, paragraphLevel);
+		const sos = Math.max(seqLevel, prevLevel) % 2 === 0 ? "L" : "R";
+		const eos = Math.max(seqLevel, nextLevel) % 2 === 0 ? "L" : "R";
+		sequences.push({
+			indices: seqIndices,
+			sos,
+			eos
+		});
+	}
+	return sequences;
+}
+function matchesAnInitiator(types, pdiIdx) {
+	let depth = 1;
+	for (let i = pdiIdx - 1; i >= 0; i--) {
+		const t = types[i];
+		if (t === "PDI") depth++;
+		else if (t === "LRI" || t === "RLI" || t === "FSI") {
+			depth--;
+			if (depth === 0) return true;
+		}
+	}
+	return false;
+}
+function levelBefore(types, levels, idx, paragraphLevel) {
+	for (let i = idx - 1; i >= 0; i--) if (!isRemoved(types[i])) return levels[i];
+	return paragraphLevel;
+}
+function levelAfter(types, levels, idx, paragraphLevel) {
+	for (let i = idx + 1; i < types.length; i++) if (!isRemoved(types[i])) return levels[i];
+	return paragraphLevel;
+}
+function resolveWeakTypes(types, seq) {
+	const idx = seq.indices;
+	const isIsolateType = (t) => t === "LRI" || t === "RLI" || t === "FSI" || t === "PDI";
+	let prevType = seq.sos;
+	for (const i of idx) {
+		if (types[i] === "NSM") types[i] = isIsolateType(prevType) ? "ON" : prevType;
+		prevType = types[i];
+	}
+	let lastStrong = seq.sos;
+	for (const i of idx) {
+		const t = types[i];
+		if (t === "R" || t === "L" || t === "AL") lastStrong = t;
+		else if (t === "EN" && lastStrong === "AL") types[i] = "AN";
+	}
+	for (const i of idx) if (types[i] === "AL") types[i] = "R";
+	for (let k = 1; k < idx.length - 1; k++) {
+		const i = idx[k];
+		const t = types[i];
+		const prev = types[idx[k - 1]];
+		const next = types[idx[k + 1]];
+		if (t === "ES" && prev === "EN" && next === "EN") types[i] = "EN";
+		else if (t === "CS" && prev === "EN" && next === "EN") types[i] = "EN";
+		else if (t === "CS" && prev === "AN" && next === "AN") types[i] = "AN";
+	}
+	for (let k = 0; k < idx.length; k++) {
+		if (types[idx[k]] !== "ET") continue;
+		let runEnd = k;
+		while (runEnd < idx.length && types[idx[runEnd]] === "ET") runEnd++;
+		const before = k > 0 ? types[idx[k - 1]] : seq.sos;
+		const after = runEnd < idx.length ? types[idx[runEnd]] : seq.eos;
+		if (before === "EN" || after === "EN") for (let j = k; j < runEnd; j++) types[idx[j]] = "EN";
+		k = runEnd - 1;
+	}
+	for (const i of idx) {
+		const t = types[i];
+		if (t === "ES" || t === "ET" || t === "CS") types[i] = "ON";
+	}
+	lastStrong = seq.sos;
+	for (const i of idx) {
+		const t = types[i];
+		if (t === "R" || t === "L") lastStrong = t;
+		else if (t === "EN" && lastStrong === "L") types[i] = "L";
+	}
+}
+var BRACKET_OPEN_TO_CLOSE = new Map([
+	[40, 41],
+	[91, 93],
+	[123, 125],
+	[8261, 8262],
+	[8317, 8318],
+	[8333, 8334],
+	[8968, 8969],
+	[8970, 8971],
+	[9001, 9002],
+	[10214, 10215],
+	[10216, 10217],
+	[10218, 10219],
+	[10220, 10221],
+	[10222, 10223],
+	[10627, 10628],
+	[10629, 10630],
+	[10631, 10632],
+	[10633, 10634],
+	[10635, 10636],
+	[10637, 10638],
+	[10639, 10640],
+	[10641, 10642],
+	[10643, 10644],
+	[10645, 10646],
+	[10647, 10648],
+	[12296, 12297],
+	[12298, 12299],
+	[12300, 12301],
+	[12302, 12303],
+	[12304, 12305],
+	[12308, 12309],
+	[12310, 12311],
+	[12312, 12313],
+	[12314, 12315],
+	[65288, 65289],
+	[65339, 65341],
+	[65371, 65373],
+	[65375, 65376],
+	[65378, 65379]
+]);
+function canonBracket(cp) {
+	if (cp === 9001) return 12296;
+	if (cp === 9002) return 12297;
+	return cp;
+}
+var CLOSE_BRACKETS = /* @__PURE__ */ new Set();
+for (const c of BRACKET_OPEN_TO_CLOSE.values()) CLOSE_BRACKETS.add(canonBracket(c));
+function resolvePairedBrackets(types, levels, seq, codePoints) {
+	const idx = seq.indices;
+	if (idx.length === 0) return;
+	const e = levels[idx[0]] % 2 === 0 ? "L" : "R";
+	const o = e === "L" ? "R" : "L";
+	const stack = [];
+	const pairs = [];
+	for (let p = 0; p < idx.length; p++) {
+		if (types[idx[p]] !== "ON") continue;
+		const cp = canonBracket(codePoints[idx[p]]);
+		const closing = BRACKET_OPEN_TO_CLOSE.get(cp);
+		if (closing !== void 0) {
+			if (stack.length === 63) break;
+			stack.push({
+				close: canonBracket(closing),
+				pos: p
+			});
+		} else if (CLOSE_BRACKETS.has(cp)) {
+			for (let s = stack.length - 1; s >= 0; s--) if (stack[s].close === cp) {
+				pairs.push({
+					open: stack[s].pos,
+					close: p
+				});
+				stack.length = s;
+				break;
+			}
+		}
+	}
+	pairs.sort((a, b) => a.open - b.open);
+	for (const { open, close } of pairs) {
+		let foundE = false;
+		let foundO = false;
+		for (let p = open + 1; p < close; p++) {
+			const d = directionOf(types[idx[p]]);
+			if (d === e) {
+				foundE = true;
+				break;
+			}
+			if (d === o) foundO = true;
+		}
+		let setDir = null;
+		if (foundE) setDir = e;
+		else if (foundO) {
+			let prev = "other";
+			for (let p = open - 1; p >= 0; p--) {
+				const d = directionOf(types[idx[p]]);
+				if (d !== "other") {
+					prev = d;
+					break;
+				}
+			}
+			if (prev === "other") prev = directionOf(seq.sos);
+			setDir = prev === o ? o : e;
+		}
+		if (setDir) {
+			types[idx[open]] = setDir;
+			types[idx[close]] = setDir;
+		}
+	}
+}
+function resolveNeutralTypes(types, levels, seq, codePoints) {
+	const idx = seq.indices;
+	const isNeutralOrIsolate = (t) => t === "B" || t === "S" || t === "WS" || t === "ON" || t === "LRI" || t === "RLI" || t === "FSI" || t === "PDI";
+	resolvePairedBrackets(types, levels, seq, codePoints);
+	let k = 0;
+	while (k < idx.length) {
+		if (!isNeutralOrIsolate(types[idx[k]])) {
+			k++;
+			continue;
+		}
+		let runEnd = k;
+		while (runEnd < idx.length && isNeutralOrIsolate(types[idx[runEnd]])) runEnd++;
+		const leftDir = directionOf(k > 0 ? types[idx[k - 1]] : seq.sos);
+		const rightDir = directionOf(runEnd < idx.length ? types[idx[runEnd]] : seq.eos);
+		let resolved;
+		if (leftDir === rightDir && (leftDir === "L" || leftDir === "R")) resolved = leftDir;
+		else resolved = levels[idx[k]] % 2 === 0 ? "L" : "R";
+		for (let j = k; j < runEnd; j++) types[idx[j]] = resolved;
+		k = runEnd;
+	}
+}
+function directionOf(t) {
+	if (t === "L") return "L";
+	if (t === "R" || t === "EN" || t === "AN") return "R";
+	return "other";
+}
+function resolveImplicitLevels(types, levels, seq) {
+	for (const i of seq.indices) {
+		const t = types[i];
+		const lvl = levels[i];
+		if (lvl % 2 === 0) {
+			if (t === "R") levels[i] = lvl + 1;
+			else if (t === "AN" || t === "EN") levels[i] = lvl + 2;
+		} else if (t === "L" || t === "EN" || t === "AN") levels[i] = lvl + 1;
+	}
+}
+function applyL1(origTypes, types, levels, paragraphLevel) {
+	const n = levels.length;
+	const isResettableWS = (t) => t === "WS" || t === "LRI" || t === "RLI" || t === "FSI" || t === "PDI" || isRemoved(t);
+	let i = 0;
+	while (i < n) {
+		const ot = origTypes[i];
+		if (ot === "B" || ot === "S") {
+			levels[i] = paragraphLevel;
+			let j = i - 1;
+			while (j >= 0 && isResettableWS(origTypes[j])) {
+				levels[j] = paragraphLevel;
+				j--;
+			}
+		}
+		i++;
+	}
+	let j = n - 1;
+	while (j >= 0 && isResettableWS(origTypes[j])) {
+		levels[j] = paragraphLevel;
+		j--;
+	}
+}
+function reorderVisual(levels) {
+	const n = levels.length;
+	const order = Array.from({ length: n }, (_, i) => i);
+	if (n === 0) return order;
+	let highest = 0;
+	let lowestOdd = MAX_DEPTH + 1;
+	for (const lvl of levels) {
+		if (lvl > highest) highest = lvl;
+		if (lvl % 2 === 1 && lvl < lowestOdd) lowestOdd = lvl;
+	}
+	for (let level = highest; level >= lowestOdd; level--) {
+		let k = 0;
+		while (k < n) {
+			if (levels[order[k]] < level) {
+				k++;
+				continue;
+			}
+			let runEnd = k;
+			while (runEnd < n && levels[order[runEnd]] >= level) runEnd++;
+			let a = k;
+			let b = runEnd - 1;
+			while (a < b) {
+				const tmp = order[a];
+				order[a] = order[b];
+				order[b] = tmp;
+				a++;
+				b--;
+			}
+			k = runEnd;
+		}
+	}
+	return order;
+}
+//#endregion
+export { computeBidi, reorderVisual };

package/dist/esm/bidi/char-types.d.ts

@@ -0,0 +1,2 @@
+export type BidiClass = 'L' | 'R' | 'AL' | 'EN' | 'ES' | 'ET' | 'AN' | 'CS' | 'NSM' | 'BN' | 'B' | 'S' | 'WS' | 'ON' | 'LRE' | 'LRO' | 'RLE' | 'RLO' | 'PDF' | 'LRI' | 'RLI' | 'FSI' | 'PDI';
+export declare function bidiClass(cp: number): BidiClass;