@segnavia/render 0.2.0 → 0.3.0

package/dist/press/content.js

@@ -232,6 +232,29 @@ function scan(source, convert, inspect, visit, operatorVisit) {
 	}
 	return counts;
 }
+function visitContentTokens(bytes, visit) {
+	visitContentOperations(bytes, ({ operator, operands }) => visit(operator, operands));
+}
+function visitContentOperations(bytes, visit) {
+	scan(decoder.decode(bytes), () => [
+		0,
+		0,
+		0,
+		0
+	], false, void 0, (operator, operands) => {
+		visit({
+			end: operator.end,
+			operands: operands.flatMap((operand) => operand.kind === "name" || operand.kind === "number" ? [{
+				end: operand.end,
+				kind: operand.kind,
+				raw: operand.raw,
+				start: operand.start
+			}] : []),
+			operator: operator.raw,
+			start: operator.start
+		});
+	});
+}
 function inspectContent(bytes) {
 	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", "CMYK operators"), true);
 }
@@ -266,4 +289,4 @@ function rewriteContent(bytes, convert) {
 	};
 }
 //#endregion
-export { inspectContent, rewriteContent };
+export { inspectContent, rewriteContent, visitContentOperations, visitContentTokens };

package/dist/press/pattern-bounds.js

@@ -0,0 +1,275 @@
+import { IDENTITY_MATRIX, multiplyAffine } from "./affine.js";
+import { visitContentTokens } from "./content.js";
+import { numberOf } from "./pdf-objects.js";
+import { clearPath, closePath, curveTo, curveV, curveY, deviceBox, intersectRect, lineTo, moveTo, rectTo } from "./pattern-path.js";
+const cloneGraphics = (graphics) => ({
+	clip: graphics.clip ? { ...graphics.clip } : void 0,
+	ctm: graphics.ctm.slice(),
+	fill: graphics.fill,
+	lineJoin: graphics.lineJoin,
+	lineWidth: graphics.lineWidth,
+	miterLimit: graphics.miterLimit,
+	stroke: graphics.stroke
+});
+function numbers(operands, count) {
+	if (operands.length !== count || operands.some((operand) => operand.kind !== "number")) return void 0;
+	return operands.map((operand) => Number(operand.raw));
+}
+function nameOf(operands) {
+	if (operands.length !== 1 || operands[0]?.kind !== "name") return void 0;
+	return operands[0].raw.slice(1);
+}
+function unionRect(left, right) {
+	return {
+		x0: Math.min(left.x0, right.x0),
+		y0: Math.min(left.y0, right.y0),
+		x1: Math.max(left.x1, right.x1),
+		y1: Math.max(left.y1, right.y1)
+	};
+}
+function addPaint(bounds, target, paint) {
+	if (!target) return;
+	const existing = bounds.get(target);
+	if (existing === "unbounded" || paint === "unbounded") {
+		bounds.set(target, "unbounded");
+		return;
+	}
+	bounds.set(target, existing ? unionRect(existing, paint) : paint);
+}
+function strokeMargin(graphics) {
+	const half = graphics.lineWidth / 2;
+	if (!Number.isFinite(half) || half < 0) return void 0;
+	if (graphics.lineJoin === 1 || graphics.lineJoin === 2) return half;
+	if (graphics.lineJoin !== 0 || !Number.isFinite(graphics.miterLimit) || graphics.miterLimit < 1) return void 0;
+	return graphics.miterLimit * half;
+}
+function paintFill(state) {
+	if (state.pastSaveCap) {
+		addPaint(state.bounds, state.current.fill, "unbounded");
+		return;
+	}
+	if (!state.path.box) return;
+	const box = deviceBox(state.path.box, state.current.ctm);
+	if (box) addPaint(state.bounds, state.current.fill, box);
+}
+function paintStroke(state) {
+	if (state.pastSaveCap) {
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	if (!state.path.box) return;
+	const margin = strokeMargin(state.current);
+	if (margin === void 0) {
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	const grown = {
+		x0: state.path.box.x0 - margin,
+		y0: state.path.box.y0 - margin,
+		x1: state.path.box.x1 + margin,
+		y1: state.path.box.y1 + margin
+	};
+	const box = deviceBox(grown, state.current.ctm);
+	if (box) addPaint(state.bounds, state.current.stroke, box);
+}
+function applyMove(state, operands) {
+	const values = numbers(operands, 2);
+	if (values) moveTo(state.path, values[0] ?? 0, values[1] ?? 0);
+}
+function applyLine(state, operands) {
+	const values = numbers(operands, 2);
+	if (values) lineTo(state.path, values[0] ?? 0, values[1] ?? 0);
+}
+function applyCurve(state, operands) {
+	const values = numbers(operands, 6);
+	if (values) curveTo(state.path, values);
+}
+function applyCurveV(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) curveV(state.path, values);
+}
+function applyCurveY(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) curveY(state.path, values);
+}
+function applyRect(state, operands) {
+	const values = numbers(operands, 4);
+	if (values) rectTo(state.path, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0, values[3] ?? 0);
+}
+function applyCm(state, operands) {
+	const values = numbers(operands, 6);
+	if (!values) {
+		addPaint(state.bounds, state.current.fill, "unbounded");
+		addPaint(state.bounds, state.current.stroke, "unbounded");
+		return;
+	}
+	state.current.ctm = multiplyAffine(state.current.ctm, values);
+}
+function clearColor(state, fill) {
+	if (fill) state.current.fill = void 0;
+	else state.current.stroke = void 0;
+}
+function applyColor(state, operator, operands) {
+	const fill = operator === operator.toLowerCase();
+	const patternName = nameOf(operands);
+	if ((operator === "scn" || operator === "SCN") && patternName) {
+		const pattern = state.resolve(patternName);
+		if (fill) state.current.fill = pattern;
+		else state.current.stroke = pattern;
+		return;
+	}
+	if ((operator === "cs" || operator === "CS") && nameOf(operands) === "Pattern") return;
+	clearColor(state, fill);
+}
+const colorHandler = (operator) => (state, operands) => applyColor(state, operator, operands);
+function markUnbounded(state) {
+	addPaint(state.bounds, state.current.fill, "unbounded");
+	addPaint(state.bounds, state.current.stroke, "unbounded");
+}
+function strokeAndClear(state, close) {
+	if (close) closePath(state.path);
+	paintStroke(state);
+	clearPath(state.path);
+}
+function fillAndClear(state) {
+	paintFill(state);
+	clearPath(state.path);
+}
+function fillStrokeAndClear(state, close) {
+	if (close) closePath(state.path);
+	paintFill(state);
+	paintStroke(state);
+	clearPath(state.path);
+}
+function setLineWidth(state, width) {
+	if (!Number.isFinite(width) || width < 0) return false;
+	state.current.lineWidth = width;
+	return true;
+}
+function setLineJoin(state, join) {
+	if (join !== 0 && join !== 1 && join !== 2) return false;
+	state.current.lineJoin = join;
+	return true;
+}
+function setMiterLimit(state, miter) {
+	if (!Number.isFinite(miter) || miter < 1) return false;
+	state.current.miterLimit = miter;
+	return true;
+}
+function applyStrokeNumber(state, operands, assign) {
+	const value = numbers(operands, 1)?.[0];
+	if (value === void 0 || !assign(state, value)) markUnbounded(state);
+}
+function applyStyleNumber(dict, key, assign) {
+	const value = numberOf(dict, key);
+	return value === void 0 || assign(value);
+}
+function applyGraphicsState(state, operands) {
+	const name = nameOf(operands);
+	const dict = name ? state.resolveGraphicsState(name) : void 0;
+	if (!dict) {
+		markUnbounded(state);
+		return;
+	}
+	if (!(applyStyleNumber(dict, "LW", (width) => setLineWidth(state, width)) && applyStyleNumber(dict, "LJ", (join) => setLineJoin(state, join)) && applyStyleNumber(dict, "ML", (miter) => setMiterLimit(state, miter)))) markUnbounded(state);
+}
+function saveGraphics(state) {
+	if (state.pastSaveCap || state.graphics.length >= 64) {
+		state.pastSaveCap = true;
+		markUnbounded(state);
+		return;
+	}
+	state.graphics.push(cloneGraphics(state.current));
+}
+function applyClip(state) {
+	if (!state.path.box) return;
+	const box = deviceBox(state.path.box, state.current.ctm);
+	if (!box) return;
+	state.current.clip = state.current.clip ? intersectRect(state.current.clip, box) : box;
+}
+function applyShading(state, operands) {
+	const name = nameOf(operands);
+	const shading = name ? state.resolveShading(name) : void 0;
+	if (state.pastSaveCap || !state.current.clip) {
+		addPaint(state.shadingBounds, shading, "unbounded");
+		return;
+	}
+	addPaint(state.shadingBounds, shading, state.current.clip);
+}
+const handlers = {
+	q: saveGraphics,
+	Q: (state) => {
+		const restored = state.graphics.pop();
+		if (restored) state.current = restored;
+	},
+	cm: applyCm,
+	m: applyMove,
+	l: applyLine,
+	c: applyCurve,
+	v: applyCurveV,
+	y: applyCurveY,
+	h: (state) => closePath(state.path),
+	re: applyRect,
+	n: (state) => clearPath(state.path),
+	W: applyClip,
+	"W*": applyClip,
+	sh: applyShading,
+	Do: markUnbounded,
+	S: (state) => strokeAndClear(state, false),
+	s: (state) => strokeAndClear(state, true),
+	f: fillAndClear,
+	F: fillAndClear,
+	"f*": fillAndClear,
+	B: (state) => fillStrokeAndClear(state, false),
+	"B*": (state) => fillStrokeAndClear(state, false),
+	b: (state) => fillStrokeAndClear(state, true),
+	"b*": (state) => fillStrokeAndClear(state, true),
+	w: (state, operands) => applyStrokeNumber(state, operands, setLineWidth),
+	j: (state, operands) => applyStrokeNumber(state, operands, setLineJoin),
+	M: (state, operands) => applyStrokeNumber(state, operands, setMiterLimit),
+	gs: applyGraphicsState,
+	cs: colorHandler("cs"),
+	CS: colorHandler("CS"),
+	sc: colorHandler("sc"),
+	SC: colorHandler("SC"),
+	scn: colorHandler("scn"),
+	SCN: colorHandler("SCN"),
+	rg: colorHandler("rg"),
+	RG: colorHandler("RG"),
+	g: colorHandler("g"),
+	G: colorHandler("G"),
+	k: colorHandler("k"),
+	K: colorHandler("K")
+};
+function emptyGraphics() {
+	return {
+		ctm: IDENTITY_MATRIX.slice(),
+		lineJoin: 0,
+		lineWidth: 1,
+		miterLimit: 10
+	};
+}
+function createPaintedBoundsTracker(bounds, shadingBounds = /* @__PURE__ */ new WeakMap()) {
+	const state = {
+		bounds,
+		current: emptyGraphics(),
+		graphics: [],
+		pastSaveCap: false,
+		path: {},
+		resolve: () => void 0,
+		resolveGraphicsState: () => void 0,
+		resolveShading: () => void 0,
+		shadingBounds
+	};
+	return { feed(bytes, resolve, resolveGraphicsState = () => void 0, resolveShading = () => void 0) {
+		state.resolve = resolve;
+		state.resolveGraphicsState = resolveGraphicsState;
+		state.resolveShading = resolveShading;
+		visitContentTokens(bytes, (operator, operands) => handlers[operator]?.(state, operands));
+	} };
+}
+function recordPatternPaintedBounds(bytes, resolve, bounds, resolveGraphicsState = () => void 0, resolveShading = () => void 0, shadingBounds = /* @__PURE__ */ new WeakMap()) {
+	createPaintedBoundsTracker(bounds, shadingBounds).feed(bytes, resolve, resolveGraphicsState, resolveShading);
+}
+//#endregion
+export { createPaintedBoundsTracker, recordPatternPaintedBounds, unionRect };

package/dist/press/pattern-path.js

@@ -0,0 +1,102 @@
+import { applyAffine } from "./affine.js";
+//#region src/press/pattern-path.ts
+function includePoint(box, x, y) {
+	if (!box) return {
+		x0: x,
+		y0: y,
+		x1: x,
+		y1: y
+	};
+	return {
+		x0: Math.min(box.x0, x),
+		y0: Math.min(box.y0, y),
+		x1: Math.max(box.x1, x),
+		y1: Math.max(box.y1, y)
+	};
+}
+function addPoint(path, x, y) {
+	const point = {
+		x,
+		y
+	};
+	path.box = includePoint(path.box, x, y);
+	path.current = point;
+	return point;
+}
+function deviceBox(box, ctm) {
+	const corners = [
+		applyAffine(ctm, box.x0, box.y0),
+		applyAffine(ctm, box.x1, box.y0),
+		applyAffine(ctm, box.x0, box.y1),
+		applyAffine(ctm, box.x1, box.y1)
+	];
+	const xs = corners.map((point) => point.x);
+	const ys = corners.map((point) => point.y);
+	const x0 = Math.min(...xs);
+	const y0 = Math.min(...ys);
+	const x1 = Math.max(...xs);
+	const y1 = Math.max(...ys);
+	if (!Number.isFinite(x0) || !Number.isFinite(y0) || !Number.isFinite(x1) || !Number.isFinite(y1)) return void 0;
+	return {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+function closePath(path) {
+	if (path.start) addPoint(path, path.start.x, path.start.y);
+}
+function clearPath(path) {
+	path.box = void 0;
+	path.current = void 0;
+	path.start = void 0;
+}
+function moveTo(path, x, y) {
+	path.start = addPoint(path, x, y);
+}
+function lineTo(path, x, y) {
+	addPoint(path, x, y);
+}
+function curveTo(path, values) {
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+	addPoint(path, values[4] ?? 0, values[5] ?? 0);
+}
+function curveV(path, values) {
+	if (!path.current) return;
+	addPoint(path, path.current.x, path.current.y);
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+}
+function curveY(path, values) {
+	addPoint(path, values[0] ?? 0, values[1] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+	addPoint(path, values[2] ?? 0, values[3] ?? 0);
+}
+function rectTo(path, x, y, width, height) {
+	addPoint(path, x, y);
+	path.start = {
+		x,
+		y
+	};
+	addPoint(path, x + width, y);
+	addPoint(path, x + width, y + height);
+	addPoint(path, x, y + height);
+	addPoint(path, x, y);
+}
+function intersectRect(left, right) {
+	const x0 = Math.max(left.x0, right.x0);
+	const y0 = Math.max(left.y0, right.y0);
+	const x1 = Math.min(left.x1, right.x1);
+	const y1 = Math.min(left.y1, right.y1);
+	if (!(x0 < x1) || !(y0 < y1)) return void 0;
+	return {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+//#endregion
+export { addPoint, clearPath, closePath, curveTo, curveV, curveY, deviceBox, includePoint, intersectRect, lineTo, moveTo, rectTo };

package/dist/press/policy.js

@@ -45,7 +45,13 @@ function groupAction(kind, label, maskSource) {
 	if (label === "missing" || label === "DeviceRGB") return decision("convert", supported);
 	return decision("refuse", supported);
 }
-function shadingAction(kind, type) {
+function shadingAction(kind, type, functionType) {
+	if (type === 1) {
+		const supported = "ShadingType 1 in an RGB space with FunctionType 4, or DeviceCMYK";
+		if (kind === "cmyk") return decision("keep", supported);
+		if (kind === "rgb" && functionType === 4) return decision("convert", supported);
+		return decision("refuse", supported);
+	}
 	const supported = "ShadingType 2 or 3 in an RGB or DeviceCMYK color space";
 	if (type !== 2 && type !== 3) return decision("refuse", supported);
 	if (kind === "rgb") return decision("convert", supported);

package/dist/press/report.js

@@ -1,7 +1,7 @@
 import { RenderRefusedError } from "../errors.js";
 import { groupAction, shadingAction } from "./policy.js";
 import { inspectContent } from "./content.js";
-import { decodeContent, nameOf, numberOf, resolvedColorSpace } from "./pdf-objects.js";
+import { decodeContent, dictionaryOf, nameOf, numberOf, resolvedColorSpace } from "./pdf-objects.js";
 import { walkPressGraph } from "./visitor.js";
 import { PDFDict, PDFDocument, PDFName, PDFRef } from "pdf-lib";
 //#region src/press/report.ts
@@ -32,9 +32,18 @@ function inspectShading(state, shading) {
 	if (state.shadings.has(shading)) return false;
 	state.shadings.add(shading);
 	const type = numberOf(shading, "ShadingType");
+	const fn = dictionaryOf(resolved(state, shading.get(key("Function"))));
+	const functionType = fn ? numberOf(fn, "FunctionType") : void 0;
 	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
-	const policy = shadingAction(space.kind, type);
-	if (policy.action === "refuse" || policy.action === "convert") refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
+	const policy = shadingAction(space.kind, type, functionType);
+	if (policy.action !== "keep") {
+		if (type === 1) refuse(`ShadingType 1 FunctionType ${functionType ?? "missing"} color space ${space.label}`, policy.supported);
+		refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
+	}
+	if (type === 1) {
+		state.report.sampledShadings++;
+		return false;
+	}
 	return true;
 }
 function inspectGroup(state, owner, maskSource) {
@@ -58,6 +67,7 @@ async function inspectPressPdf(bytes) {
 			fills: 0,
 			strokes: 0,
 			gradientStops: 0,
+			sampledShadings: 0,
 			groups: 0
 		},
 		shadings: /* @__PURE__ */ new WeakSet()