reamkit 0.1.0-alpha.0

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

@@ -0,0 +1,174 @@
+import { shapeText } from "../font/opentype-layout.js";
+import { glyphClosure, subsetTtf } from "../font/ttf-subset.js";
+import { dict, name, ref, stream } from "./objects.js";
+//#region src/pdf/cid-font.ts
+var encoder = new TextEncoder();
+function embedTtfFont(doc, parsed, options = {}) {
+	const scale = 1e3 / parsed.unitsPerEm;
+	const toPdfUnits = (v) => Math.round(v * scale);
+	const usedGidsArr = options.usedGids ? [...options.usedGids] : void 0;
+	const fontFileBytes = usedGidsArr ? subsetTtf(parsed, usedGidsArr) : parsed.raw;
+	const fontFileRef = doc.add(stream({ Length1: fontFileBytes.byteLength }, fontFileBytes));
+	const cidSetRef = usedGidsArr !== void 0 && options.cidSet ? doc.add(stream({}, buildCidSet(glyphClosure(parsed, usedGidsArr)))) : void 0;
+	const baseFontName = usedGidsArr ? `${subsetTag(parsed.postScriptName, usedGidsArr)}+${parsed.postScriptName}` : parsed.postScriptName;
+	const descriptorRef = doc.add(dict({
+		Type: name("FontDescriptor"),
+		FontName: name(baseFontName),
+		Flags: parsed.flags,
+		FontBBox: [
+			toPdfUnits(parsed.fontBBox[0]),
+			toPdfUnits(parsed.fontBBox[1]),
+			toPdfUnits(parsed.fontBBox[2]),
+			toPdfUnits(parsed.fontBBox[3])
+		],
+		ItalicAngle: parsed.italicAngle,
+		Ascent: toPdfUnits(parsed.ascender),
+		Descent: toPdfUnits(parsed.descender),
+		CapHeight: toPdfUnits(parsed.capHeight),
+		XHeight: toPdfUnits(parsed.xHeight),
+		StemV: parsed.stemV,
+		FontFile2: ref(fontFileRef.id),
+		...cidSetRef ? { CIDSet: ref(cidSetRef.id) } : {}
+	}));
+	const widths = new Array(parsed.numGlyphs);
+	for (let i = 0; i < parsed.numGlyphs; i++) widths[i] = toPdfUnits(parsed.advanceWidths[i] ?? 0);
+	const cidFontRef = doc.add(dict({
+		Type: name("Font"),
+		Subtype: name("CIDFontType2"),
+		BaseFont: name(baseFontName),
+		CIDSystemInfo: dict({
+			Registry: "Adobe",
+			Ordering: "Identity",
+			Supplement: 0
+		}),
+		FontDescriptor: ref(descriptorRef.id),
+		DW: 1e3,
+		W: [0, widths],
+		CIDToGIDMap: name("Identity")
+	}));
+	const toUnicodeRef = doc.add(stream({}, buildToUnicodeCMap(parsed)));
+	const type0Ref = doc.add(dict({
+		Type: name("Font"),
+		Subtype: name("Type0"),
+		BaseFont: name(baseFontName),
+		Encoding: name("Identity-H"),
+		DescendantFonts: [ref(cidFontRef.id)],
+		ToUnicode: ref(toUnicodeRef.id)
+	}));
+	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 encodeTextAsCidHexFn = (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 {
+		fontRef: type0Ref,
+		parsed,
+		pdfWidthForGid,
+		textWidthPt,
+		encodeTextAsCidHex: encodeTextAsCidHexFn
+	};
+}
+function buildCidSet(cids) {
+	let maxCid = 0;
+	for (const c of cids) if (c > maxCid) maxCid = c;
+	const bytes = new Uint8Array((maxCid >> 3) + 1);
+	for (const c of cids) bytes[c >> 3] |= 128 >> (c & 7);
+	return bytes;
+}
+function subsetTag(postScriptName, gids) {
+	let h = 2166136261;
+	const mix = (n) => {
+		h = (h ^ n & 255) >>> 0;
+		h = Math.imul(h, 16777619) >>> 0;
+	};
+	for (let i = 0; i < postScriptName.length; i++) mix(postScriptName.charCodeAt(i));
+	for (const g of [...gids].sort((a, b) => a - b)) {
+		mix(g);
+		mix(g >> 8);
+	}
+	let tag = "";
+	for (let i = 0; i < 6; i++) {
+		tag += String.fromCharCode(65 + h % 26);
+		h = Math.floor(h / 26) + 1;
+	}
+	return tag;
+}
+function buildToUnicodeCMap(parsed) {
+	const gidToCps = /* @__PURE__ */ new Map();
+	const order = [];
+	for (let cp = 9; cp <= 65535; cp++) {
+		if (cp >= 55296 && cp <= 57343) continue;
+		const gid = parsed.glyphForCodepoint(cp);
+		if (gid === 0 || gidToCps.has(gid)) continue;
+		gidToCps.set(gid, [cp]);
+		order.push(gid);
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [key, ligGid] of parsed.ligatures) {
+			if (gidToCps.has(ligGid)) continue;
+			const cps = [];
+			let ok = true;
+			for (const comp of key.split(",")) {
+				const c = gidToCps.get(Number(comp));
+				if (!c) {
+					ok = false;
+					break;
+				}
+				cps.push(...c);
+			}
+			if (ok && cps.length > 0) {
+				gidToCps.set(ligGid, cps);
+				order.push(ligGid);
+				changed = true;
+			}
+		}
+	}
+	const pairs = order.map((g) => [g, gidToCps.get(g)]).sort((a, b) => a[0] - b[0]);
+	const utf16beHex = (cps) => {
+		let hex = "";
+		for (const cp of cps) if (cp <= 65535) hex += cp.toString(16).padStart(4, "0").toUpperCase();
+		else {
+			const adj = cp - 65536;
+			hex += (55296 + (adj >> 10)).toString(16).padStart(4, "0").toUpperCase();
+			hex += (56320 + (adj & 1023)).toString(16).padStart(4, "0").toUpperCase();
+		}
+		return hex;
+	};
+	const lines = [];
+	lines.push("/CIDInit /ProcSet findresource begin");
+	lines.push("12 dict begin");
+	lines.push("begincmap");
+	lines.push("/CIDSystemInfo <</Registry (Adobe) /Ordering (UCS) /Supplement 0>> def");
+	lines.push("/CMapName /Adobe-Identity-UCS def");
+	lines.push("/CMapType 2 def");
+	lines.push("1 begincodespacerange");
+	lines.push("<0000> <FFFF>");
+	lines.push("endcodespacerange");
+	const CHUNK = 100;
+	for (let i = 0; i < pairs.length; i += CHUNK) {
+		const chunk = pairs.slice(i, i + CHUNK);
+		lines.push(`${chunk.length} beginbfchar`);
+		for (const [gid, cps] of chunk) lines.push(`<${gid.toString(16).padStart(4, "0").toUpperCase()}> <${utf16beHex(cps)}>`);
+		lines.push("endbfchar");
+	}
+	lines.push("endcmap");
+	lines.push("CMapName currentdict /CMap defineresource pop");
+	lines.push("end");
+	lines.push("end");
+	return encoder.encode(lines.join("\n"));
+}
+//#endregion
+export { embedTtfFont };

package/dist/esm/pdf/embedded-file.d.ts

@@ -0,0 +1,11 @@
+import { PdfRef } from './objects.js';
+import { PdfDocument } from './writer.js';
+export type AFRelationship = 'Source' | 'Data' | 'Alternative' | 'Supplement' | 'Unspecified';
+export interface AttachedFile {
+    readonly name: string;
+    readonly bytes: Uint8Array;
+    readonly mimeType: string;
+    readonly relationship?: AFRelationship;
+    readonly description?: string;
+}
+export declare function embedAssociatedFile(doc: PdfDocument, file: AttachedFile): PdfRef;

package/dist/esm/pdf/embedded-file.js

@@ -0,0 +1,23 @@
+import { dict, name, ref, stream, unicodeString } from "./objects.js";
+//#region src/pdf/embedded-file.ts
+function embedAssociatedFile(doc, file) {
+	const efRef = doc.add(stream({
+		Type: name("EmbeddedFile"),
+		Subtype: name(file.mimeType),
+		Params: dict({ Size: file.bytes.byteLength })
+	}, file.bytes));
+	const filespec = {
+		Type: name("Filespec"),
+		F: file.name,
+		UF: unicodeString(file.name),
+		EF: dict({
+			F: ref(efRef.id),
+			UF: ref(efRef.id)
+		}),
+		AFRelationship: name(file.relationship ?? "Unspecified")
+	};
+	if (file.description) filespec["Desc"] = unicodeString(file.description);
+	return doc.add(dict(filespec));
+}
+//#endregion
+export { embedAssociatedFile };

package/dist/esm/pdf/icc-profile.d.ts

@@ -0,0 +1 @@
+export declare function buildSrgbIccProfile(): Uint8Array;

package/dist/esm/pdf/icc-profile.js

@@ -0,0 +1,166 @@
+//#region src/pdf/icc-profile.ts
+function s15Fixed16(value) {
+	return Math.round(value * 65536);
+}
+function writeU32BE(view, offset, value) {
+	view.setUint32(offset, value >>> 0, false);
+}
+function tag(s) {
+	return (s.charCodeAt(0) << 24 | s.charCodeAt(1) << 16 | s.charCodeAt(2) << 8 | s.charCodeAt(3)) >>> 0;
+}
+var D50 = {
+	x: .9642,
+	y: 1,
+	z: .8249
+};
+var RED = {
+	x: .43607,
+	y: .22249,
+	z: .0139
+};
+var GREEN = {
+	x: .38515,
+	y: .71687,
+	z: .09708
+};
+var BLUE = {
+	x: .14307,
+	y: .06061,
+	z: .7141
+};
+var DESC = "sRGB-compatible";
+var COPYRIGHT = "Public Domain";
+function buildTextDescription(text) {
+	const ascii = text + "\0";
+	const asciiBytes = new TextEncoder().encode(ascii);
+	const size = 12 + asciiBytes.length + 4 + 4 + 2 + 1 + 67;
+	const buf = new Uint8Array(align4(size));
+	const view = new DataView(buf.buffer);
+	writeU32BE(view, 0, tag("desc"));
+	writeU32BE(view, 4, 0);
+	writeU32BE(view, 8, asciiBytes.length);
+	buf.set(asciiBytes, 12);
+	return buf;
+}
+function buildText(text) {
+	const bytes = new TextEncoder().encode(text + "\0");
+	const size = 8 + bytes.length;
+	const buf = new Uint8Array(align4(size));
+	const view = new DataView(buf.buffer);
+	writeU32BE(view, 0, tag("text"));
+	writeU32BE(view, 4, 0);
+	buf.set(bytes, 8);
+	return buf;
+}
+function buildXYZ(x, y, z) {
+	const buf = new Uint8Array(20);
+	const view = new DataView(buf.buffer);
+	writeU32BE(view, 0, tag("XYZ "));
+	writeU32BE(view, 4, 0);
+	view.setInt32(8, s15Fixed16(x), false);
+	view.setInt32(12, s15Fixed16(y), false);
+	view.setInt32(16, s15Fixed16(z), false);
+	return buf;
+}
+function buildCurveGamma(gamma) {
+	const buf = new Uint8Array(align4(14));
+	const view = new DataView(buf.buffer);
+	writeU32BE(view, 0, tag("curv"));
+	writeU32BE(view, 4, 0);
+	writeU32BE(view, 8, 1);
+	view.setUint16(12, Math.round(gamma * 256), false);
+	return buf;
+}
+function align4(n) {
+	return n + 3 & -4;
+}
+function buildSrgbIccProfile() {
+	const desc = buildTextDescription(DESC);
+	const wtpt = buildXYZ(D50.x, D50.y, D50.z);
+	const rXYZ = buildXYZ(RED.x, RED.y, RED.z);
+	const gXYZ = buildXYZ(GREEN.x, GREEN.y, GREEN.z);
+	const bXYZ = buildXYZ(BLUE.x, BLUE.y, BLUE.z);
+	const trc = buildCurveGamma(2.2);
+	const cprt = buildText(COPYRIGHT);
+	const entries = [
+		{
+			sig: "desc",
+			data: desc
+		},
+		{
+			sig: "wtpt",
+			data: wtpt
+		},
+		{
+			sig: "rXYZ",
+			data: rXYZ
+		},
+		{
+			sig: "gXYZ",
+			data: gXYZ
+		},
+		{
+			sig: "bXYZ",
+			data: bXYZ
+		},
+		{
+			sig: "rTRC",
+			data: trc
+		},
+		{
+			sig: "gTRC",
+			data: trc
+		},
+		{
+			sig: "bTRC",
+			data: trc
+		},
+		{
+			sig: "cprt",
+			data: cprt
+		}
+	];
+	const headerSize = 128;
+	const tagCount = entries.length;
+	let dataOffset = align4(headerSize + (4 + tagCount * 12));
+	const blockOffsets = /* @__PURE__ */ new Map();
+	const orderedBlocks = [];
+	for (const e of entries) if (!blockOffsets.has(e.data)) {
+		blockOffsets.set(e.data, dataOffset);
+		orderedBlocks.push({
+			data: e.data,
+			offset: dataOffset
+		});
+		dataOffset += align4(e.data.length);
+	}
+	const totalSize = dataOffset;
+	const out = new Uint8Array(totalSize);
+	const view = new DataView(out.buffer);
+	writeU32BE(view, 0, totalSize);
+	writeU32BE(view, 4, 0);
+	writeU32BE(view, 8, 35651584);
+	writeU32BE(view, 12, tag("mntr"));
+	writeU32BE(view, 16, tag("RGB "));
+	writeU32BE(view, 20, tag("XYZ "));
+	view.setUint16(24, 2e3, false);
+	view.setUint16(26, 1, false);
+	view.setUint16(28, 1, false);
+	writeU32BE(view, 36, tag("acsp"));
+	writeU32BE(view, 64, 0);
+	view.setInt32(68, s15Fixed16(D50.x), false);
+	view.setInt32(72, s15Fixed16(D50.y), false);
+	view.setInt32(76, s15Fixed16(D50.z), false);
+	writeU32BE(view, headerSize, tagCount);
+	let p = headerSize + 4;
+	for (const e of entries) {
+		const off = blockOffsets.get(e.data);
+		writeU32BE(view, p, tag(e.sig));
+		writeU32BE(view, p + 4, off);
+		writeU32BE(view, p + 8, e.data.length);
+		p += 12;
+	}
+	for (const b of orderedBlocks) out.set(b.data, b.offset);
+	return out;
+}
+//#endregion
+export { buildSrgbIccProfile };

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

@@ -0,0 +1,13 @@
+import { PdfRef } from './objects.js';
+import { PdfDocument } from './writer.js';
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000';
+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 declare function embedImage(doc: PdfDocument, bytes: Uint8Array, options?: EmbedImageOptions): EmbeddedImage;