reamkit 0.1.0-alpha.0

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

@@ -0,0 +1,335 @@
+import { name, stream } from "./objects.js";
+import { unzlibSync, zlibSync } from "fflate";
+//#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 embedImage(doc, bytes, options = {}) {
+	const format = detectImageFormat(bytes);
+	if (format === "jpeg") return embedJpeg(doc, bytes);
+	if (format === "png") return embedPng(doc, bytes, options);
+	if (format === "jpeg2000") return embedJpeg2000(doc, bytes);
+	throw new Error("Unsupported image format");
+}
+function embedJpeg2000(doc, bytes) {
+	const { width, height } = readJpeg2000Info(bytes);
+	return {
+		ref: doc.add(stream({
+			Type: name("XObject"),
+			Subtype: name("Image"),
+			Width: width,
+			Height: height,
+			Filter: name("JPXDecode")
+		}, bytes)),
+		widthPx: width,
+		heightPx: height
+	};
+}
+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 embedJpeg(doc, bytes) {
+	const info = readJpegInfo(bytes);
+	const colorSpace = info.numComponents === 1 ? "DeviceGray" : "DeviceRGB";
+	return {
+		ref: doc.add(stream({
+			Type: name("XObject"),
+			Subtype: name("Image"),
+			Width: info.width,
+			Height: info.height,
+			ColorSpace: name(colorSpace),
+			BitsPerComponent: info.precision,
+			Filter: name("DCTDecode")
+		}, bytes)),
+		widthPx: info.width,
+		heightPx: info.height
+	};
+}
+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 embedPng(doc, bytes, options = {}) {
+	let decoded = decodePng(bytes);
+	if (options.flattenAlpha && decoded.smaskRaw) decoded = flattenAlphaOnWhite(decoded);
+	const compressedColor = zlibSync(decoded.raw);
+	const baseDict = {
+		Type: name("XObject"),
+		Subtype: name("Image"),
+		Width: decoded.width,
+		Height: decoded.height,
+		ColorSpace: name(decoded.colorSpace),
+		BitsPerComponent: decoded.bitsPerComponent,
+		Filter: name("FlateDecode")
+	};
+	let smaskRef;
+	if (decoded.smaskRaw) {
+		const compressedAlpha = zlibSync(decoded.smaskRaw);
+		smaskRef = doc.add(stream({
+			Type: name("XObject"),
+			Subtype: name("Image"),
+			Width: decoded.width,
+			Height: decoded.height,
+			ColorSpace: name("DeviceGray"),
+			BitsPerComponent: 8,
+			Filter: name("FlateDecode")
+		}, compressedAlpha));
+	}
+	const entries = { ...baseDict };
+	if (smaskRef) entries["SMask"] = smaskRef;
+	return {
+		ref: doc.add(stream(entries, compressedColor)),
+		widthPx: decoded.width,
+		heightPx: decoded.height
+	};
+}
+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 { detectImageFormat, embedImage };

package/dist/esm/pdf/index.d.ts

@@ -0,0 +1,11 @@
+export { renderPlainTextPdf } from './text-page-renderer.js';
+export type { TextRenderOptions, FontInput } from './text-page-renderer.js';
+export { renderStyledPdf } from './styled-page-renderer.js';
+export type { DocumentInfo, StyledRenderOptions, PdfALevel } from './styled-page-renderer.js';
+export { signPdf } from './signature.js';
+export type { SignaturePlaceholder, SignerCredentials, SignatureOptions } from './signature.js';
+export type { AttachedFile, AFRelationship } from './embedded-file.js';
+export { embedTtfFont } from './cid-font.js';
+export type { EmbeddedFont } from './cid-font.js';
+export { embedImage, detectImageFormat } from './image-xobject.js';
+export type { EmbeddedImage, ImageFormat } from './image-xobject.js';

package/dist/esm/pdf/index.js

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

package/dist/esm/pdf/math-layout.d.ts

@@ -0,0 +1,45 @@
+import { MathNode } from '../document-model/index.js';
+import { PathSegment } from './vector-graphics.js';
+export type MathVariant = 'regular' | 'italic' | 'bold' | 'boldItalic';
+export interface MathGlyphItem {
+    readonly kind: 'glyph';
+    readonly x: number;
+    readonly y: number;
+    readonly text: string;
+    readonly variant: MathVariant;
+    readonly sizePt: number;
+}
+export interface MathRuleItem {
+    readonly kind: 'rule';
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+export interface MathPathItem {
+    readonly kind: 'path';
+    readonly segments: ReadonlyArray<PathSegment>;
+    readonly strokeWidthPt?: number;
+    readonly fill?: boolean;
+}
+export type MathDrawItem = MathGlyphItem | MathRuleItem | MathPathItem;
+export interface MathBox {
+    readonly width: number;
+    readonly ascent: number;
+    readonly descent: number;
+    readonly items: ReadonlyArray<MathDrawItem>;
+}
+export type MeasureMath = (text: string, sizePt: number, variant: MathVariant) => number;
+export interface MathCtx {
+    readonly sizePt: number;
+}
+export declare function variantStyle(v: MathVariant): {
+    bold: boolean;
+    italic: boolean;
+};
+export declare function layoutMath(node: MathNode, ctx: MathCtx, measure: MeasureMath): MathBox;
+export declare function shiftItems(items: ReadonlyArray<MathDrawItem>, dx: number, dy: number): Array<MathDrawItem>;
+export declare function mathGlyphSegments(node: MathNode): Array<{
+    variant: MathVariant;
+    text: string;
+}>;