@segnavia/render 0.0.0-stage → 0.2.0

package/dist/press/adapter.js

@@ -0,0 +1,145 @@
+import { RenderRefusedError } from "../errors.js";
+import { readProfile } from "../color/profile.js";
+import { cachedPressColor } from "./color-policy.js";
+import { groupAction, shadingAction } from "./policy.js";
+import { rewriteContent } from "./content.js";
+import { arrayNumbers, decodeContent, nameOf, numberOf, replaceArray, resolvedColorSpace } from "./pdf-objects.js";
+import { walkPressGraph } from "./visitor.js";
+import { inspectPressPdf } from "./report.js";
+import { PDFDict, PDFDocument, PDFName, PDFRef, PDFString } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/press/adapter.ts
+const key = (name) => PDFName.of(name);
+const refuse = (found, supported) => {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+};
+const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
+function convertFunction(state, fn, policy) {
+	if (policy.action === "refuse") refuse(policy.found, policy.supported);
+	if (!fn) return;
+	if (numberOf(fn, "FunctionType") === 2) {
+		for (const name of ["C0", "C1"]) replaceArray(fn, name, state.convert(arrayNumbers(fn, name, 3)));
+		if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+			0,
+			1,
+			0,
+			1,
+			0,
+			1,
+			0,
+			1
+		]);
+		state.totals.gradientStops += 2;
+		return;
+	}
+	if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+		0,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1
+	]);
+}
+function convertShading(state, shading) {
+	if (state.seenShadings.has(shading)) return false;
+	state.seenShadings.add(shading);
+	const type = numberOf(shading, "ShadingType");
+	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
+	const policy = shadingAction(space.kind, type);
+	if (policy.action === "refuse") refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
+	if (policy.action === "keep") return false;
+	if (shading.has(key("Background"))) replaceArray(shading, "Background", state.convert(arrayNumbers(shading, "Background", 3)));
+	shading.set(key("ColorSpace"), key("DeviceCMYK"));
+	return true;
+}
+function convertGroup(state, owner, maskSource) {
+	const group = owner.lookupMaybe(key("Group"), PDFDict);
+	if (!group || nameOf(group.get(key("S"))) !== "Transparency" || state.seenGroups.has(group)) return;
+	state.seenGroups.add(group);
+	const space = resolvedColorSpace(state.document, resolved(state, group.get(key("CS"))));
+	const policy = groupAction(space.kind, space.label, maskSource);
+	if (policy.action === "refuse") refuse(`transparency group color space ${space.label}`, policy.supported);
+	if (policy.action === "convert") {
+		group.set(key("CS"), key("DeviceCMYK"));
+		state.totals.groups++;
+	}
+}
+function streamDictionary(stream) {
+	const dictionary = { Filter: key("FlateDecode") };
+	for (const [name, value] of stream.dict.entries()) {
+		const label = name.toString().slice(1);
+		if (![
+			"Filter",
+			"DecodeParms",
+			"Length"
+		].includes(label)) dictionary[label] = value;
+	}
+	return dictionary;
+}
+function convertContent(state, object, stream, setDirect) {
+	const rewritten = rewriteContent(decodeContent(stream, state.budget), state.convert);
+	state.totals.fills += rewritten.counts.fills;
+	state.totals.strokes += rewritten.counts.strokes;
+	const replacement = state.document.context.stream(deflateSync(rewritten.bytes), streamDictionary(stream));
+	const reference = object instanceof PDFRef ? object : state.document.context.getObjectRef(object);
+	if (reference) state.document.context.assign(reference, replacement);
+	else setDirect(replacement);
+}
+function newState(document, profile) {
+	return {
+		budget: { decodedBytes: 0 },
+		convert: cachedPressColor(profile),
+		document,
+		seenGroups: /* @__PURE__ */ new WeakSet(),
+		seenShadings: /* @__PURE__ */ new WeakSet(),
+		totals: {
+			fills: 0,
+			strokes: 0,
+			gradientStops: 0,
+			groups: 0
+		}
+	};
+}
+function rewritePressDocument(document, profile) {
+	const state = newState(document, profile);
+	walkPressGraph(document, {
+		content: (object, stream, replace) => convertContent(state, object, stream, replace),
+		function: (fn, decision) => convertFunction(state, fn, decision),
+		group: (owner, _stream, maskSource) => convertGroup(state, owner, maskSource),
+		image: () => void 0,
+		shading: (shading) => convertShading(state, shading)
+	});
+	return state.totals;
+}
+function addOutputIntent(document, profile) {
+	const profileRef = document.context.register(document.context.stream(profile, { N: 4 }));
+	const intentRef = document.context.register(document.context.obj({
+		Type: "OutputIntent",
+		S: "GTS_PDFX",
+		OutputConditionIdentifier: PDFString.of("Custom"),
+		DestOutputProfile: profileRef
+	}));
+	document.catalog.set(key("OutputIntents"), document.context.obj([intentRef]));
+}
+async function rewritePressPdf(bytes, profileBytes) {
+	try {
+		const profile = readProfile(profileBytes);
+		if (profile.colorSpace !== "CMYK") refuse(`press profile color space ${profile.colorSpace}`, "CMYK");
+		const document = await PDFDocument.load(bytes, { updateMetadata: false });
+		rewritePressDocument(document, profile);
+		addOutputIntent(document, profileBytes);
+		const output = await document.save({ useObjectStreams: false });
+		return {
+			bytes: output,
+			report: await inspectPressPdf(output)
+		};
+	} catch (error) {
+		if (error instanceof RenderRefusedError) throw error;
+		throw new RenderRefusedError("The PDF has unsupported malformed structure; supported: a valid PDF produced by the renderer.");
+	}
+}
+//#endregion
+export { rewritePressDocument, rewritePressPdf };

package/dist/press/color-policy.js

@@ -0,0 +1,31 @@
+import { toPress } from "../color/engine.js";
+//#region src/press/color-policy.ts
+const NEUTRAL_TOLERANCE = .001;
+function pressColor(profile, rgb) {
+	const [red, green, blue] = rgb;
+	if (Math.max(red, green, blue) - Math.min(red, green, blue) <= NEUTRAL_TOLERANCE) return [
+		0,
+		0,
+		0,
+		1 - red
+	];
+	return toPress(profile, rgb);
+}
+function formatPdfNumber(value) {
+	const rounded = Math.round(value * 1e6) / 1e6;
+	if (Object.is(rounded, -0)) return "0";
+	return rounded.toFixed(6).replace(/(?:\.0+|(?<=\.[0-9]*?)0+)$/, "");
+}
+function cachedPressColor(profile) {
+	const cache = /* @__PURE__ */ new Map();
+	return (rgb) => {
+		const key = rgb.join(",");
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const converted = pressColor(profile, rgb);
+		cache.set(key, converted);
+		return converted;
+	};
+}
+//#endregion
+export { cachedPressColor, formatPdfNumber, pressColor };

package/dist/press/content.js

@@ -0,0 +1,269 @@
+import { RenderRefusedError } from "../errors.js";
+import { formatPdfNumber } from "./color-policy.js";
+import { colorSpaceLabel, contentOperatorAction, inlineImageAction, isContentColorOperator } from "./policy.js";
+const decoder = new TextDecoder("latin1");
+const encoder = new TextEncoder();
+const numberPattern = /^[+-]?(?:\d+\.?\d*|\.\d+)$/;
+const whitespace = (character) => character !== void 0 && /[\0\t\n\f\r ]/.test(character);
+const delimiter = (character) => character !== void 0 && /[()<>{}[\]/%]/.test(character);
+function refusal(found, supported) {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+}
+function skipComment(source, at) {
+	let cursor = at + 1;
+	while (cursor < source.length && source[cursor] !== "\r" && source[cursor] !== "\n") cursor++;
+	return cursor;
+}
+function skipLiteral(source, at) {
+	let cursor = at + 1;
+	let depth = 1;
+	while (cursor < source.length) {
+		const character = source[cursor];
+		if (character === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (character === "(" && ++depth > 64) refusal(`literal string nesting over 64`, `at most 64 levels`);
+		if (character === ")" && --depth === 0) return cursor + 1;
+		cursor++;
+	}
+	return refusal("truncated literal string", "a closing parenthesis");
+}
+function skipHex(source, at) {
+	const end = source.indexOf(">", at + 1);
+	if (end < 0) return refusal("truncated hex string", "a closing >");
+	return end + 1;
+}
+function skipComposite(source, at, dictionary, depth = 1) {
+	if (depth > 64) refusal(`dictionary or array nesting over 64`, `at most 64 levels`);
+	let cursor = at + (dictionary ? 2 : 1);
+	while (cursor < source.length) {
+		const character = source[cursor];
+		const nested = skipCompositeConstruct(source, cursor, depth);
+		if (nested !== void 0) {
+			cursor = nested;
+			continue;
+		}
+		if (dictionary && character === ">" && source[cursor + 1] === ">") return cursor + 2;
+		if (!dictionary && character === "]") return cursor + 1;
+		cursor++;
+	}
+	return refusal(`truncated ${dictionary ? "dictionary" : "array"}`, dictionary ? "a closing >>" : "a closing ]");
+}
+function skipCompositeConstruct(source, cursor, depth) {
+	const character = source[cursor];
+	if (whitespace(character)) return cursor + 1;
+	if (character === "%") return skipComment(source, cursor);
+	if (character === "(") return skipLiteral(source, cursor);
+	if (character === "<") return source[cursor + 1] === "<" ? skipComposite(source, cursor, true, depth + 1) : skipHex(source, cursor);
+	if (character === "[") return skipComposite(source, cursor, false, depth + 1);
+}
+function readToken(source, cursor) {
+	const start = cursor;
+	if (source[cursor] === "/") {
+		cursor++;
+		while (cursor < source.length && !whitespace(source[cursor]) && !delimiter(source[cursor])) cursor++;
+		return {
+			start,
+			end: cursor,
+			raw: source.slice(start, cursor),
+			kind: "name"
+		};
+	}
+	if (delimiter(source[cursor])) return void 0;
+	while (cursor < source.length && !whitespace(source[cursor]) && !delimiter(source[cursor])) cursor++;
+	const raw = source.slice(start, cursor);
+	return {
+		start,
+		end: cursor,
+		raw,
+		kind: numberPattern.test(raw) ? "number" : "operator"
+	};
+}
+function inlineHeaderToken(source, at) {
+	let cursor = at;
+	while (whitespace(source[cursor])) cursor++;
+	if (source[cursor] === "[") {
+		const end = skipComposite(source, cursor, false);
+		return {
+			end,
+			raw: source.slice(cursor, end)
+		};
+	}
+	const token = readToken(source, cursor);
+	return token ? {
+		end: token.end,
+		raw: token.raw
+	} : {
+		end: cursor + 1,
+		raw: ""
+	};
+}
+function inlineHeader(source, at) {
+	let cursor = at;
+	let name = "";
+	const values = /* @__PURE__ */ new Map();
+	while (cursor < source.length) {
+		const token = inlineHeaderToken(source, cursor);
+		cursor = token.end;
+		if (token.raw === "ID") return {
+			colorSpace: values.get("/CS") ?? values.get("/ColorSpace"),
+			id: cursor,
+			imageMask: values.get("/IM") === "true" || values.get("/ImageMask") === "true"
+		};
+		if (!token.raw) continue;
+		if (!name) name = token.raw;
+		else {
+			values.set(name, token.raw);
+			name = "";
+		}
+	}
+	return refusal("truncated BI operator", "an ID and EI pair");
+}
+function inlineImageEnd(source, at) {
+	const { colorSpace, id, imageMask } = inlineHeader(source, at);
+	const match = /[\0\t\n\f\r ]EI(?=[\0\t\n\f\r ()<>[\]{}/%]|$)/g;
+	match.lastIndex = id;
+	const end = match.exec(source);
+	if (!end) return refusal("truncated BI operator", "an ID and EI pair");
+	const name = colorSpace?.startsWith("/") ? colorSpace.slice(1) : void 0;
+	const policy = inlineImageAction(name, imageMask);
+	if (policy.action === "refuse") refusal(`BI operator with color space ${policy.label}`, policy.supported);
+	return end.index + end[0].length;
+}
+function skippedConstruct(source, cursor) {
+	const character = source[cursor];
+	if (whitespace(character)) return cursor + 1;
+	if (character === "%") return skipComment(source, cursor);
+	if (character === "(") return skipLiteral(source, cursor);
+	if (character === "<") return source[cursor + 1] === "<" ? skipComposite(source, cursor, true) : skipHex(source, cursor);
+	if (character === "[") return skipComposite(source, cursor, false);
+}
+function numeric(operands, count, operator) {
+	if (operands.length !== count || operands.some((token) => token.kind !== "number")) refusal(`${operator} operator operands`, `${count} numeric operands`);
+	return operands.map((token) => Number(token.raw));
+}
+function replacement(token, operands, values) {
+	const operator = token.raw === "rg" || token.raw === "g" ? "k" : "K";
+	return {
+		start: operands[0]?.start ?? token.start,
+		end: token.end,
+		text: `${values.map(formatPdfNumber).join(" ")} ${operator}`
+	};
+}
+function replaceRgb(token, operands, convert, counts) {
+	const [red = 0, green = 0, blue = 0] = numeric(operands, 3, token.raw);
+	counts[token.raw === "rg" ? "fills" : "strokes"]++;
+	return replacement(token, operands, convert([
+		red,
+		green,
+		blue
+	]));
+}
+function replaceGray(token, operands, convert, counts) {
+	const [gray = 0] = numeric(operands, 1, token.raw);
+	counts[token.raw === "g" ? "fills" : "strokes"]++;
+	return replacement(token, operands, convert([
+		gray,
+		gray,
+		gray
+	]));
+}
+function validateSpace(token, operands) {
+	if (operands.length !== 1 || operands[0]?.kind !== "name") refusal(`${token.raw} operator operands`, "one color space name");
+	const name = operands[0].raw.slice(1);
+	const policy = contentOperatorAction(token.raw, false, name);
+	if (policy.action === "refuse") refusal(`${token.raw} operator selecting ${colorSpaceLabel({ name })}`, policy.supported);
+}
+function enforceOperatorPolicy(token, operands, policy) {
+	if (policy.action !== "refuse") return;
+	const operator = token.raw;
+	if (operator === "cs" || operator === "CS") {
+		validateSpace(token, operands);
+		return;
+	}
+	if (operator === "sc" || operator === "SC" || operator === "scn" || operator === "SCN") refusal(`${operator} operator with numeric operands`, policy.supported);
+	refusal(`${operator === "g" || operator === "G" ? "gray" : "RGB"} color operator ${operator} after conversion`, policy.supported);
+}
+function colorOperator(token, operands, convert, counts, inspect) {
+	const operator = token.raw;
+	if (!isContentColorOperator(operator)) return void 0;
+	const patternName = operands.length === 1 && operands[0]?.kind === "name";
+	enforceOperatorPolicy(token, operands, contentOperatorAction(operator, inspect, void 0, patternName));
+	if (operator === "rg" || operator === "RG") return replaceRgb(token, operands, convert, counts);
+	if (operator === "g" || operator === "G") return replaceGray(token, operands, convert, counts);
+	if (operator === "cs" || operator === "CS") validateSpace(token, operands);
+	else if (operator === "k" || operator === "K") {
+		numeric(operands, 4, operator);
+		counts[operator === "k" ? "fills" : "strokes"]++;
+	}
+}
+function scan(source, convert, inspect, visit, operatorVisit) {
+	const counts = {
+		fills: 0,
+		strokes: 0
+	};
+	let operands = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const skipped = skippedConstruct(source, cursor);
+		if (skipped !== void 0) {
+			cursor = skipped;
+			continue;
+		}
+		const token = readToken(source, cursor);
+		if (!token) {
+			cursor++;
+			continue;
+		}
+		cursor = token.end;
+		if (token.raw === "BI") {
+			cursor = inlineImageEnd(source, cursor);
+			operands = [];
+		} else if (token.kind === "operator") {
+			operatorVisit?.(token, operands);
+			const found = colorOperator(token, operands, convert, counts, inspect);
+			if (found) visit?.(found);
+			operands = [];
+		} else {
+			if (operands.length >= 32) refusal(`more than 32 operands before an operator`, `at most 32 operands`);
+			operands.push(token);
+		}
+	}
+	return counts;
+}
+function inspectContent(bytes) {
+	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", "CMYK operators"), true);
+}
+function rewriteContent(bytes, convert) {
+	const source = decoder.decode(bytes);
+	let outputLength = bytes.length;
+	let changed = false;
+	const counts = scan(source, convert, false, (found) => {
+		changed = true;
+		outputLength += encoder.encode(found.text).length - (found.end - found.start);
+	});
+	if (!changed) return {
+		bytes,
+		counts
+	};
+	const output = new Uint8Array(outputLength);
+	let inputAt = 0;
+	let outputAt = 0;
+	scan(source, convert, false, (found) => {
+		const untouched = bytes.subarray(inputAt, found.start);
+		output.set(untouched, outputAt);
+		outputAt += untouched.length;
+		const inserted = encoder.encode(found.text);
+		output.set(inserted, outputAt);
+		outputAt += inserted.length;
+		inputAt = found.end;
+	});
+	output.set(bytes.subarray(inputAt), outputAt);
+	return {
+		bytes: output,
+		counts
+	};
+}
+//#endregion
+export { inspectContent, rewriteContent };

package/dist/press/pdf-objects.js

@@ -0,0 +1,88 @@
+import { RenderRefusedError } from "../errors.js";
+import { colorSpaceKind, colorSpaceLabel, contentFilter } from "./policy.js";
+import { PDFArray, PDFDict, PDFName, PDFNumber, PDFRawStream, PDFRef, PDFStream } from "pdf-lib";
+import { inflateSync } from "node:zlib";
+//#region src/press/pdf-objects.ts
+const MAX_CONTENT_BYTES = 33554432;
+const MAX_DOCUMENT_CONTENT_BYTES = 134217728;
+const nameOf = (object) => object instanceof PDFName ? object.toString().slice(1) : void 0;
+function dictionaryOf(object) {
+	if (object instanceof PDFDict) return object;
+	if (object instanceof PDFStream) return object.dict;
+}
+function numberOf(dictionary, key) {
+	return dictionary.lookupMaybe(PDFName.of(key), PDFNumber)?.asNumber();
+}
+function arrayNumbers(dictionary, key, count) {
+	const array = dictionary.lookupMaybe(PDFName.of(key), PDFArray);
+	if (!array || array.size() !== count) throw new Error(`PDF ${key} has unsupported length ${array?.size() ?? "missing"}; supported: ${count} numbers`);
+	return Array.from({ length: count }, (_, index) => {
+		const value = array.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0) throw new Error(`PDF ${key} has unsupported non-number at index ${index}; supported: ${count} numbers`);
+		return value;
+	});
+}
+function replaceArray(dictionary, key, values) {
+	const array = dictionary.context.obj(values);
+	dictionary.set(PDFName.of(key), array);
+}
+function rawStreamOf(object) {
+	return object instanceof PDFRawStream ? object : void 0;
+}
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function colorSpaceValue(document, object) {
+	const value = resolved(document, object);
+	const name = nameOf(value);
+	if (name) return { name };
+	if (!(value instanceof PDFArray)) return void 0;
+	const family = nameOf(resolved(document, value.get(0)));
+	if (family === "ICCBased") return {
+		family,
+		channels: rawStreamOf(resolved(document, value.get(1)))?.dict.lookupMaybe(PDFName.of("N"), PDFNumber)?.asNumber()
+	};
+	if (family === "Indexed") return {
+		family,
+		base: colorSpaceValue(document, value.get(1))
+	};
+	return { family };
+}
+function resolvedColorSpace(document, object) {
+	const value = colorSpaceValue(document, object);
+	return {
+		kind: colorSpaceKind(value),
+		label: object ? colorSpaceLabel(value) : "missing"
+	};
+}
+function filterNames(filter) {
+	if (!filter) return void 0;
+	const direct = nameOf(filter);
+	if (direct) return [direct];
+	if (!(filter instanceof PDFArray)) return [];
+	const names = [];
+	for (let index = 0; index < filter.size(); index++) {
+		const name = nameOf(filter.get(index));
+		if (!name) return [];
+		names.push(name);
+	}
+	return names;
+}
+function decodeContent(stream, budget) {
+	const filter = stream.dict.get(PDFName.of("Filter"));
+	const decision = contentFilter(filterNames(filter));
+	if (decision.action === "refuse") throw new RenderRefusedError(`The PDF has unsupported content stream filter other; supported: ${decision.supported}.`);
+	let decoded;
+	try {
+		decoded = decision.encoding === "compressed" ? inflateSync(stream.contents, { maxOutputLength: MAX_CONTENT_BYTES }) : stream.contents;
+	} catch (error) {
+		if (error.code === "ERR_BUFFER_TOO_LARGE") throw new RenderRefusedError(`The PDF has unsupported decoded content stream longer than ${MAX_CONTENT_BYTES} bytes; supported: at most ${MAX_CONTENT_BYTES} bytes.`);
+		throw new RenderRefusedError(`The PDF has unsupported content stream decode failure; supported: a valid FlateDecode or unfiltered stream.`);
+	}
+	if (decoded.byteLength > 33554432) throw new RenderRefusedError(`The PDF has unsupported decoded content stream length ${decoded.byteLength}; supported: at most ${MAX_CONTENT_BYTES} bytes.`);
+	if (budget) {
+		budget.decodedBytes += decoded.byteLength;
+		if (budget.decodedBytes > 134217728) throw new RenderRefusedError(`The PDF has unsupported total decoded content length ${budget.decodedBytes}; supported: at most ${MAX_DOCUMENT_CONTENT_BYTES} bytes.`);
+	}
+	return decoded;
+}
+//#endregion
+export { MAX_CONTENT_BYTES, MAX_DOCUMENT_CONTENT_BYTES, arrayNumbers, decodeContent, dictionaryOf, nameOf, numberOf, rawStreamOf, replaceArray, resolvedColorSpace };

package/dist/press/policy.js

@@ -0,0 +1,120 @@
+//#region src/press/policy.ts
+function colorSpaceKind(value) {
+	if (value?.name === "DeviceRGB" || value?.name === "CalRGB") return "rgb";
+	if (value?.name === "DeviceGray") return "gray";
+	if (value?.name === "DeviceCMYK") return "cmyk";
+	if (value?.family === "ICCBased") return value.channels === 3 ? "rgb" : value.channels === 1 ? "gray" : value.channels === 4 ? "cmyk" : "other";
+	if (value?.family === "Indexed") return colorSpaceKind(value.base);
+	return "other";
+}
+function colorSpaceLabel(value) {
+	const label = value?.name ?? value?.family;
+	if (!label) return "missing";
+	return [
+		"DeviceRGB",
+		"DeviceGray",
+		"DeviceCMYK",
+		"CalRGB",
+		"ICCBased",
+		"Indexed",
+		"Pattern"
+	].includes(label) ? label : "other";
+}
+const decision = (action, supported) => ({
+	action,
+	supported
+});
+function contentFilter(names) {
+	const supported = `FlateDecode or no filter`;
+	if (!names) return {
+		...decision("keep", supported),
+		encoding: "none"
+	};
+	if (names.length === 1 && names[0] === "FlateDecode") return {
+		...decision("keep", supported),
+		encoding: "compressed"
+	};
+	return {
+		...decision("refuse", supported),
+		encoding: "unsupported"
+	};
+}
+function groupAction(kind, label, maskSource) {
+	const supported = "DeviceCMYK, DeviceGray, DeviceRGB on a mask source, or no declared space";
+	if (kind === "gray" || kind === "cmyk" || maskSource && (label === "DeviceRGB" || label === "missing")) return decision("keep", supported);
+	if (label === "missing" || label === "DeviceRGB") return decision("convert", supported);
+	return decision("refuse", supported);
+}
+function shadingAction(kind, type) {
+	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);
+	if (kind === "cmyk") return decision("keep", supported);
+	return decision("refuse", supported);
+}
+function shadingFunctionAction(type, dictionary, functions) {
+	if (!dictionary) return {
+		...decision("refuse", "FunctionType 2 or 3"),
+		found: "shading function other"
+	};
+	if (type !== 2 && type !== 3) return {
+		...decision("refuse", "FunctionType 2 or 3"),
+		found: `shading FunctionType ${type ?? "missing"}`
+	};
+	if (type === 3 && !functions) return {
+		...decision("refuse", "a Functions array"),
+		found: "FunctionType 3 Functions missing"
+	};
+	return {
+		...decision("keep", "FunctionType 2 or 3"),
+		found: `shading FunctionType ${type}`
+	};
+}
+const inlineNames = {
+	G: { name: "DeviceGray" },
+	DeviceGray: { name: "DeviceGray" },
+	RGB: { name: "DeviceRGB" },
+	DeviceRGB: { name: "DeviceRGB" },
+	CMYK: { name: "DeviceCMYK" },
+	DeviceCMYK: { name: "DeviceCMYK" },
+	I: { family: "Indexed" },
+	Indexed: { family: "Indexed" },
+	CalRGB: { name: "CalRGB" }
+};
+function inlineImageAction(name, imageMask) {
+	const value = name ? inlineNames[name] ?? { name } : void 0;
+	const kind = colorSpaceKind(value);
+	return {
+		...decision(imageMask || kind === "gray" || kind === "cmyk" ? "keep" : "refuse", "an image mask, DeviceGray, or DeviceCMYK"),
+		kind,
+		label: colorSpaceLabel(value)
+	};
+}
+function contentColorSpaceAction(name) {
+	return decision(name === "Pattern" || name === "DeviceCMYK" ? "keep" : "refuse", "Pattern or DeviceCMYK");
+}
+const colorOperators = [
+	"rg",
+	"RG",
+	"g",
+	"G",
+	"k",
+	"K",
+	"sc",
+	"SC",
+	"scn",
+	"SCN",
+	"cs",
+	"CS"
+];
+function isContentColorOperator(operator) {
+	return colorOperators.includes(operator);
+}
+function contentOperatorAction(operator, inspect, selectedSpace, patternName = false) {
+	if (operator === "rg" || operator === "RG" || operator === "g" || operator === "G") return decision(inspect ? "refuse" : "convert", inspect ? "CMYK operators" : "RGB or DeviceGray color operands");
+	if (operator === "k" || operator === "K") return decision("keep", "four CMYK operands");
+	if (operator === "cs" || operator === "CS") return contentColorSpaceAction(selectedSpace);
+	return decision((operator === "scn" || operator === "SCN") && patternName ? "keep" : "refuse", "a pattern name with scn or SCN");
+}
+//#endregion
+export { colorSpaceKind, colorSpaceLabel, contentColorSpaceAction, contentFilter, contentOperatorAction, groupAction, inlineImageAction, isContentColorOperator, shadingAction, shadingFunctionAction };