reamkit 0.1.0-alpha.0 → 1.0.1

package/dist/esm/pdf/text-page-renderer.d.ts

@@ -1,4 +1,4 @@
-import { ParsedTtf } from '../font/index.js';
+import { ParsedTtf } from '../core/font/index.js';
 export type FontInput = ParsedTtf | {
     readonly bytes: Uint8Array;
 };

package/dist/esm/pdf/vector-graphics.d.ts

@@ -1,46 +1,4 @@
-export type PathSegment = {
-    readonly op: 'move';
-    readonly x: number;
-    readonly y: number;
-} | {
-    readonly op: 'line';
-    readonly x: number;
-    readonly y: number;
-} | {
-    readonly op: 'cubic';
-    readonly x1: number;
-    readonly y1: number;
-    readonly x2: number;
-    readonly y2: number;
-    readonly x: number;
-    readonly y: number;
-} | {
-    readonly op: 'close';
-};
-export interface VectorPath {
-    readonly segments: ReadonlyArray<PathSegment>;
-    readonly fillRule?: 'nonzero' | 'evenodd';
-}
-export interface StrokeStyle {
-    readonly colorHex: string;
-    readonly widthPt: number;
-    readonly cap?: 'butt' | 'round' | 'square';
-    readonly join?: 'miter' | 'round' | 'bevel';
-    readonly dash?: ReadonlyArray<number>;
-}
-export interface VectorShape {
-    readonly paths: ReadonlyArray<VectorPath>;
-    readonly fillColorHex?: string;
-    readonly stroke?: StrokeStyle;
-    readonly transform: readonly [number, number, number, number, number, number];
-}
-export declare class PathBuilder {
-    private readonly segments;
-    moveTo(x: number, y: number): this;
-    lineTo(x: number, y: number): this;
-    cubicTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
-    append(segments: ReadonlyArray<PathSegment>): this;
-    close(): this;
-    build(fillRule?: 'nonzero' | 'evenodd'): VectorPath;
-}
+import { VectorShape } from '../core/vector.js';
+export type { PathSegment, StrokeStyle, VectorPath, VectorShape } from '../core/vector.js';
+export { PathBuilder } from '../core/vector.js';
 export declare function emitVectorShape(shape: VectorShape): Array<string>;

package/dist/esm/pdf/vector-graphics.js

@@ -1,49 +1,5 @@
+import "../core/vector.js";
 //#region src/pdf/vector-graphics.ts
-var PathBuilder = class {
-	segments = [];
-	moveTo(x, y) {
-		this.segments.push({
-			op: "move",
-			x,
-			y
-		});
-		return this;
-	}
-	lineTo(x, y) {
-		this.segments.push({
-			op: "line",
-			x,
-			y
-		});
-		return this;
-	}
-	cubicTo(x1, y1, x2, y2, x, y) {
-		this.segments.push({
-			op: "cubic",
-			x1,
-			y1,
-			x2,
-			y2,
-			x,
-			y
-		});
-		return this;
-	}
-	append(segments) {
-		for (const s of segments) this.segments.push(s);
-		return this;
-	}
-	close() {
-		this.segments.push({ op: "close" });
-		return this;
-	}
-	build(fillRule) {
-		return {
-			segments: this.segments.slice(),
-			...fillRule ? { fillRule } : {}
-		};
-	}
-};
 function emitVectorShape(shape) {
 	const out = [];
 	out.push("q");
@@ -100,4 +56,4 @@ function hexToRgb01(hex) {
 	];
 }
 //#endregion
-export { PathBuilder, emitVectorShape };
+export { emitVectorShape };

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

@@ -0,0 +1,8 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { LaidOutDocument } from '../layout/page-doc.js';
+export interface SvgWriteOptions {
+    /** Gap between stacked pages, in px/pt (default 12). */
+    readonly pageGap?: number;
+}
+export declare function writeSvg(laid: LaidOutDocument, opts?: SvgWriteOptions): WriteResult;
+export declare const svgWriter: DocumentWriter<LaidOutDocument>;

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

@@ -0,0 +1,137 @@
+import { FEATURES } from "../core/ir/features.js";
+import { paintPlan } from "../layout/page-doc.js";
+//#region src/svg/svg-writer.ts
+var PAGE_GAP = 12;
+function writeSvg(laid, opts = {}) {
+	const gap = opts.pageGap ?? PAGE_GAP;
+	const losses = [];
+	const width = Math.max(1, ...laid.pages.map((p) => p.width));
+	const height = laid.pages.reduce((s, p) => s + p.height, 0) + gap * Math.max(0, laid.pages.length - 1);
+	const parts = [];
+	parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${fmt(width)}" height="${fmt(height)}" viewBox="0 0 ${fmt(width)} ${fmt(height)}">`);
+	let yOffset = 0;
+	laid.pages.forEach((page, i) => {
+		parts.push(`<g transform="translate(0 ${fmt(yOffset)})" data-page="${i + 1}">`);
+		parts.push(`<rect x="0" y="0" width="${fmt(page.width)}" height="${fmt(page.height)}" fill="#ffffff" stroke="#cccccc"/>`);
+		emitPage(parts, page, laid, losses);
+		parts.push("</g>");
+		yOffset += page.height + gap;
+	});
+	parts.push("</svg>");
+	return {
+		bytes: new TextEncoder().encode(parts.join("\n")),
+		losses
+	};
+}
+var svgWriter = {
+	id: "svg",
+	consumes: "page",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.images,
+		FEATURES.shapes
+	]),
+	write: (doc, opts) => writeSvg(doc, opts ?? {})
+};
+function emitPage(out, page, laid, losses) {
+	const plan = paintPlan(page.commands);
+	for (const f of plan.fills) out.push(`<rect x="${fmt(f.x)}" y="${fmt(f.y)}" width="${fmt(f.width)}" height="${fmt(f.height)}" fill="#${f.fillColorHex}"/>`);
+	for (const img of plan.images) {
+		const href = imageHref(img.imageResourceName, laid);
+		if (!href) continue;
+		out.push(`<image x="${fmt(img.x)}" y="${fmt(img.y)}" width="${fmt(img.width)}" height="${fmt(img.height)}" href="${href}" preserveAspectRatio="none"/>`);
+	}
+	for (const b of plan.borders) {
+		const x2 = b.x + b.width;
+		const yTop = b.y;
+		const yBottom = b.y + b.height;
+		const [ax, ay, bx, by] = b.side === "top" ? [
+			b.x,
+			yTop,
+			x2,
+			yTop
+		] : b.side === "bottom" ? [
+			b.x,
+			yBottom,
+			x2,
+			yBottom
+		] : b.side === "left" ? [
+			b.x,
+			yTop,
+			b.x,
+			yBottom
+		] : [
+			x2,
+			yTop,
+			x2,
+			yBottom
+		];
+		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"/>`);
+	}
+	for (const sh of plan.shapes) emitShape(out, sh.shape);
+	for (const t of plan.lines) emitTextLine(out, t, losses);
+}
+function emitTextLine(out, item, losses) {
+	const y = item.baselineY;
+	let x = item.originX;
+	for (const tok of item.line.tokens) {
+		if (tok.kind === "image") {
+			x += tok.widthPt;
+			continue;
+		}
+		if (tok.kind === "math") {
+			losses.push({
+				severity: "dropped",
+				feature: FEATURES.math,
+				detail: "inline math box not rendered by the SVG writer (v0)"
+			});
+			x += tok.widthPt;
+			continue;
+		}
+		if (tok.text.trim().length > 0) out.push(`<text x="${fmt(x)}" y="${fmt(y)}" font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
+		x += tok.widthPt;
+	}
+}
+function emitShape(out, shape) {
+	const [a, b, c, d, e, f] = shape.transform;
+	const transform = `matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e)} ${fmt(f)})`;
+	const fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
+	const stroke = shape.stroke ? ` stroke="#${shape.stroke.colorHex}" stroke-width="${fmt(shape.stroke.widthPt)}"` : "";
+	for (const path of shape.paths) {
+		const d2 = pathData(path.segments);
+		const rule = path.fillRule === "evenodd" ? " fill-rule=\"evenodd\"" : "";
+		out.push(`<path d="${d2}" fill="${fill}"${rule}${stroke} transform="${transform}"/>`);
+	}
+}
+function pathData(segments) {
+	const parts = [];
+	for (const s of segments) if (s.op === "move") parts.push(`M ${fmt(s.x)} ${fmt(s.y)}`);
+	else if (s.op === "line") parts.push(`L ${fmt(s.x)} ${fmt(s.y)}`);
+	else if (s.op === "cubic") parts.push(`C ${fmt(s.x1)} ${fmt(s.y1)} ${fmt(s.x2)} ${fmt(s.y2)} ${fmt(s.x)} ${fmt(s.y)}`);
+	else parts.push("Z");
+	return parts.join(" ");
+}
+function imageHref(resourceName, laid) {
+	if (!resourceName) return void 0;
+	for (const [resourceId, res] of laid.imageResources) {
+		if (res.resourceName !== resourceName) continue;
+		const bytes = laid.resources.get(resourceId);
+		if (!bytes) return void 0;
+		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;");
+}
+function fmt(n) {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+//#endregion
+export { svgWriter, writeSvg };

package/dist/esm/word/document-parser.d.ts

@@ -0,0 +1,16 @@
+import { BodyElement, Section, SectionProperties } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { ResourceId } from '../core/ir/index.js';
+import { PoNode } from '../core/po-helpers.js';
+export type ImageResolver = (relId: string) => ResourceId | undefined;
+export interface ParseContext {
+    readonly resolveColor: ColorResolver;
+    readonly resolveImage?: ImageResolver;
+}
+export declare const DEFAULT_PARSE_CONTEXT: ParseContext;
+export declare function parseDocument(documentXml: Uint8Array, ctx?: ParseContext): Array<BodyElement>;
+export declare const EMPTY_SECTION: SectionProperties;
+export declare function parseSection(documentXml: Uint8Array): SectionProperties;
+export declare function parseSections(documentXml: Uint8Array): Array<Section>;
+export declare function parseHeaderFooter(xml: Uint8Array, ctx?: ParseContext): Array<BodyElement>;
+export declare function parseBodyElements(children: ReadonlyArray<PoNode>, ctx?: ParseContext): Array<BodyElement>;

package/dist/esm/{ooxml/wordproc → word}/document-parser.js

@@ -1,13 +1,14 @@
-import { poAttr, poChildren, poFindByPath, poIntAttr, poIs, poText } from "./po-helpers.js";
-import { defaultColorResolver } from "../drawingml/colors.js";
-import { parseOMath } from "../math/omml-parser.js";
+import { twipsToPt } from "../core/ir/units.js";
+import { poAttr, poChildren, poFindByPath, poIntAttr, poIs, poText } from "../core/po-helpers.js";
+import { defaultColorResolver } from "../core/drawingml/colors.js";
+import { parseOMath } from "./omml-parser.js";
 import { expandMcChildren, parseDrawing } from "./drawing-parser.js";
 import { parseRunProperties } from "./run-properties.js";
 import { parseParagraphProperties } from "./paragraph-properties.js";
 import { poElementToFlat } from "./po-to-flat.js";
 import { parseTable } from "./table-parser.js";
 import { XMLParser } from "fast-xml-parser";
-//#region src/ooxml/wordproc/document-parser.ts
+//#region src/word/document-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,
@@ -26,11 +27,12 @@ var RUN_CONTAINER_TAGS = new Set([
 	"w:ins",
 	"w:moveTo"
 ]);
-function parseDocument(documentXml, resolveColor = defaultColorResolver) {
+var DEFAULT_PARSE_CONTEXT = { resolveColor: defaultColorResolver };
+function parseDocument(documentXml, ctx = DEFAULT_PARSE_CONTEXT) {
 	const xml = decoder.decode(documentXml);
 	const body = poFindByPath(parser.parse(xml), ["w:document", "w:body"]);
 	if (!body) return [];
-	return parseBodyElements(poChildren(body), resolveColor);
+	return parseBodyElements(poChildren(body), ctx);
 }
 var HF_TYPES = new Set([
 	"default",
@@ -83,8 +85,8 @@ function parseSectPrNode(sectPr) {
 		const h = poIntAttr(child, "h");
 		const orientRaw = poAttr(child, "orient");
 		if (w !== void 0 && h !== void 0) pageSize = {
-			widthTwips: w,
-			heightTwips: h,
+			width: twipsToPt(w),
+			height: twipsToPt(h),
 			...orientRaw === "portrait" || orientRaw === "landscape" ? { orientation: orientRaw } : {}
 		};
 	} else if (poIs(child, "w:pgMar")) {
@@ -95,12 +97,12 @@ function parseSectPrNode(sectPr) {
 		const header = poIntAttr(child, "header");
 		const footer = poIntAttr(child, "footer");
 		margins = {
-			topTwips: top ?? 1440,
-			rightTwips: right ?? 1440,
-			bottomTwips: bottom ?? 1440,
-			leftTwips: left ?? 1440,
-			...header !== void 0 ? { headerTwips: header } : {},
-			...footer !== void 0 ? { footerTwips: footer } : {}
+			top: twipsToPt(top ?? 1440),
+			right: twipsToPt(right ?? 1440),
+			bottom: twipsToPt(bottom ?? 1440),
+			left: twipsToPt(left ?? 1440),
+			...header !== void 0 ? { header: twipsToPt(header) } : {},
+			...footer !== void 0 ? { footer: twipsToPt(footer) } : {}
 		};
 	} else if (poIs(child, "w:headerReference")) pushHeaderFooter(child, headers);
 	else if (poIs(child, "w:footerReference")) pushHeaderFooter(child, footers);
@@ -126,26 +128,26 @@ function pushHeaderFooter(node, list) {
 		relationshipId: rId
 	});
 }
-function parseHeaderFooter(xml, resolveColor = defaultColorResolver) {
+function parseHeaderFooter(xml, ctx = DEFAULT_PARSE_CONTEXT) {
 	const root = parser.parse(decoder.decode(xml)).find((n) => poIs(n, "w:hdr") || poIs(n, "w:ftr"));
 	if (!root) return [];
-	return parseBodyElements(poChildren(root), resolveColor);
+	return parseBodyElements(poChildren(root), ctx);
 }
-function parseBodyElements(children, resolveColor = defaultColorResolver) {
+function parseBodyElements(children, ctx = DEFAULT_PARSE_CONTEXT) {
 	const out = [];
 	for (const child of children) if (poIs(child, "w:p")) {
-		const drawing = tryExtractDrawingFromParagraph(child, resolveColor);
+		const drawing = tryExtractDrawingFromParagraph(child, ctx);
 		out.push(drawing ?? {
 			kind: "paragraph",
-			paragraph: parseParagraph(child)
+			paragraph: parseParagraph(child, ctx)
 		});
 	} else if (poIs(child, "w:tbl")) out.push({
 		kind: "table",
-		table: parseTable(child)
+		table: parseTable(child, ctx)
 	});
 	return out;
 }
-function tryExtractDrawingFromParagraph(p, resolveColor) {
+function tryExtractDrawingFromParagraph(p, ctx) {
 	let drawing;
 	let hasText = false;
 	for (const child of poChildren(p)) {
@@ -156,27 +158,30 @@ function tryExtractDrawingFromParagraph(p, resolveColor) {
 		else if (poIs(runChild, "w:tab") || poIs(runChild, "w:br") || poIs(runChild, "w:noBreakHyphen")) hasText = true;
 	}
 	if (!drawing || hasText) return null;
-	const parseBody = (children) => parseBodyElements(children, resolveColor);
-	const content = parseDrawing(drawing, resolveColor, parseBody);
+	const parseBody = (children) => parseBodyElements(children, ctx);
+	const content = parseDrawing(drawing, ctx.resolveColor, parseBody);
 	if (!content) return null;
 	const pPrNode = poChildren(p).find((c) => poIs(c, "w:pPr"));
 	const paragraphProperties = pPrNode ? parseParagraphProperties(poElementToFlat(pPrNode)) : {};
-	if (content.kind === "image") return {
-		kind: "image",
-		image: {
-			imageId: content.imageId,
-			widthEmu: content.widthEmu,
-			heightEmu: content.heightEmu,
-			paragraphProperties,
-			...content.altText ? { altText: content.altText } : {}
-		}
-	};
+	if (content.kind === "image") {
+		const resource = ctx.resolveImage?.(content.imageId);
+		return {
+			kind: "image",
+			image: {
+				...resource ? { resource } : {},
+				width: content.width,
+				height: content.height,
+				paragraphProperties,
+				...content.altText ? { altText: content.altText } : {}
+			}
+		};
+	}
 	if (content.kind === "chart") return {
 		kind: "chart",
 		chart: {
 			chartRelId: content.chartRelId,
-			widthEmu: content.widthEmu,
-			heightEmu: content.heightEmu,
+			width: content.width,
+			height: content.height,
 			paragraphProperties,
 			...content.altText ? { altText: content.altText } : {}
 		}
@@ -190,7 +195,7 @@ function tryExtractDrawingFromParagraph(p, resolveColor) {
 		}
 	};
 }
-function parseParagraph(p) {
+function parseParagraph(p, ctx) {
 	const pPr = poChildren(p).find((c) => poIs(c, "w:pPr"));
 	let properties = parseParagraphProperties(pPr ? poElementToFlat(pPr) : void 0);
 	const mathPara = poChildren(p).find((c) => poIs(c, "m:oMathPara"));
@@ -204,17 +209,17 @@ function parseParagraph(p) {
 		};
 	}
 	const runs = [];
-	collectRuns(p, runs);
+	collectRuns(p, runs, ctx);
 	return {
 		properties,
 		runs
 	};
 }
-function collectRuns(container, out) {
+function collectRuns(container, out, ctx) {
 	for (const child of poChildren(container)) {
 		if (poIs(child, "w:pPr")) continue;
 		if (poIs(child, "w:r")) {
-			out.push(parseRun(child));
+			out.push(parseRun(child, ctx));
 			continue;
 		}
 		if (poIs(child, "m:oMath")) {
@@ -234,10 +239,10 @@ function collectRuns(container, out) {
 			continue;
 		}
 		const tag = elementTag(child);
-		if (tag && RUN_CONTAINER_TAGS.has(tag)) collectRuns(child, out);
+		if (tag && RUN_CONTAINER_TAGS.has(tag)) collectRuns(child, out, ctx);
 	}
 }
-function parseRun(r) {
+function parseRun(r, ctx) {
 	const rPr = poChildren(r).find((c) => poIs(c, "w:rPr"));
 	const properties = parseRunProperties(rPr ? poElementToFlat(rPr) : void 0);
 	let text = "";
@@ -253,11 +258,14 @@ function parseRun(r) {
 		else if (poIs(child, "w:softHyphen")) text += "­";
 		else if (poIs(child, "w:drawing")) {
 			const content = parseDrawing(child, defaultColorResolver);
-			if (content && content.kind === "image") inlineImage = {
-				imageId: content.imageId,
-				widthEmu: content.widthEmu,
-				heightEmu: content.heightEmu
-			};
+			if (content && content.kind === "image") {
+				const resource = ctx.resolveImage?.(content.imageId);
+				inlineImage = {
+					...resource ? { resource } : {},
+					width: content.width,
+					height: content.height
+				};
+			}
 		}
 	}
 	return {
@@ -271,4 +279,4 @@ function elementTag(node) {
 	for (const key of Object.keys(node)) if (key !== ":@" && key !== "#text") return key;
 }
 //#endregion
-export { EMPTY_SECTION, parseBodyElements, parseDocument, parseHeaderFooter, parseSections };
+export { DEFAULT_PARSE_CONTEXT, EMPTY_SECTION, parseBodyElements, parseDocument, parseHeaderFooter, parseSections };

package/dist/esm/word/docx-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 readDocx(docx: Uint8Array): ReadResult<FlowDoc>;
+export declare const docxReader: DocumentReader<FlowDoc>;