reamkit 1.14.0 → 1.15.1

package/dist/esm/pdf-reader/flow-build.js

@@ -124,14 +124,37 @@ function shapeBlock(v) {
 		}
 	};
 }
-function buildFlowDoc(body, resources = new ResourceStore()) {
+function sectionFromPdfPages(pages) {
+	const box = pages[0]?.mediaBox;
+	if (!box) return void 0;
+	const width = Math.abs(box[2] - box[0]);
+	const height = Math.abs(box[3] - box[1]);
+	if (!(width > 0 && height > 0)) return void 0;
+	return {
+		pageSize: {
+			width: pt(width),
+			height: pt(height),
+			orientation: width > height ? "landscape" : "portrait"
+		},
+		margins: {
+			top: pt(0),
+			right: pt(0),
+			bottom: pt(0),
+			left: pt(0)
+		},
+		headers: [],
+		footers: []
+	};
+}
+function buildFlowDoc(body, resources = new ResourceStore(), section) {
 	return {
 		kind: "flow",
 		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
 		sections: [],
+		...section ? { section } : {},
 		styles: EMPTY_STYLE_SHEET,
 		resources
 	};
 }
 //#endregion
-export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, shapeBlock };
+export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock };

package/dist/esm/pdf-reader/layout.js

@@ -1,5 +1,5 @@
 import { ResourceStore } from "../core/ir/resources.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, shapeBlock } from "./flow-build.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock } from "./flow-build.js";
 import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
 import { collectPageVectors } from "./vector.js";
@@ -45,7 +45,7 @@ function reconstructByLayout(file) {
 		for (const block of blocks) body.push(block.el);
 	});
 	return {
-		doc: buildFlowDoc(body, resources),
+		doc: buildFlowDoc(body, resources, sectionFromPdfPages(pages)),
 		losses: dedupeLosses(losses)
 	};
 }

package/dist/esm/pdf-reader/tagged.js

@@ -1,6 +1,6 @@
 import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns } from "./flow-build.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages } from "./flow-build.js";
 import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
 import { readStructTree } from "./struct-tree.js";
@@ -126,7 +126,7 @@ function reconstructTaggedPdf(file) {
 	for (const { img } of orphans) body.push(imageBlock(img, resources));
 	if (body.length === 0) return void 0;
 	return {
-		doc: buildFlowDoc(body, resources),
+		doc: buildFlowDoc(body, resources, sectionFromPdfPages(pages)),
 		losses: imageLosses
 	};
 }

package/dist/esm/pptx/ppt/ppt-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 readPpt(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const pptReader: DocumentReader<FlowDoc>;

package/dist/esm/pptx/ppt/ppt-reader.js

@@ -0,0 +1,337 @@
+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 { isCfb, openCfb } from "../../core/ole/cfb.js";
+import { extractPptContent, paragraphText } from "./ppt-text.js";
+//#region src/pptx/ppt/ppt-reader.ts
+var ZERO_WIDTH_SPACE = "​";
+var DEFAULT_SLIDE_W = 720;
+var DEFAULT_SLIDE_H = 540;
+var SLIDE_MARGIN = 36;
+var LEVEL_INDENT_PT = 18;
+function looksLikePpt(bytes) {
+	if (!isCfb(bytes)) return false;
+	try {
+		return openCfb(bytes).hasStream("PowerPoint Document");
+	} catch {
+		return false;
+	}
+}
+var PPT_TEXT_LOSS = {
+	severity: "degraded",
+	feature: FEATURES.text,
+	detail: "legacy .ppt: each slide's text (with run formatting — bold/italic/underline/size/colour — and paragraph alignment/indent), embedded images, per-shape placement and decorative autoshapes (preset or exact freeform geometry with literal, scheme- or system-resolved fill/line colours) are read into one page per slide (re-save as .pptx for full fidelity)"
+};
+var PPT_ENCRYPTED_LOSS = {
+	severity: "dropped",
+	feature: FEATURES.text,
+	detail: "legacy .ppt is encrypted/obfuscated — its text cannot be read"
+};
+function readPpt(bytes) {
+	const content = extractPptContent(bytes);
+	const width = pt(content.slideWidthPt ?? DEFAULT_SLIDE_W);
+	const height = pt(content.slideHeightPt ?? DEFAULT_SLIDE_H);
+	const resources = new ResourceStore();
+	return {
+		doc: {
+			kind: "flow",
+			body: resolveBodyStyles(buildBody(content, resources), EMPTY_STYLE_SHEET),
+			sections: [],
+			section: {
+				pageSize: {
+					width,
+					height
+				},
+				margins: {
+					top: pt(SLIDE_MARGIN),
+					right: pt(SLIDE_MARGIN),
+					bottom: pt(SLIDE_MARGIN),
+					left: pt(SLIDE_MARGIN)
+				},
+				headers: [],
+				footers: []
+			},
+			styles: EMPTY_STYLE_SHEET,
+			resources
+		},
+		losses: [content.encrypted ? PPT_ENCRYPTED_LOSS : PPT_TEXT_LOSS]
+	};
+}
+function buildBody(content, resources) {
+	const body = [];
+	content.slides.forEach((slide, slideIndex) => {
+		const inFlowParas = [];
+		const inFlowImages = [];
+		const floats = [];
+		for (const shape of slide.shapes) if (shape.rectPt) {
+			if (shape.paragraphs?.some((p) => paragraphText(p).length > 0)) floats.push(positionedTextShape(shape.rectPt, shape.paragraphs));
+			if (shape.image) {
+				const block = positionedImage(shape.rectPt, shape.image, resources);
+				if (block) floats.push(block);
+			}
+			if (shape.autoShape) floats.push(positionedAutoShape(shape.rectPt, shape.autoShape));
+		} else {
+			for (const para of shape.paragraphs ?? []) if (paragraphText(para).length > 0) inFlowParas.push(flowParagraph(para));
+			if (shape.image) {
+				const block = inFlowImage(shape.image, resources);
+				if (block) inFlowImages.push(block);
+			}
+		}
+		pushSlide(body, [...inFlowParas, ...inFlowImages], floats, slideIndex > 0);
+	});
+	if (body.length === 0) body.push(anchorParagraph(false));
+	return body;
+}
+function pushSlide(body, inFlow, floats, breakBefore) {
+	if (inFlow.length === 0 && floats.length === 0) {
+		body.push(anchorParagraph(breakBefore));
+		return;
+	}
+	if (inFlow.length > 0) {
+		const first = inFlow[0];
+		if (breakBefore && first.kind === "paragraph") inFlow[0] = {
+			kind: "paragraph",
+			paragraph: {
+				...first.paragraph,
+				properties: {
+					...first.paragraph.properties,
+					pageBreakBefore: true
+				}
+			}
+		};
+		else if (breakBefore) body.push(anchorParagraph(true));
+		body.push(...inFlow);
+	} else body.push(anchorParagraph(breakBefore));
+	body.push(...floats);
+}
+function flowParagraph(para) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: toParaProperties(para, false),
+			runs: para.runs.map(toRun)
+		}
+	};
+}
+function floatAt(rect) {
+	return {
+		wrap: "none",
+		posH: {
+			relativeFrom: "page",
+			offsetPt: pt(rect.x)
+		},
+		posV: {
+			relativeFrom: "page",
+			offsetPt: pt(rect.y)
+		}
+	};
+}
+function positionedTextShape(rect, paragraphs) {
+	return {
+		kind: "shape",
+		shape: {
+			float: floatAt(rect),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill: { kind: "none" },
+			text: {
+				content: paragraphs.filter((p) => paragraphText(p).length > 0).map(flowParagraph),
+				anchor: "t"
+			},
+			paragraphProperties: {}
+		}
+	};
+}
+function positionedImage(rect, image, resources) {
+	if (!imagePixelSize(image.bytes)) return void 0;
+	return {
+		kind: "image",
+		image: {
+			float: floatAt(rect),
+			resource: resources.put(image.bytes),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			paragraphProperties: {}
+		}
+	};
+}
+var SHAPE_PRESETS = new Map([
+	[1, "rect"],
+	[2, "roundRect"],
+	[3, "ellipse"],
+	[4, "diamond"],
+	[5, "triangle"],
+	[6, "rtTriangle"],
+	[7, "parallelogram"],
+	[8, "trapezoid"],
+	[9, "hexagon"],
+	[10, "octagon"],
+	[13, "line"],
+	[20, "line"]
+]);
+function isLineShape(shapeType) {
+	return shapeType === 13 || shapeType >= 20 && shapeType <= 49;
+}
+function toCustomGeometry(g) {
+	const commands = g.commands.map((c) => c.kind === "move" ? {
+		cmd: "move",
+		x: c.x,
+		y: c.y
+	} : c.kind === "line" ? {
+		cmd: "line",
+		x: c.x,
+		y: c.y
+	} : c.kind === "cubic" ? {
+		cmd: "cubic",
+		x1: c.x1,
+		y1: c.y1,
+		x2: c.x2,
+		y2: c.y2,
+		x: c.x,
+		y: c.y
+	} : { cmd: "close" });
+	return {
+		pathWidth: g.pathWidth,
+		pathHeight: g.pathHeight,
+		commands
+	};
+}
+function positionedAutoShape(rect, auto) {
+	const line = isLineShape(auto.shapeType);
+	const fill = auto.fillColorHex && !line ? {
+		kind: "solid",
+		colorHex: auto.fillColorHex
+	} : { kind: "none" };
+	const stroke = auto.lineColorHex ? {
+		colorHex: auto.lineColorHex,
+		fill: "solid"
+	} : line ? { fill: "solid" } : void 0;
+	return {
+		kind: "shape",
+		shape: {
+			float: floatAt(rect),
+			width: pt(rect.w),
+			height: pt(rect.h),
+			geometry: auto.geometry ? {
+				kind: "custom",
+				custom: toCustomGeometry(auto.geometry)
+			} : {
+				kind: "preset",
+				preset: SHAPE_PRESETS.get(auto.shapeType) ?? "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill,
+			...stroke ? { line: stroke } : {},
+			paragraphProperties: {}
+		}
+	};
+}
+function inFlowImage(image, resources) {
+	const size = imagePixelSize(image.bytes);
+	if (!size) return void 0;
+	return {
+		kind: "image",
+		image: {
+			resource: resources.put(image.bytes),
+			width: pt(size.w * .75),
+			height: pt(size.h * .75),
+			paragraphProperties: {}
+		}
+	};
+}
+function imagePixelSize(d) {
+	if (d.length >= 24 && d[0] === 137 && d[1] === 80 && d[2] === 78 && d[3] === 71) {
+		const w = u32be(d, 16);
+		const h = u32be(d, 20);
+		return w > 0 && h > 0 ? {
+			w,
+			h
+		} : void 0;
+	}
+	if (d.length >= 4 && d[0] === 255 && d[1] === 216) {
+		let off = 2;
+		while (off + 9 < d.length) {
+			if (d[off] !== 255) {
+				off++;
+				continue;
+			}
+			const marker = d[off + 1];
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+				const h = d[off + 5] << 8 | d[off + 6];
+				const w = d[off + 7] << 8 | d[off + 8];
+				return w > 0 && h > 0 ? {
+					w,
+					h
+				} : void 0;
+			}
+			const len = d[off + 2] << 8 | d[off + 3];
+			if (len < 2) break;
+			off += 2 + len;
+		}
+	}
+}
+function u32be(d, o) {
+	return (d[o] << 24 | d[o + 1] << 16 | d[o + 2] << 8 | d[o + 3]) >>> 0;
+}
+function toRun(r) {
+	const underline = r.underline ? "single" : void 0;
+	const properties = {
+		...r.bold ? { bold: true } : {},
+		...r.italic ? { italic: true } : {},
+		...underline ? { underline } : {},
+		...r.sizePt ? { fontSizePt: pt(r.sizePt) } : {},
+		...r.colorHex ? { colorHex: r.colorHex } : {}
+	};
+	return {
+		text: r.text,
+		properties
+	};
+}
+function toParaProperties(p, breakBefore) {
+	const alignment = p.align !== void 0 ? alignmentFrom(p.align) : void 0;
+	const level = p.level ?? 0;
+	return {
+		...breakBefore ? { pageBreakBefore: true } : {},
+		...alignment ? { alignment } : {},
+		...level > 0 ? { indentLeft: pt(level * LEVEL_INDENT_PT) } : {}
+	};
+}
+function alignmentFrom(a) {
+	switch (a) {
+		case 1: return "center";
+		case 2: return "right";
+		case 3:
+		case 6: return "both";
+		case 4:
+		case 5: return "distribute";
+		default: return;
+	}
+}
+function anchorParagraph(breakBefore) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: breakBefore ? { pageBreakBefore: true } : {},
+			runs: [{
+				text: ZERO_WIDTH_SPACE,
+				properties: {}
+			}]
+		}
+	};
+}
+var pptReader = {
+	id: "ppt",
+	produces: "flow",
+	supports: new Set([FEATURES.text]),
+	sniff: looksLikePpt,
+	read: (bytes) => readPpt(bytes)
+};
+//#endregion
+export { pptReader };

package/dist/esm/pptx/ppt/ppt-text.d.ts

@@ -0,0 +1,69 @@
+export interface PptRun {
+    readonly text: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: boolean;
+    readonly sizePt?: number;
+    readonly colorHex?: string;
+}
+export interface PptParagraph {
+    readonly runs: ReadonlyArray<PptRun>;
+    readonly align?: number;
+    readonly level?: number;
+}
+export interface PptImage {
+    readonly bytes: Uint8Array;
+}
+export interface PptRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+export type PptPathCmd = {
+    readonly kind: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: 'close';
+};
+export interface PptCustomGeometry {
+    readonly pathWidth: number;
+    readonly pathHeight: number;
+    readonly commands: ReadonlyArray<PptPathCmd>;
+}
+export interface PptAutoShape {
+    readonly shapeType: number;
+    readonly fillColorHex?: string;
+    readonly lineColorHex?: string;
+    readonly geometry?: PptCustomGeometry;
+}
+export interface PptShape {
+    readonly rectPt?: PptRect;
+    readonly paragraphs?: ReadonlyArray<PptParagraph>;
+    readonly image?: PptImage;
+    readonly autoShape?: PptAutoShape;
+}
+export interface PptSlide {
+    readonly shapes: ReadonlyArray<PptShape>;
+}
+export interface PptContent {
+    readonly slides: ReadonlyArray<PptSlide>;
+    readonly slideWidthPt?: number;
+    readonly slideHeightPt?: number;
+    readonly encrypted: boolean;
+}
+export declare function extractPptContent(bytes: Uint8Array): PptContent;
+export declare function paragraphText(p: PptParagraph): string;