@segnavia/render 0.1.0 → 0.3.0

package/dist/press/calculator.js

@@ -0,0 +1,130 @@
+import { applyOperator, calculatorRefuse, classifiedOperatorName, pushStack } from "./calculator-ops.js";
+//#region src/press/calculator.ts
+const MAX_CALCULATOR_PROGRAM_BYTES = 8192;
+const MAX_CALCULATOR_OPERATORS = 4096;
+const NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/;
+const OPERATOR = /^[A-Za-z][A-Za-z0-9]*/;
+const whitespace = (character) => character !== void 0 && /[\0\t\n\f\r ]/.test(character);
+function skipComment(source, at) {
+	let cursor = at + 1;
+	while (cursor < source.length && source[cursor] !== "\r" && source[cursor] !== "\n") cursor++;
+	return cursor;
+}
+function skipSpace(source, at) {
+	let cursor = at;
+	while (cursor < source.length) if (whitespace(source[cursor])) cursor++;
+	else if (source[cursor] === "%") cursor = skipComment(source, cursor);
+	else break;
+	return cursor;
+}
+function parseNumber(source, at) {
+	const match = NUMBER.exec(source.slice(at));
+	if (!match) return calculatorRefuse("calculator number", "a PDF calculator number");
+	const raw = match[0];
+	const value = Number(raw);
+	if (!Number.isFinite(value)) return calculatorRefuse("calculator number", "a finite PDF calculator number");
+	return {
+		end: at + raw.length,
+		op: {
+			kind: "number",
+			value,
+			int: !/[.eE]/.test(raw)
+		}
+	};
+}
+function parseOperator(source, at) {
+	const match = OPERATOR.exec(source.slice(at));
+	if (!match) return calculatorRefuse(`calculator token ${classifiedOperatorName(source[at] ?? "other")}`, "a PDF calculator operator, number, or procedure");
+	return {
+		end: at + match[0].length,
+		op: {
+			kind: "operator",
+			name: match[0]
+		}
+	};
+}
+function parseProcedure(source, at, depth) {
+	if (depth > 32) return calculatorRefuse(`calculator procedure nesting over 32`, `at most 32 levels`);
+	const body = [];
+	let cursor = skipSpace(source, at + 1);
+	while (cursor < source.length && source[cursor] !== "}") {
+		const parsed = parseToken(source, cursor, depth + 1);
+		body.push(parsed.op);
+		cursor = skipSpace(source, parsed.end);
+	}
+	if (cursor >= source.length) return calculatorRefuse("calculator truncated procedure", "a closing }");
+	return {
+		end: cursor + 1,
+		op: {
+			kind: "procedure",
+			body
+		}
+	};
+}
+function parseToken(source, at, depth) {
+	const character = source[at];
+	if (character === "{") return parseProcedure(source, at, depth);
+	if (character === "+" || character === "-" || character === "." || character !== void 0 && character >= "0" && character <= "9") return parseNumber(source, at);
+	return parseOperator(source, at);
+}
+function parseCalculator(source) {
+	if (source.length > 8192) calculatorRefuse(`calculator program length ${source.length}`, `at most ${MAX_CALCULATOR_PROGRAM_BYTES} bytes`);
+	const tokens = [];
+	let cursor = skipSpace(source, 0);
+	while (cursor < source.length) {
+		const parsed = parseToken(source, cursor, 1);
+		tokens.push(parsed.op);
+		cursor = skipSpace(source, parsed.end);
+	}
+	if (tokens.length === 1 && tokens[0]?.kind === "procedure") return tokens[0].body;
+	return tokens;
+}
+function exec(body, state) {
+	for (const token of body) {
+		if (token.kind === "number") {
+			pushStack(state, {
+				kind: "n",
+				value: token.value,
+				int: token.int
+			});
+			continue;
+		}
+		if (token.kind === "procedure") {
+			pushStack(state, {
+				kind: "p",
+				body: token.body
+			});
+			continue;
+		}
+		state.count++;
+		if (state.count > 4096) calculatorRefuse(`calculator operators ${state.count}`, `at most ${MAX_CALCULATOR_OPERATORS} operators per evaluation`);
+		applyOperator(token.name, state, (inner) => exec(inner, state));
+	}
+}
+function runCalculator(program, inputs) {
+	const state = {
+		count: 0,
+		stack: []
+	};
+	for (const value of inputs) pushStack(state, {
+		kind: "n",
+		value,
+		int: Number.isInteger(value)
+	});
+	exec(program, state);
+	return state;
+}
+function staticOperatorCount(program) {
+	let count = 0;
+	for (const token of program) if (token.kind === "operator") count++;
+	else if (token.kind === "procedure") count += staticOperatorCount(token.body);
+	return count;
+}
+function evaluateCalculator(program, inputs) {
+	return runCalculator(program, inputs).stack.map((value) => {
+		if (value.kind !== "n") return calculatorRefuse("calculator output type", "numbers");
+		return value.value;
+	});
+}
+//#endregion
+export { MAX_CALCULATOR_OPERATORS, MAX_CALCULATOR_PROGRAM_BYTES, evaluateCalculator, parseCalculator, staticOperatorCount };

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,292 @@
+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 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);
+}
+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, visitContentOperations, visitContentTokens };