reamkit 1.0.0 → 1.0.1

package/dist/esm/pdf/cid-font.d.ts

@@ -12,10 +12,4 @@ export interface EmbeddedFont {
     readonly textWidthPt: (text: string, fontSize: number) => number;
     readonly encodeTextAsCidHex: (text: string) => string;
 }
-export interface FontMeasure {
-    readonly pdfWidthForGid: (gid: number) => number;
-    readonly textWidthPt: (text: string, fontSize: number) => number;
-    readonly encodeTextAsCidHex: (text: string) => string;
-}
-export declare function createFontMeasure(parsed: ParsedTtf): FontMeasure;
 export declare function embedTtfFont(doc: PdfDocument, parsed: ParsedTtf, options?: EmbedTtfOptions): EmbeddedFont;

package/dist/esm/pdf/cid-font.js

@@ -1,34 +1,8 @@
-import { shapeText } from "../core/font/opentype-layout.js";
 import { glyphClosure, subsetTtf } from "../core/font/ttf-subset.js";
+import { createFontMeasure } from "../core/font/measure.js";
 import { dict, name, ref, stream } from "./objects.js";
 //#region src/pdf/cid-font.ts
 var encoder = new TextEncoder();
-function createFontMeasure(parsed) {
-	const scale = 1e3 / parsed.unitsPerEm;
-	const widths = new Array(parsed.numGlyphs);
-	for (let i = 0; i < parsed.numGlyphs; i++) widths[i] = Math.round((parsed.advanceWidths[i] ?? 0) * scale);
-	const pdfWidthForGid = (gid) => {
-		if (gid < 0 || gid >= parsed.numGlyphs) return 1e3;
-		return widths[gid];
-	};
-	const textWidthPt = (text, fontSize) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
-		let totalEm = 0;
-		for (const a of shaped.advances) totalEm += a;
-		return totalEm * fontSize / parsed.unitsPerEm;
-	};
-	const encodeTextAsCidHex = (text) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
-		let out = "";
-		for (const gid of shaped.gids) out += gid.toString(16).padStart(4, "0").toUpperCase();
-		return out;
-	};
-	return {
-		pdfWidthForGid,
-		textWidthPt,
-		encodeTextAsCidHex
-	};
-}
 function embedTtfFont(doc, parsed, options = {}) {
 	const scale = 1e3 / parsed.unitsPerEm;
 	const toPdfUnits = (v) => Math.round(v * scale);
@@ -182,4 +156,4 @@ function buildToUnicodeCMap(parsed) {
 	return encoder.encode(lines.join("\n"));
 }
 //#endregion
-export { createFontMeasure, embedTtfFont };
+export { embedTtfFont };

package/dist/esm/pdf/image-xobject.d.ts

@@ -1,26 +1,12 @@
 import { PdfRef } from './objects.js';
 import { PdfDocument } from './writer.js';
-export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000';
+import { EmbedImageOptions, PreparedImage } from '../core/images.js';
+export { detectImageFormat, prepareImage } from '../core/images.js';
+export type { EmbedImageOptions, ImageFormat, PreparedImage } from '../core/images.js';
 export interface EmbeddedImage {
     readonly ref: PdfRef;
     readonly widthPx: number;
     readonly heightPx: number;
 }
-export declare function detectImageFormat(bytes: Uint8Array): ImageFormat | null;
-export interface EmbedImageOptions {
-    readonly flattenAlpha?: boolean;
-}
-export interface PreparedImage {
-    readonly format: ImageFormat;
-    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png';
-    readonly widthPx: number;
-    readonly heightPx: number;
-    readonly colorSpace?: 'DeviceGray' | 'DeviceRGB';
-    readonly bitsPerComponent?: number;
-    readonly filter: 'DCTDecode' | 'FlateDecode' | 'JPXDecode';
-    readonly data: Uint8Array;
-    readonly smaskData?: Uint8Array;
-}
-export declare function prepareImage(bytes: Uint8Array, options?: EmbedImageOptions): PreparedImage;
 export declare function addImage(doc: PdfDocument, prepared: PreparedImage): EmbeddedImage;
 export declare function embedImage(doc: PdfDocument, bytes: Uint8Array, options?: EmbedImageOptions): EmbeddedImage;

package/dist/esm/pdf/image-xobject.js

@@ -1,20 +1,6 @@
 import { name, stream } from "./objects.js";
-import { unzlibSync, zlibSync } from "fflate";
+import "../core/images.js";
 //#region src/pdf/image-xobject.ts
-function detectImageFormat(bytes) {
-	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "jpeg";
-	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "png";
-	if (bytes.length >= 12 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 12 && bytes[4] === 106 && bytes[5] === 80 && bytes[6] === 32 && bytes[7] === 32 && bytes[8] === 13 && bytes[9] === 10 && bytes[10] === 135 && bytes[11] === 10) return "jpeg2000";
-	if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 79 && bytes[2] === 255 && bytes[3] === 81) return "jpeg2000";
-	return null;
-}
-function prepareImage(bytes, options = {}) {
-	const format = detectImageFormat(bytes);
-	if (format === "jpeg") return prepareJpeg(bytes);
-	if (format === "png") return preparePng(bytes, options);
-	if (format === "jpeg2000") return prepareJpeg2000(bytes);
-	throw new Error("Unsupported image format");
-}
 function addImage(doc, prepared) {
 	let smaskRef;
 	if (prepared.smaskData) smaskRef = doc.add(stream({
@@ -42,295 +28,5 @@ function addImage(doc, prepared) {
 		heightPx: prepared.heightPx
 	};
 }
-function prepareJpeg2000(bytes) {
-	const { width, height } = readJpeg2000Info(bytes);
-	return {
-		format: "jpeg2000",
-		mimeType: "image/jp2",
-		widthPx: width,
-		heightPx: height,
-		filter: "JPXDecode",
-		data: bytes
-	};
-}
-function readU32(b, o) {
-	return b[o] * 16777216 + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3];
-}
-var boxType = (b, o) => String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]);
-function readJpeg2000Info(bytes) {
-	if (bytes[0] === 255 && bytes[1] === 79) return readSiz(bytes, 2);
-	let p = 0;
-	while (p + 8 <= bytes.length) {
-		let len = readU32(bytes, p);
-		const type = boxType(bytes, p + 4);
-		let contentStart = p + 8;
-		if (len === 1) {
-			len = readU32(bytes, p + 12);
-			contentStart = p + 16;
-		}
-		const end = len === 0 ? bytes.length : p + len;
-		if (type === "jp2h") {
-			let q = contentStart;
-			while (q + 8 <= end) {
-				const clen = readU32(bytes, q);
-				if (boxType(bytes, q + 4) === "ihdr") return {
-					height: readU32(bytes, q + 8),
-					width: readU32(bytes, q + 12)
-				};
-				if (clen === 0) break;
-				q += clen;
-			}
-		}
-		if (len === 0) break;
-		p = end;
-	}
-	for (let i = 0; i + 22 < bytes.length; i++) if (bytes[i] === 255 && bytes[i + 1] === 81) return readSiz(bytes, i);
-	throw new Error("JPEG 2000: no ihdr/SIZ found");
-}
-function readSiz(bytes, sizOffset) {
-	const xsiz = readU32(bytes, sizOffset + 6);
-	const ysiz = readU32(bytes, sizOffset + 10);
-	const xo = readU32(bytes, sizOffset + 14);
-	const yo = readU32(bytes, sizOffset + 18);
-	const width = xsiz - xo;
-	const height = ysiz - yo;
-	if (width <= 0 || height <= 0) throw new Error("JPEG 2000: invalid SIZ dimensions");
-	return {
-		width,
-		height
-	};
-}
-function prepareJpeg(bytes) {
-	const info = readJpegInfo(bytes);
-	return {
-		format: "jpeg",
-		mimeType: "image/jpeg",
-		widthPx: info.width,
-		heightPx: info.height,
-		colorSpace: info.numComponents === 1 ? "DeviceGray" : "DeviceRGB",
-		bitsPerComponent: info.precision,
-		filter: "DCTDecode",
-		data: bytes
-	};
-}
-function readJpegInfo(bytes) {
-	if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) throw new Error("Not a JPEG (missing SOI)");
-	let i = 2;
-	while (i + 9 < bytes.length) {
-		if (bytes[i] !== 255) {
-			i++;
-			continue;
-		}
-		let marker = bytes[i + 1];
-		while (marker === 255) {
-			i++;
-			marker = bytes[i + 1];
-		}
-		if (marker === 1 || marker >= 208 && marker <= 217) {
-			i += 2;
-			continue;
-		}
-		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
-			precision: bytes[i + 4],
-			height: bytes[i + 5] << 8 | bytes[i + 6],
-			width: bytes[i + 7] << 8 | bytes[i + 8],
-			numComponents: bytes[i + 9]
-		};
-		const length = bytes[i + 2] << 8 | bytes[i + 3];
-		i += 2 + length;
-	}
-	throw new Error("JPEG SOFn marker not found");
-}
-function preparePng(bytes, options = {}) {
-	let decoded = decodePng(bytes);
-	if (options.flattenAlpha && decoded.smaskRaw) decoded = flattenAlphaOnWhite(decoded);
-	return {
-		format: "png",
-		mimeType: "image/png",
-		widthPx: decoded.width,
-		heightPx: decoded.height,
-		colorSpace: decoded.colorSpace,
-		bitsPerComponent: decoded.bitsPerComponent,
-		filter: "FlateDecode",
-		data: zlibSync(decoded.raw),
-		...decoded.smaskRaw ? { smaskData: zlibSync(decoded.smaskRaw) } : {}
-	};
-}
-function decodePng(bytes) {
-	let width = 0;
-	let height = 0;
-	let bitDepth = 0;
-	let colorType = 0;
-	let interlaceMethod = 0;
-	const idatChunks = [];
-	let pos = 8;
-	while (pos + 12 <= bytes.length) {
-		const len = readU32BE(bytes, pos);
-		const type = chunkType(bytes, pos + 4);
-		const dataOff = pos + 8;
-		if (type === "IHDR") {
-			width = readU32BE(bytes, dataOff);
-			height = readU32BE(bytes, dataOff + 4);
-			bitDepth = bytes[dataOff + 8];
-			colorType = bytes[dataOff + 9];
-			interlaceMethod = bytes[dataOff + 12];
-		} else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
-		else if (type === "IEND") break;
-		pos = dataOff + len + 4;
-	}
-	if (width === 0 || height === 0) throw new Error("PNG: missing IHDR");
-	if (idatChunks.length === 0) throw new Error("PNG: no IDAT");
-	if (interlaceMethod !== 0) throw new Error("PNG: interlaced not supported");
-	if (bitDepth !== 8) throw new Error(`PNG: bit depth ${bitDepth} not supported`);
-	const inflated = unzlibSync(concatBytes(idatChunks));
-	const channels = pngChannels(colorType);
-	if (channels === 0) throw new Error(`PNG color type ${colorType} not supported`);
-	const bpp = channels;
-	const scanlineBytes = width * bpp;
-	const expected = height * (1 + scanlineBytes);
-	if (inflated.length !== expected) throw new Error(`PNG: inflated size ${inflated.length} != expected ${expected} (interlaced or malformed)`);
-	const raw = new Uint8Array(height * scanlineBytes);
-	let prev = null;
-	for (let y = 0; y < height; y++) {
-		const inOff = y * (1 + scanlineBytes);
-		const filterType = inflated[inOff];
-		const decoded = new Uint8Array(scanlineBytes);
-		for (let x = 0; x < scanlineBytes; x++) {
-			const filt = inflated[inOff + 1 + x];
-			const a = x < bpp ? 0 : decoded[x - bpp];
-			const b = prev ? prev[x] : 0;
-			const c = !prev || x < bpp ? 0 : prev[x - bpp];
-			let v;
-			switch (filterType) {
-				case 0:
-					v = filt;
-					break;
-				case 1:
-					v = filt + a;
-					break;
-				case 2:
-					v = filt + b;
-					break;
-				case 3:
-					v = filt + Math.floor((a + b) / 2);
-					break;
-				case 4:
-					v = filt + paethPredictor(a, b, c);
-					break;
-				default: throw new Error(`PNG: unknown filter type ${filterType}`);
-			}
-			decoded[x] = v & 255;
-		}
-		raw.set(decoded, y * scanlineBytes);
-		prev = decoded;
-	}
-	return splitChannels(width, height, colorType, raw);
-}
-function flattenAlphaOnWhite(decoded) {
-	const alpha = decoded.smaskRaw;
-	if (!alpha) return decoded;
-	const channels = decoded.colorSpace === "DeviceRGB" ? 3 : 1;
-	const pixelCount = decoded.width * decoded.height;
-	const out = new Uint8Array(pixelCount * channels);
-	for (let i = 0; i < pixelCount; i++) {
-		const a = alpha[i] / 255;
-		for (let c = 0; c < channels; c++) {
-			const src = decoded.raw[i * channels + c];
-			out[i * channels + c] = Math.round(src * a + 255 * (1 - a));
-		}
-	}
-	return {
-		width: decoded.width,
-		height: decoded.height,
-		raw: out,
-		colorSpace: decoded.colorSpace,
-		bitsPerComponent: decoded.bitsPerComponent
-	};
-}
-function splitChannels(width, height, colorType, raw) {
-	const pixelCount = width * height;
-	if (colorType === 0) return {
-		width,
-		height,
-		raw,
-		colorSpace: "DeviceGray",
-		bitsPerComponent: 8
-	};
-	if (colorType === 2) return {
-		width,
-		height,
-		raw,
-		colorSpace: "DeviceRGB",
-		bitsPerComponent: 8
-	};
-	if (colorType === 4) {
-		const gray = new Uint8Array(pixelCount);
-		const alpha = new Uint8Array(pixelCount);
-		for (let i = 0; i < pixelCount; i++) {
-			gray[i] = raw[i * 2];
-			alpha[i] = raw[i * 2 + 1];
-		}
-		return {
-			width,
-			height,
-			raw: gray,
-			colorSpace: "DeviceGray",
-			bitsPerComponent: 8,
-			smaskRaw: alpha
-		};
-	}
-	if (colorType === 6) {
-		const rgb = new Uint8Array(pixelCount * 3);
-		const alpha = new Uint8Array(pixelCount);
-		for (let i = 0; i < pixelCount; i++) {
-			rgb[i * 3] = raw[i * 4];
-			rgb[i * 3 + 1] = raw[i * 4 + 1];
-			rgb[i * 3 + 2] = raw[i * 4 + 2];
-			alpha[i] = raw[i * 4 + 3];
-		}
-		return {
-			width,
-			height,
-			raw: rgb,
-			colorSpace: "DeviceRGB",
-			bitsPerComponent: 8,
-			smaskRaw: alpha
-		};
-	}
-	throw new Error(`PNG color type ${colorType} not supported (palette/indexed?)`);
-}
-function pngChannels(colorType) {
-	if (colorType === 0) return 1;
-	if (colorType === 2) return 3;
-	if (colorType === 4) return 2;
-	if (colorType === 6) return 4;
-	return 0;
-}
-function paethPredictor(a, b, c) {
-	const p = a + b - c;
-	const pa = Math.abs(p - a);
-	const pb = Math.abs(p - b);
-	const pc = Math.abs(p - c);
-	if (pa <= pb && pa <= pc) return a;
-	if (pb <= pc) return b;
-	return c;
-}
-function readU32BE(bytes, offset) {
-	return bytes[offset] * 16777216 + (bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]);
-}
-function chunkType(bytes, offset) {
-	return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
-}
-function concatBytes(parts) {
-	let total = 0;
-	for (const p of parts) total += p.length;
-	const out = new Uint8Array(total);
-	let off = 0;
-	for (const p of parts) {
-		out.set(p, off);
-		off += p.length;
-	}
-	return out;
-}
 //#endregion
-export { addImage, detectImageFormat, prepareImage };
+export { addImage };

package/dist/esm/pdf/index.js

@@ -1,5 +1,6 @@
 import "./cid-font.js";
 import "./text-page-renderer.js";
+import "../core/images.js";
 import "./image-xobject.js";
 import "./signature.js";
 import "./styled-page-renderer.js";

package/dist/esm/pdf/styled-page-emitter.d.ts

@@ -1,5 +1,11 @@
-import { LaidOutDocument, StyledRenderOptions } from './styled-page-renderer.js';
+import { LaidOutPdfDocument, StyledRenderOptions } from '../layout/styled-layout.js';
 import { PdfDocument } from './writer.js';
 type EmitOptions = Pick<StyledRenderOptions, 'attachments' | 'info' | 'language' | 'signaturePlaceholder'>;
-export declare function emitStyledPdf(laid: LaidOutDocument, options: EmitOptions, doc: PdfDocument): Uint8Array;
+export declare function emitStyledPdf(laid: LaidOutPdfDocument, options: EmitOptions, doc: PdfDocument): Uint8Array;
+export interface PageTagging {
+    next: number;
+    assigned: boolean;
+    record: (structId: number, mcid: number) => void;
+    tagFor: (structId: number) => string;
+}
 export {};

package/dist/esm/pdf/styled-page-emitter.js

@@ -2,19 +2,20 @@ import { dict, name, ref, stream, unicodeString } from "./objects.js";
 import { embedTtfFont } from "./cid-font.js";
 import { reorderVisual } from "../core/bidi/algorithm.js";
 import { reverseByCodePoint } from "../core/bidi/index.js";
+import "../layout/styled-layout.js";
+import { paintPlan } from "../layout/page-doc.js";
 import { emitVectorShape } from "./vector-graphics.js";
-import { addImage } from "./image-xobject.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
+import { addImage } from "./image-xobject.js";
 import { addSignaturePlaceholder } from "./signature.js";
 import { buildXmpPacket } from "./xmp.js";
-import { paintPlan } from "./styled-page-renderer.js";
 //#region src/pdf/styled-page-emitter.ts
 var encoder = new TextEncoder();
 function emitStyledPdf(laid, options, doc) {
-	const { pages: renderedPages, structBuilder } = laid;
-	const { sectionCtxs, pdfaProfile, tagged } = laid;
-	const embeddedFonts = embedFontResources(doc, laid);
+	const { pages: renderedPages } = laid;
+	const { structBuilder, sectionCtxs, pdfaProfile, tagged } = laid.pdf;
+	const embeddedFonts = embedFontResources(doc, laid, pdfaProfile);
 	const embeddedImages = embedImageResources(doc, laid);
 	const pagesDict = dict({
 		Type: name("Pages"),
@@ -53,7 +54,7 @@ function emitStyledPdf(laid, options, doc) {
 				tagFor: (structId) => builder.node(structId).type
 			};
 		}
-		const contentBytes = emitPageContent(page.commands, pageTagging);
+		const contentBytes = emitPageContent(page, pageTagging);
 		const contentsRef = doc.add(stream({}, contentBytes));
 		const pageEntries = {
 			Type: name("Page"),
@@ -212,8 +213,8 @@ function embedImageResources(doc, laid) {
 	for (const [resourceId, res] of laid.imageResources) out.set(resourceId, addImage(doc, res.prepared).ref);
 	return out;
 }
-function embedFontResources(doc, laid) {
-	const cidSet = laid.pdfaProfile?.part === 1;
+function embedFontResources(doc, laid, pdfaProfile) {
+	const cidSet = pdfaProfile?.part === 1;
 	const out = /* @__PURE__ */ new Map();
 	for (const [variant, res] of laid.fontResources) out.set(variant, embedTtfFont(doc, res.parsed, {
 		usedGids: res.gids,
@@ -267,8 +268,10 @@ function emitTaggedRuns(out, cmds, tagging, body) {
 	}
 	close();
 }
-function emitPageContent(commands, tagging) {
+function emitPageContent(page, tagging) {
+	const commands = page.commands;
 	if (commands.length === 0) return new Uint8Array(0);
+	const H = page.height;
 	const out = [];
 	const plan = paintPlan(commands);
 	const fills = plan.fills;
@@ -283,7 +286,7 @@ function emitPageContent(commands, tagging) {
 				out.push(`${formatNumber(r)} ${formatNumber(g)} ${formatNumber(b)} rg`);
 				lastColor = color;
 			}
-			out.push(`${formatNumber(f.x)} ${formatNumber(f.y)} ${formatNumber(f.width)} ${formatNumber(f.height)} re`);
+			out.push(`${formatNumber(f.x)} ${formatNumber(H - f.y - f.height)} ${formatNumber(f.width)} ${formatNumber(f.height)} re`);
 			out.push("f");
 		}
 		out.push("Q");
@@ -291,7 +294,7 @@ function emitPageContent(commands, tagging) {
 	}
 	emitTaggedRuns(out, plan.images.filter((c) => c.imageResourceName !== ""), tagging, (img) => {
 		out.push("q");
-		out.push(`${formatNumber(img.width)} 0 0 ${formatNumber(img.height)} ${formatNumber(img.x)} ${formatNumber(img.y)} cm`);
+		out.push(`${formatNumber(img.width)} 0 0 ${formatNumber(img.height)} ${formatNumber(img.x)} ${formatNumber(H - img.y - img.height)} cm`);
 		out.push(`/${img.imageResourceName} Do`);
 		out.push("Q");
 	});
@@ -314,7 +317,7 @@ function emitPageContent(commands, tagging) {
 				lastColor = color;
 			}
 			const x = b.x;
-			const y = b.y;
+			const y = H - b.y - b.height;
 			const w = b.width;
 			const h = b.height;
 			switch (b.side) {
@@ -342,7 +345,19 @@ function emitPageContent(commands, tagging) {
 	}
 	const shapes = plan.shapes;
 	emitTaggedRuns(out, shapes, tagging, (sh) => {
-		for (const op of emitVectorShape(sh.shape)) out.push(op);
+		const t = sh.shape.transform;
+		const shape = {
+			...sh.shape,
+			transform: [
+				t[0],
+				-t[1],
+				t[2],
+				-t[3],
+				t[4],
+				H - t[5]
+			]
+		};
+		for (const op of emitVectorShape(shape)) out.push(op);
 	});
 	const lines = plan.lines;
 	if (lines.length > 0) {
@@ -437,7 +452,7 @@ function emitPageContent(commands, tagging) {
 		const emitOneLine = (cmd) => {
 			const line = cmd.line;
 			const originX = cmd.originX;
-			const baselineY = cmd.baselineY;
+			const baselineY = H - cmd.baselineY;
 			const extraPerSpace = computeJustifyExtra(line);
 			const hasImageToken = line.tokens.some((t) => t.kind === "image");
 			const hasMathToken = line.tokens.some((t) => t.kind === "math");