reamkit 1.6.0 → 1.9.0

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

@@ -6,6 +6,7 @@ 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 { buildGradientPattern, shapeBbox } from "./shading.js";
 import { sanitizeHref } from "../core/links.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
@@ -49,9 +50,33 @@ function assembleStyledPdf(laid, options, doc) {
 	let annotParentCount = 0;
 	const fontResourceDict = buildFontResourceDict(laid.fontResources, embeddedFonts);
 	const xobjectResourceDict = buildXObjectResourceDict(laid.imageResources, embeddedImages);
+	const gradientNames = /* @__PURE__ */ new Map();
+	const patternEntries = {};
+	if (!pdfaProfile) for (const page of renderedPages) {
+		const ph = page.height;
+		for (const item of paintPlan(page.commands).shapes) {
+			const gradient = item.shape.fillGradient;
+			if (!gradient) continue;
+			const bbox = shapeBbox(item.shape);
+			if (!bbox) continue;
+			const t = item.shape.transform;
+			const ctm = [
+				t[0],
+				-t[1],
+				t[2],
+				-t[3],
+				t[4],
+				ph - t[5]
+			];
+			const nm = `Sh${gradientNames.size}`;
+			patternEntries[nm] = ref(buildGradientPattern(doc, gradient, bbox, ctm).id);
+			gradientNames.set(item.shape, nm);
+		}
+	}
 	const resourcesDict = dict({
 		Font: fontResourceDict,
-		...xobjectResourceDict ? { XObject: xobjectResourceDict } : {}
+		...xobjectResourceDict ? { XObject: xobjectResourceDict } : {},
+		...Object.keys(patternEntries).length > 0 ? { Pattern: dict(patternEntries) } : {}
 	});
 	let pdfaIccRef;
 	let transparencyGroup;
@@ -78,7 +103,7 @@ function assembleStyledPdf(laid, options, doc) {
 				tagFor: (structId) => builder.node(structId).type
 			};
 		}
-		const { content: contentBytes, links } = emitPageContent(page, pageTagging);
+		const { content: contentBytes, links } = emitPageContent(page, pageTagging, gradientNames);
 		const contentsRef = doc.add(stream({}, contentBytes));
 		const pageEntries = {
 			Type: name("Page"),
@@ -361,7 +386,7 @@ function emitTaggedRuns(out, cmds, tagging, body) {
 	}
 	close();
 }
-function emitPageContent(page, tagging) {
+function emitPageContent(page, tagging, gradientNames) {
 	const commands = page.commands;
 	const links = [];
 	if (commands.length === 0) return {
@@ -454,7 +479,7 @@ function emitPageContent(page, tagging) {
 				H - t[5]
 			]
 		};
-		for (const op of emitVectorShape(shape)) out.push(op);
+		for (const op of emitVectorShape(shape, gradientNames?.get(sh.shape))) out.push(op);
 	});
 	const lines = plan.lines;
 	if (lines.length > 0) {

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

@@ -1,4 +1,4 @@
 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>;
+export declare function emitVectorShape(shape: VectorShape, patternName?: string): Array<string>;

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

@@ -1,6 +1,6 @@
 import "../core/vector.js";
 //#region src/pdf/vector-graphics.ts
-function emitVectorShape(shape) {
+function emitVectorShape(shape, patternName) {
 	const out = [];
 	out.push("q");
 	const [a, b, c, d, e, f] = shape.transform;
@@ -14,7 +14,9 @@ function emitVectorShape(shape) {
 		const [r, g, bl] = hexToRgb01(stroke.colorHex);
 		out.push(`${num(r)} ${num(g)} ${num(bl)} RG`);
 	}
-	if (shape.fillColorHex) {
+	const usePattern = patternName !== void 0 && shape.fillGradient !== void 0;
+	if (usePattern) out.push(`/Pattern cs /${patternName} scn`);
+	else if (shape.fillColorHex) {
 		const [r, g, bl] = hexToRgb01(shape.fillColorHex);
 		out.push(`${num(r)} ${num(g)} ${num(bl)} rg`);
 	}
@@ -23,7 +25,7 @@ function emitVectorShape(shape) {
 		if (path.fillRule === "evenodd") evenodd = true;
 		for (const seg of path.segments) out.push(emitSegment(seg));
 	}
-	out.push(paintOp(shape.fillColorHex !== void 0, stroke !== void 0, evenodd));
+	out.push(paintOp(usePattern || shape.fillColorHex !== void 0, stroke !== void 0, evenodd));
 	out.push("Q");
 	return out;
 }

package/dist/esm/pdf-reader/ccitt.d.ts

@@ -0,0 +1,15 @@
+export interface CcittParams {
+    readonly k: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly byteAlign: boolean;
+}
+export declare function decodeCcitt(data: Uint8Array, params: CcittParams): Uint8Array | undefined;
+export interface Mode {
+    readonly kind: 'pass' | 'horizontal' | 'vertical';
+    readonly d: number;
+}
+export declare const WHITE_CODES: ReadonlyArray<readonly [number, string]>;
+export declare const BLACK_CODES: ReadonlyArray<readonly [number, string]>;
+export declare const SHARED_MAKEUP: ReadonlyArray<readonly [number, string]>;
+export declare const MODE_CODES: ReadonlyArray<readonly [string, Mode]>;

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

@@ -0,0 +1,394 @@
+//#region src/pdf-reader/ccitt.ts
+function decodeCcitt(data, params) {
+	const { k, columns, rows, byteAlign } = params;
+	if (k > 0) return void 0;
+	if (columns <= 0 || rows <= 0 || columns > 1 << 20) return void 0;
+	const reader = new BitReader(data);
+	const rowBytes = columns + 7 >> 3;
+	const out = new Uint8Array(rowBytes * rows);
+	let ref = [columns, columns];
+	for (let y = 0; y < rows; y++) {
+		if (byteAlign && y > 0) reader.align();
+		const cur = k < 0 ? decode2D(reader, ref, columns) : decode1D(reader, columns);
+		if (!cur) {
+			if (y === 0) return void 0;
+			break;
+		}
+		expandRow(cur, columns, out, y * rowBytes);
+		cur.push(columns, columns);
+		ref = cur;
+	}
+	return out;
+}
+function decode1D(reader, columns) {
+	const cur = [];
+	let pos = 0;
+	let color = 0;
+	while (pos < columns) {
+		const run = readRun(reader, color);
+		if (run < 0) return cur.length > 0 ? cur : null;
+		pos = Math.min(pos + run, columns);
+		cur.push(pos);
+		color ^= 1;
+	}
+	return cur;
+}
+function decode2D(reader, ref, columns) {
+	const cur = [];
+	let a0 = -1;
+	let color = 0;
+	while (a0 < columns) {
+		const [b1, b2] = findB(ref, a0, color, columns);
+		const mode = readMode(reader);
+		if (!mode) return cur.length > 0 || a0 >= 0 ? cur : null;
+		if (mode.kind === "pass") a0 = b2;
+		else if (mode.kind === "horizontal") {
+			const start = a0 < 0 ? 0 : a0;
+			const r1 = readRun(reader, color);
+			const r2 = readRun(reader, color ^ 1);
+			if (r1 < 0 || r2 < 0) return cur.length > 0 ? cur : null;
+			const a1 = Math.min(start + r1, columns);
+			const a2 = Math.min(a1 + r2, columns);
+			cur.push(a1, a2);
+			a0 = a2;
+		} else {
+			const a1 = Math.min(Math.max(b1 + mode.d, 0), columns);
+			cur.push(a1);
+			a0 = a1;
+			color ^= 1;
+		}
+	}
+	return cur;
+}
+function findB(ref, a0, color, columns) {
+	let i = 0;
+	while (i < ref.length && ref[i] <= a0) i++;
+	const wantEven = color === 0;
+	if (i < ref.length && i % 2 === 0 !== wantEven) i++;
+	return [i < ref.length ? ref[i] : columns, i + 1 < ref.length ? ref[i + 1] : columns];
+}
+function expandRow(cur, columns, out, rowOff) {
+	let prev = 0;
+	let color = 0;
+	for (const cRaw of cur) {
+		const c = Math.min(cRaw, columns);
+		if (color === 1) setBlack(out, rowOff, prev, c);
+		prev = c;
+		color ^= 1;
+		if (prev >= columns) return;
+	}
+	if (color === 1 && prev < columns) setBlack(out, rowOff, prev, columns);
+}
+function setBlack(out, rowOff, from, to) {
+	for (let x = from; x < to; x++) out[rowOff + (x >> 3)] |= 128 >> (x & 7);
+}
+function readRun(reader, color) {
+	const table = color === 1 ? BLACK : WHITE;
+	let total = 0;
+	for (let guard = 0; guard < 64; guard++) {
+		const run = readCode(reader, table);
+		if (run < 0) return -1;
+		total += run;
+		if (run < 64) return total;
+	}
+	return -1;
+}
+function readMode(reader) {
+	let code = 0;
+	for (let len = 1; len <= 7; len++) {
+		const b = reader.readBit();
+		if (b < 0) return void 0;
+		code = code << 1 | b;
+		const m = MODES.get(len << 8 | code);
+		if (m) return m;
+	}
+}
+function readCode(reader, table) {
+	let code = 0;
+	for (let len = 1; len <= table.maxLen; len++) {
+		const b = reader.readBit();
+		if (b < 0) return -1;
+		code = code << 1 | b;
+		const run = table.map.get(len << 16 | code);
+		if (run !== void 0) return run;
+	}
+	return -1;
+}
+var BitReader = class {
+	bytePos = 0;
+	bitPos = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	readBit() {
+		if (this.bytePos >= this.data.length) return -1;
+		const bit = this.data[this.bytePos] >> 7 - this.bitPos & 1;
+		if (++this.bitPos === 8) {
+			this.bitPos = 0;
+			this.bytePos++;
+		}
+		return bit;
+	}
+	align() {
+		if (this.bitPos !== 0) {
+			this.bitPos = 0;
+			this.bytePos++;
+		}
+	}
+};
+var WHITE_CODES = [
+	[0, "00110101"],
+	[1, "000111"],
+	[2, "0111"],
+	[3, "1000"],
+	[4, "1011"],
+	[5, "1100"],
+	[6, "1110"],
+	[7, "1111"],
+	[8, "10011"],
+	[9, "10100"],
+	[10, "00111"],
+	[11, "01000"],
+	[12, "001000"],
+	[13, "000011"],
+	[14, "110100"],
+	[15, "110101"],
+	[16, "101010"],
+	[17, "101011"],
+	[18, "0100111"],
+	[19, "0001100"],
+	[20, "0001000"],
+	[21, "0010111"],
+	[22, "0000011"],
+	[23, "0000100"],
+	[24, "0101000"],
+	[25, "0101011"],
+	[26, "0010011"],
+	[27, "0100100"],
+	[28, "0011000"],
+	[29, "00000010"],
+	[30, "00000011"],
+	[31, "00011010"],
+	[32, "00011011"],
+	[33, "00010010"],
+	[34, "00010011"],
+	[35, "00010100"],
+	[36, "00010101"],
+	[37, "00010110"],
+	[38, "00010111"],
+	[39, "00101000"],
+	[40, "00101001"],
+	[41, "00101010"],
+	[42, "00101011"],
+	[43, "00101100"],
+	[44, "00101101"],
+	[45, "00000100"],
+	[46, "00000101"],
+	[47, "00001010"],
+	[48, "00001011"],
+	[49, "01010010"],
+	[50, "01010011"],
+	[51, "01010100"],
+	[52, "01010101"],
+	[53, "00100100"],
+	[54, "00100101"],
+	[55, "01011000"],
+	[56, "01011001"],
+	[57, "01011010"],
+	[58, "01011011"],
+	[59, "01001010"],
+	[60, "01001011"],
+	[61, "00110010"],
+	[62, "00110011"],
+	[63, "00110100"],
+	[64, "11011"],
+	[128, "10010"],
+	[192, "010111"],
+	[256, "0110111"],
+	[320, "00110110"],
+	[384, "00110111"],
+	[448, "01100100"],
+	[512, "01100101"],
+	[576, "01101000"],
+	[640, "01100111"],
+	[704, "011001100"],
+	[768, "011001101"],
+	[832, "011010010"],
+	[896, "011010011"],
+	[960, "011010100"],
+	[1024, "011010101"],
+	[1088, "011010110"],
+	[1152, "011010111"],
+	[1216, "011011000"],
+	[1280, "011011001"],
+	[1344, "011011010"],
+	[1408, "011011011"],
+	[1472, "010011000"],
+	[1536, "010011001"],
+	[1600, "010011010"],
+	[1664, "011000"],
+	[1728, "010011011"]
+];
+var BLACK_CODES = [
+	[0, "0000110111"],
+	[1, "010"],
+	[2, "11"],
+	[3, "10"],
+	[4, "011"],
+	[5, "0011"],
+	[6, "0010"],
+	[7, "00011"],
+	[8, "000101"],
+	[9, "000100"],
+	[10, "0000100"],
+	[11, "0000101"],
+	[12, "0000111"],
+	[13, "00000100"],
+	[14, "00000111"],
+	[15, "000011000"],
+	[16, "0000010111"],
+	[17, "0000011000"],
+	[18, "0000001000"],
+	[19, "00001100111"],
+	[20, "00001101000"],
+	[21, "00001101100"],
+	[22, "00000110111"],
+	[23, "00000101000"],
+	[24, "00000010111"],
+	[25, "00000011000"],
+	[26, "000011001010"],
+	[27, "000011001011"],
+	[28, "000011001100"],
+	[29, "000011001101"],
+	[30, "000001101000"],
+	[31, "000001101001"],
+	[32, "000001101010"],
+	[33, "000001101011"],
+	[34, "000011010010"],
+	[35, "000011010011"],
+	[36, "000011010100"],
+	[37, "000011010101"],
+	[38, "000011010110"],
+	[39, "000011010111"],
+	[40, "000001101100"],
+	[41, "000001101101"],
+	[42, "000011011010"],
+	[43, "000011011011"],
+	[44, "000001010100"],
+	[45, "000001010101"],
+	[46, "000001010110"],
+	[47, "000001010111"],
+	[48, "000001100100"],
+	[49, "000001100101"],
+	[50, "000001010010"],
+	[51, "000001010011"],
+	[52, "000000100100"],
+	[53, "000000110111"],
+	[54, "000000111000"],
+	[55, "000000100111"],
+	[56, "000000101000"],
+	[57, "000001011000"],
+	[58, "000001011001"],
+	[59, "000000101011"],
+	[60, "000000101100"],
+	[61, "000001011010"],
+	[62, "000001100110"],
+	[63, "000001100111"],
+	[64, "0000001111"],
+	[128, "000011001000"],
+	[192, "000011001001"],
+	[256, "000001011011"],
+	[320, "000000110011"],
+	[384, "000000110100"],
+	[448, "000000110101"],
+	[512, "0000001101100"],
+	[576, "0000001101101"],
+	[640, "0000001001010"],
+	[704, "0000001001011"],
+	[768, "0000001001100"],
+	[832, "0000001001101"],
+	[896, "0000001110010"],
+	[960, "0000001110011"],
+	[1024, "0000001110100"],
+	[1088, "0000001110101"],
+	[1152, "0000001110110"],
+	[1216, "0000001110111"],
+	[1280, "0000001010010"],
+	[1344, "0000001010011"],
+	[1408, "0000001010100"],
+	[1472, "0000001010101"],
+	[1536, "0000001011010"],
+	[1600, "0000001011011"],
+	[1664, "0000001100100"],
+	[1728, "0000001100101"]
+];
+var SHARED_MAKEUP = [
+	[1792, "00000001000"],
+	[1856, "00000001100"],
+	[1920, "00000001101"],
+	[1984, "000000010010"],
+	[2048, "000000010011"],
+	[2112, "000000010100"],
+	[2176, "000000010101"],
+	[2240, "000000010110"],
+	[2304, "000000010111"],
+	[2368, "000000011100"],
+	[2432, "000000011101"],
+	[2496, "000000011110"],
+	[2560, "000000011111"]
+];
+var MODE_CODES = [
+	["0001", {
+		kind: "pass",
+		d: 0
+	}],
+	["001", {
+		kind: "horizontal",
+		d: 0
+	}],
+	["1", {
+		kind: "vertical",
+		d: 0
+	}],
+	["011", {
+		kind: "vertical",
+		d: 1
+	}],
+	["000011", {
+		kind: "vertical",
+		d: 2
+	}],
+	["0000011", {
+		kind: "vertical",
+		d: 3
+	}],
+	["010", {
+		kind: "vertical",
+		d: -1
+	}],
+	["000010", {
+		kind: "vertical",
+		d: -2
+	}],
+	["0000010", {
+		kind: "vertical",
+		d: -3
+	}]
+];
+function buildRunTable(...groups) {
+	const map = /* @__PURE__ */ new Map();
+	let maxLen = 0;
+	for (const group of groups) for (const [run, bits] of group) {
+		map.set(bits.length << 16 | parseInt(bits, 2), run);
+		maxLen = Math.max(maxLen, bits.length);
+	}
+	return {
+		map,
+		maxLen
+	};
+}
+var WHITE = buildRunTable(WHITE_CODES, SHARED_MAKEUP);
+var BLACK = buildRunTable(BLACK_CODES, SHARED_MAKEUP);
+var MODES = new Map(MODE_CODES.map(([bits, m]) => [bits.length << 8 | parseInt(bits, 2), m]));
+//#endregion
+export { decodeCcitt };

package/dist/esm/pdf-reader/content.d.ts

@@ -1,3 +1,4 @@
+import { ShapeGradient } from '../core/vector.js';
 export interface ContentFont {
     readonly bytesPerCode: 1 | 2;
     decode: (codes: ReadonlyArray<number>) => string;
@@ -10,5 +11,46 @@ export interface TextRun {
     readonly fontSizePt: number;
     readonly fontKey: string;
     readonly mcid?: number;
+    readonly href?: string;
 }
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>): Array<TextRun>;
+export interface ImagePlacement {
+    readonly name: string;
+    readonly ctm: Matrix;
+    readonly mcid?: number;
+}
+export type PathSeg = {
+    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 VectorPlacement {
+    readonly segs: ReadonlyArray<PathSeg>;
+    readonly fillHex?: string;
+    readonly gradient?: ShapeGradient;
+    readonly strokeHex?: string;
+    readonly lineWidth?: number;
+    readonly mcid?: number;
+}
+export interface InterpretResult {
+    readonly texts: Array<TextRun>;
+    readonly images: Array<ImagePlacement>;
+    readonly vectors: Array<VectorPlacement>;
+}
+export type Matrix = readonly [number, number, number, number, number, number];
+export declare const IDENTITY: Matrix;
+export declare function multiply(a: Matrix, b: Matrix): Matrix;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>): InterpretResult;