@segnavia/render 0.1.0 → 0.3.0

package/dist/press/sample-shading.js

@@ -0,0 +1,266 @@
+import { RenderRefusedError } from "../errors.js";
+import { IDENTITY_MATRIX, applyAffine, invertAffine, multiplyAffine } from "./affine.js";
+import { MAX_DOCUMENT_CONTENT_BYTES, arrayNumbers, decodeContent, rawStreamOf } from "./pdf-objects.js";
+import { evaluateCalculator, parseCalculator, staticOperatorCount } from "./calculator.js";
+import { PDFArray, PDFName, PDFNumber, PDFRef } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/press/sample-shading.ts
+const SHADING_SAMPLE_SPACING_PT = .5;
+const MAX_SHADING_SAMPLES = 1048576;
+const MAX_DOCUMENT_SHADING_SAMPLES = 4 * MAX_SHADING_SAMPLES;
+const MAX_DOCUMENT_CALCULATOR_OPERATIONS = 8 * MAX_SHADING_SAMPLES * 52;
+const MAX_SAMPLING_COLOR_CACHE = 4096;
+const SAMPLE_CHANNELS = 4;
+const SAMPLE_BYTES = 1;
+function refuse(found, supported) {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+}
+function clamp01(value) {
+	if (value < 0) return 0;
+	if (value > 1) return 1;
+	return value;
+}
+function requireFinite(values, found) {
+	if (values.some((value) => !Number.isFinite(value))) refuse(found, "finite numbers");
+}
+function shadingNumbers(dictionary, key, count) {
+	const expected = count === 4 ? "four finite numbers" : "six finite numbers";
+	const array = dictionary.lookupMaybe(PDFName.of(key), PDFArray);
+	if (!array || array.size() !== count) refuse(`shading ${key}`, expected);
+	const values = Array.from({ length: count }, (_, index) => array.lookupMaybe(index, PDFNumber)?.asNumber());
+	if (values.some((value) => value === void 0 || !Number.isFinite(value))) refuse(`shading ${key}`, expected);
+	return values;
+}
+function shadingDomainOf(shading) {
+	return shadingNumbers(shading, "Domain", 4);
+}
+function axisSamples(span, columnA, columnB) {
+	if (![
+		span,
+		columnA,
+		columnB
+	].every(Number.isFinite)) refuse("shading axis length", "a finite length");
+	const extent = Math.hypot(columnA, columnB) * Math.abs(span) / SHADING_SAMPLE_SPACING_PT;
+	if (!Number.isFinite(extent)) refuse("shading axis length", "a finite length");
+	return Math.min(MAX_SHADING_SAMPLES, Math.max(1, Math.ceil(extent)));
+}
+function packedRgb8(rgb) {
+	return Math.round(clamp01(rgb[0]) * 255) << 16 | Math.round(clamp01(rgb[1]) * 255) << 8 | Math.round(clamp01(rgb[2]) * 255);
+}
+function unpackRgb8(key) {
+	return [
+		(key >> 16) / 255,
+		(key >> 8 & 255) / 255,
+		(key & 255) / 255
+	];
+}
+function createSamplingColorConverter(convert) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		size: () => cache.size,
+		convert: (rgb) => {
+			const key = packedRgb8(rgb);
+			const cached = cache.get(key);
+			if (cached) return cached;
+			const converted = convert(unpackRgb8(key));
+			if (cache.size < 4096) cache.set(key, converted);
+			return converted;
+		}
+	};
+}
+function sampleDomainForPainted(domain, matrix, painted) {
+	const original = [
+		domain[0] ?? 0,
+		domain[1] ?? 0,
+		domain[2] ?? 0,
+		domain[3] ?? 0
+	];
+	if (!painted || painted === "unbounded") return original;
+	const inverse = invertAffine(matrix);
+	if (!inverse) return original;
+	const corners = [
+		applyAffine(inverse, painted.x0, painted.y0),
+		applyAffine(inverse, painted.x1, painted.y0),
+		applyAffine(inverse, painted.x0, painted.y1),
+		applyAffine(inverse, painted.x1, painted.y1)
+	];
+	const xs = corners.map((point) => point.x);
+	const ys = corners.map((point) => point.y);
+	const x0 = Math.max(original[0] ?? 0, Math.min(...xs));
+	const x1 = Math.min(original[1] ?? 0, Math.max(...xs));
+	const y0 = Math.max(original[2] ?? 0, Math.min(...ys));
+	const y1 = Math.min(original[3] ?? 0, Math.max(...ys));
+	if (!(x0 < x1) || !(y0 < y1)) return original;
+	return [
+		x0,
+		x1,
+		y0,
+		y1
+	];
+}
+function unionSampleDomain(left, right) {
+	return [
+		Math.min(left[0] ?? 0, right[0] ?? 0),
+		Math.max(left[1] ?? 0, right[1] ?? 0),
+		Math.min(left[2] ?? 0, right[2] ?? 0),
+		Math.max(left[3] ?? 0, right[3] ?? 0)
+	];
+}
+function sampleDomainForUses(domain, uses) {
+	const original = [
+		domain[0] ?? 0,
+		domain[1] ?? 0,
+		domain[2] ?? 0,
+		domain[3] ?? 0
+	];
+	if (uses.length === 0) return original;
+	let union;
+	for (const use of uses) {
+		const next = sampleDomainForPainted(domain, use.matrix, use.painted);
+		if (!use.painted || use.painted === "unbounded") return original;
+		union = union ? unionSampleDomain(union, next) : next;
+	}
+	return union ?? original;
+}
+function matrixOf(dictionary) {
+	if (!dictionary?.has(PDFName.of("Matrix"))) return IDENTITY_MATRIX.slice();
+	return arrayNumbers(dictionary, "Matrix", 6);
+}
+function shadingDeviceMatrix(shading, pattern) {
+	const shadingMatrix = shading.has(PDFName.of("Matrix")) ? shadingNumbers(shading, "Matrix", 6) : IDENTITY_MATRIX.slice();
+	return pattern ? multiplyAffine(matrixOf(pattern), shadingMatrix) : shadingMatrix;
+}
+function capSampleGrid(n, m) {
+	if (n * m <= 1048576) return {
+		n,
+		m
+	};
+	const scale = Math.sqrt(MAX_SHADING_SAMPLES / (n * m));
+	let nextN = Math.max(1, Math.floor(n * scale));
+	let nextM = Math.max(1, Math.floor(m * scale));
+	while (nextN * nextM > MAX_SHADING_SAMPLES) if (nextN >= nextM && nextN > 1) nextN--;
+	else if (nextM > 1) nextM--;
+	else break;
+	return {
+		n: nextN,
+		m: nextM
+	};
+}
+function shadingSampleGrid(domain, matrix) {
+	const x0 = domain[0] ?? 0;
+	const x1 = domain[1] ?? 0;
+	const y0 = domain[2] ?? 0;
+	const y1 = domain[3] ?? 0;
+	requireFinite([
+		x0,
+		x1,
+		y0,
+		y1
+	], "shading Domain");
+	const columnAx = matrix[0] ?? 1;
+	const columnAy = matrix[1] ?? 0;
+	const columnBx = matrix[2] ?? 0;
+	const columnBy = matrix[3] ?? 1;
+	requireFinite([
+		columnAx,
+		columnAy,
+		columnBx,
+		columnBy,
+		matrix[4] ?? 0,
+		matrix[5] ?? 0
+	], "shading Matrix");
+	return capSampleGrid(axisSamples(x1 - x0, columnAx, columnAy), axisSamples(y1 - y0, columnBx, columnBy));
+}
+function shadingSampleGridForUses(domain, matrices) {
+	if (matrices.length === 0) return shadingSampleGrid(domain, IDENTITY_MATRIX);
+	let n = 1;
+	let m = 1;
+	for (const matrix of matrices) {
+		const grid = shadingSampleGrid(domain, matrix);
+		n = Math.max(n, grid.n);
+		m = Math.max(m, grid.m);
+	}
+	return capSampleGrid(n, m);
+}
+function domainValue(min, max, index, size) {
+	if (size <= 1) return min;
+	return min + (max - min) * index / (size - 1);
+}
+function sampleShadingToCmyk(program, domain, size, convert) {
+	const x0 = domain[0] ?? 0;
+	const x1 = domain[1] ?? 0;
+	const y0 = domain[2] ?? 0;
+	const y1 = domain[3] ?? 0;
+	const samples = new Uint8Array(size.n * size.m * SAMPLE_CHANNELS * SAMPLE_BYTES);
+	const toCmyk = createSamplingColorConverter(convert).convert;
+	let offset = 0;
+	for (let j = 0; j < size.m; j++) {
+		const y = domainValue(y0, y1, j, size.m);
+		for (let i = 0; i < size.n; i++) {
+			const x = domainValue(x0, x1, i, size.n);
+			const rgb = evaluateCalculator(program, [x, y]);
+			if (rgb.length !== 3) refuse("shading function outputs", "3 numbers");
+			const cmyk = toCmyk([
+				clamp01(rgb[0] ?? 0),
+				clamp01(rgb[1] ?? 0),
+				clamp01(rgb[2] ?? 0)
+			]);
+			for (const channel of cmyk) {
+				samples[offset] = Math.round(clamp01(channel) * 255);
+				offset += SAMPLE_BYTES;
+			}
+		}
+	}
+	return samples;
+}
+function chargeShadingSamples(budget, samples, operations) {
+	const bytes = samples * SAMPLE_CHANNELS * SAMPLE_BYTES;
+	if (!Number.isFinite(samples) || samples < 0 || !Number.isFinite(bytes) || bytes < 0) refuse(`document shading samples ${samples}`, "a finite non-negative sample count and byte charge");
+	if (!Number.isFinite(operations) || operations < 0) refuse(`document calculator operations ${operations}`, "a finite non-negative operator count");
+	const totalSamples = (budget.shadingSamples ?? 0) + samples;
+	const totalBytes = budget.decodedBytes + bytes;
+	const totalOperations = (budget.calculatorOperations ?? 0) + operations;
+	if (!Number.isFinite(totalSamples) || totalSamples > 4194304) refuse(`document shading samples ${totalSamples}`, `at most ${MAX_DOCUMENT_SHADING_SAMPLES} samples`);
+	if (!Number.isFinite(totalOperations) || totalOperations > 436207616) refuse(`document calculator operations ${totalOperations}`, `at most ${MAX_DOCUMENT_CALCULATOR_OPERATIONS} operators`);
+	if (!Number.isFinite(totalBytes) || totalBytes > 134217728) refuse(`total decoded content length ${totalBytes}`, `at most ${MAX_DOCUMENT_CONTENT_BYTES} bytes`);
+	budget.shadingSamples = totalSamples;
+	budget.decodedBytes = totalBytes;
+	budget.calculatorOperations = totalOperations;
+}
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function replaceType1Function(document, shading, pattern, convert, budget, painted, sampleDomain, sampleSize) {
+	const existing = shading.get(PDFName.of("Function"));
+	const stream = rawStreamOf(resolved(document, existing));
+	if (!stream) return refuse("shading FunctionType 4 stream", "a FunctionType 4 stream");
+	const shadingDomain = shadingDomainOf(shading);
+	const matrix = shadingDeviceMatrix(shading, pattern);
+	requireFinite(matrix, "shading Matrix");
+	const domain = sampleDomain ? [...sampleDomain] : sampleDomainForPainted(shadingDomain, matrix, painted);
+	const size = sampleSize ?? shadingSampleGrid(domain, matrix);
+	const program = parseCalculator(new TextDecoder("latin1").decode(decodeContent(stream, budget)));
+	const samples = size.n * size.m;
+	chargeShadingSamples(budget, samples, samples * staticOperatorCount(program));
+	const data = sampleShadingToCmyk(program, domain, size, convert);
+	const replacement = document.context.stream(deflateSync(data), {
+		FunctionType: 0,
+		Domain: domain,
+		Range: [
+			0,
+			1,
+			0,
+			1,
+			0,
+			1,
+			0,
+			1
+		],
+		Size: [size.n, size.m],
+		BitsPerSample: 8,
+		Order: 1,
+		Filter: "FlateDecode"
+	});
+	shading.set(PDFName.of("Function"), document.context.register(replacement));
+	return size;
+}
+//#endregion
+export { MAX_DOCUMENT_CALCULATOR_OPERATIONS, MAX_DOCUMENT_SHADING_SAMPLES, MAX_SAMPLING_COLOR_CACHE, MAX_SHADING_SAMPLES, SHADING_SAMPLE_SPACING_PT, chargeShadingSamples, createSamplingColorConverter, domainValue, matrixOf, packedRgb8, replaceType1Function, sampleDomainForPainted, sampleDomainForUses, sampleShadingToCmyk, shadingDeviceMatrix, shadingDomainOf, shadingSampleGrid, shadingSampleGridForUses, unionSampleDomain, unpackRgb8 };

package/dist/press/types.d.ts

@@ -0,0 +1,18 @@
+//#region src/press/types.d.ts
+export interface PressImage {
+  width: number;
+  height: number;
+  colorSpace: 'DeviceRGB' | 'CalRGB' | 'ICCBased' | 'Indexed';
+}
+export interface PressReport {
+  /** Authored raster images left in RGB, read back from the finished PDF. */
+  images: PressImage[];
+  /** CMYK painting and group counts read back from the finished PDF. */
+  fills: number;
+  strokes: number;
+  gradientStops: number;
+  /** Function-based shadings rewritten as DeviceCMYK sampled functions. */
+  sampledShadings: number;
+  groups: number;
+}
+//#endregion

package/dist/press/visitor.js

@@ -0,0 +1,163 @@
+import { shadingFunctionAction } from "./policy.js";
+import { dictionaryOf, nameOf, numberOf, rawStreamOf } from "./pdf-objects.js";
+import { PDFArray, PDFDict, PDFName, PDFRef } from "pdf-lib";
+//#region src/press/visitor.ts
+const key = (name) => PDFName.of(name);
+const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
+const dictionary = (state, object) => dictionaryOf(resolved(state, object));
+const stream = (state, object) => rawStreamOf(resolved(state, object));
+function rememberRef(state, object) {
+	if (!(object instanceof PDFRef)) return false;
+	const label = object.toString();
+	if (state.references.has(label)) return true;
+	state.references.add(label);
+	return false;
+}
+function visitContent(state, object, replace, enclosing, replay = false, nestResources = true) {
+	if (!object) return;
+	const seenRef = rememberRef(state, object);
+	const found = stream(state, object);
+	if (!found) return;
+	const seenStream = state.streams.has(found);
+	if (!seenStream) state.streams.add(found);
+	const seen = seenRef || seenStream;
+	if (seen && !replay) return;
+	const own = found.dict.lookupMaybe(key("Resources"), PDFDict);
+	if (!seen) state.actions?.group(found.dict, found, state.maskSources.has(found));
+	state.actions?.content(object, found, replace, own ?? enclosing);
+	if (nestResources && !seen) visitResources(state, own);
+}
+function visitSoftMask(state, object, enclosing) {
+	const graphicsState = dictionary(state, object);
+	const mask = dictionary(state, graphicsState?.get(key("SMask")));
+	const sourceObject = mask?.get(key("G"));
+	const source = stream(state, sourceObject);
+	if (!graphicsState || !mask || !source || !sourceObject) return;
+	state.actions?.softMask?.(graphicsState, mask, source, source.dict.lookupMaybe(key("Resources"), PDFDict) ?? enclosing);
+	state.maskSources.add(source);
+	visitContent(state, sourceObject, (replacement) => mask?.set(key("G"), replacement), enclosing);
+}
+function visitAppearances(state, page, enclosing) {
+	const annotations = resolved(state, page.get(key("Annots")));
+	if (!(annotations instanceof PDFArray)) return;
+	for (let index = 0; index < annotations.size(); index++) {
+		const appearance = dictionary(state, dictionary(state, annotations.get(index))?.get(key("AP")));
+		for (const name of [
+			"N",
+			"R",
+			"D"
+		]) {
+			const object = appearance?.get(key(name));
+			if (!object) continue;
+			if (stream(state, object)) visitContent(state, object, (replacement) => appearance?.set(key(name), replacement), enclosing);
+			else {
+				const states = dictionary(state, object);
+				for (const [stateName, stateObject] of states?.entries() ?? []) visitContent(state, stateObject, (replacement) => states?.set(stateName, replacement), enclosing);
+			}
+		}
+	}
+}
+function visitFunction(state, object) {
+	const fn = dictionary(state, object);
+	if (fn && state.functions.has(fn)) return;
+	if (fn) state.functions.add(fn);
+	const type = fn ? numberOf(fn, "FunctionType") : void 0;
+	const functions = type === 3 ? fn?.lookupMaybe(key("Functions"), PDFArray) : void 0;
+	const decision = shadingFunctionAction(type, Boolean(fn), type !== 3 || Boolean(functions));
+	state.actions?.function(fn, decision);
+	for (let index = 0; index < (functions?.size() ?? 0); index++) visitFunction(state, functions?.get(index));
+}
+function visitShading(state, shading, pattern) {
+	if (state.actions?.shading(shading, pattern)) visitFunction(state, shading.get(key("Function")));
+}
+function visitShadings(state, resources) {
+	const shadings = resources.lookupMaybe(key("Shading"), PDFDict);
+	for (const [, object] of shadings?.entries() ?? []) {
+		const found = dictionary(state, object);
+		if (found) visitShading(state, found);
+	}
+}
+function visitPatterns(state, resources) {
+	const patterns = resources.lookupMaybe(key("Pattern"), PDFDict);
+	for (const [name, object] of patterns?.entries() ?? []) {
+		const found = dictionary(state, object);
+		if (!found) continue;
+		if (numberOf(found, "PatternType") === 2) {
+			const shading = dictionary(state, found.get(key("Shading")));
+			if (shading) visitShading(state, shading, found);
+		} else visitContent(state, object, (replacement) => patterns?.set(name, replacement), found.lookupMaybe(key("Resources"), PDFDict) ?? resources);
+		visitResources(state, found.lookupMaybe(key("Resources"), PDFDict));
+	}
+}
+function visitGraphicsStates(state, resources) {
+	const graphicsStates = resources.lookupMaybe(key("ExtGState"), PDFDict);
+	for (const [, object] of graphicsStates?.entries() ?? []) visitSoftMask(state, object, resources);
+}
+function visitXObjects(state, resources) {
+	const xObjects = resources.lookupMaybe(key("XObject"), PDFDict);
+	for (const [name, object] of xObjects?.entries() ?? []) {
+		const found = stream(state, object);
+		if (!found) continue;
+		if (nameOf(found.dict.get(key("Subtype"))) === "Image") state.actions?.image(found);
+		else visitContent(state, object, (replacement) => xObjects?.set(name, replacement), found.dict.lookupMaybe(key("Resources"), PDFDict) ?? resources);
+	}
+}
+function visitFonts(state, resources) {
+	const fonts = resources.lookupMaybe(key("Font"), PDFDict);
+	for (const [, object] of fonts?.entries() ?? []) {
+		const font = dictionary(state, object);
+		if (!font || nameOf(font.get(key("Subtype"))) !== "Type3") continue;
+		const charProcs = font.lookupMaybe(key("CharProcs"), PDFDict);
+		for (const [name, glyph] of charProcs?.entries() ?? []) visitContent(state, glyph, (replacement) => charProcs?.set(name, replacement), font.lookupMaybe(key("Resources"), PDFDict) ?? resources);
+		visitResources(state, font.lookupMaybe(key("Resources"), PDFDict));
+	}
+}
+function visitResources(state, resources) {
+	if (!resources || state.resources.has(resources)) return;
+	state.resources.add(resources);
+	visitGraphicsStates(state, resources);
+	visitXObjects(state, resources);
+	visitFonts(state, resources);
+	visitShadings(state, resources);
+	visitPatterns(state, resources);
+}
+function visitPageContents(state, page, contents, pageResources) {
+	const replay = Boolean(state.actions?.replayPageContents);
+	const nested = [];
+	const feed = (object, replace) => {
+		visitContent(state, object, replace, pageResources, replay, false);
+		const own = stream(state, object)?.dict.lookupMaybe(key("Resources"), PDFDict);
+		if (own) nested.push(own);
+	};
+	if (contents instanceof PDFArray) {
+		state.actions?.beginContentsSequence?.();
+		for (let index = 0; index < contents.size(); index++) feed(contents.get(index), (replacement) => contents.set(index, replacement));
+		state.actions?.endContentsSequence?.();
+	} else feed(contents, (replacement) => page.set(key("Contents"), replacement));
+	for (const resources of nested) visitResources(state, resources);
+}
+function traverse(document, maskSources, actions) {
+	const state = {
+		document,
+		maskSources,
+		actions,
+		functions: /* @__PURE__ */ new WeakSet(),
+		references: /* @__PURE__ */ new Set(),
+		resources: /* @__PURE__ */ new WeakSet(),
+		streams: /* @__PURE__ */ new WeakSet()
+	};
+	for (const page of document.getPages()) {
+		actions?.group(page.node, void 0, false);
+		const pageResources = page.node.Resources();
+		visitPageContents(state, page.node, page.node.Contents(), pageResources);
+		visitResources(state, pageResources);
+		visitAppearances(state, page.node, pageResources);
+	}
+}
+function walkPressGraph(document, actions) {
+	const maskSources = /* @__PURE__ */ new WeakSet();
+	traverse(document, maskSources);
+	traverse(document, maskSources, actions);
+}
+//#endregion
+export { walkPressGraph };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/render",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,8 +26,8 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.1.0",
-    "@segnavia/frame": "0.1.0",
+    "@segnavia/format": "0.3.0",
+    "@segnavia/frame": "0.3.0",
     "playwright-core": "1.55.1",
     "pdf-lib": "^1.17.1"
   }