@segnavia/render 0.2.0 → 0.4.0

package/dist/press/adapter.js

@@ -1,12 +1,15 @@
 import { RenderRefusedError } from "../errors.js";
-import { readProfile } from "../color/profile.js";
-import { cachedPressColor } from "./color-policy.js";
+import { cachedPressColor, pressColor } 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 { arrayNumbers, decodeContent, dictionaryOf, nameOf, numberOf, replaceArray, resolvedColorSpace } from "./pdf-objects.js";
 import { walkPressGraph } from "./visitor.js";
+import "../effects/types.js";
+import { replaceType1Function, sampleDomainForUses, shadingDeviceMatrix, shadingDomainOf, shadingSampleGridForUses } from "./sample-shading.js";
+import { readProfile } from "../color/profile.js";
+import { createPaintedBoundsTracker, recordPatternPaintedBounds } from "./pattern-bounds.js";
 import { inspectPressPdf } from "./report.js";
-import { PDFDict, PDFDocument, PDFName, PDFRef, PDFString } from "pdf-lib";
+import { PDFDict, PDFDocument, PDFHexString, PDFName, PDFRef, PDFString } from "pdf-lib";
 import { deflateSync } from "node:zlib";
 //#region src/press/adapter.ts
 const key = (name) => PDFName.of(name);
@@ -43,16 +46,57 @@ function convertFunction(state, fn, policy) {
 		1
 	]);
 }
-function convertShading(state, shading) {
+function functionTypeOf(state, shading) {
+	const fn = dictionaryOf(resolved(state, shading.get(key("Function"))));
+	return fn ? numberOf(fn, "FunctionType") : void 0;
+}
+function indexShadingPattern(state, shading, pattern) {
+	if (!pattern) return false;
+	const list = state.shadingPatterns.get(shading) ?? [];
+	if (!list.includes(pattern)) list.push(pattern);
+	state.shadingPatterns.set(shading, list);
+	return false;
+}
+function shadingUses(state, shading, pattern) {
+	const patterns = [...state.shadingPatterns.get(shading) ?? []];
+	if (pattern && !patterns.includes(pattern)) patterns.push(pattern);
+	const uses = patterns.map((found) => ({
+		matrix: shadingDeviceMatrix(shading, found),
+		painted: state.painted.get(found),
+		pattern: found
+	}));
+	const shPaint = state.shadingPainted.get(shading);
+	if (shPaint !== void 0) uses.push({
+		matrix: shadingDeviceMatrix(shading, void 0),
+		painted: shPaint
+	});
+	return uses.filter((use) => use.painted !== void 0);
+}
+function convertType1Shading(state, shading, pattern) {
+	const uses = shadingUses(state, shading, pattern);
+	const domain = sampleDomainForUses(shadingDomainOf(shading), uses);
+	const matrices = uses.length > 0 ? uses.map((use) => use.matrix) : [shadingDeviceMatrix(shading, pattern)];
+	const size = shadingSampleGridForUses(domain, matrices);
+	replaceType1Function(state.document, shading, pattern, (rgb) => pressColor(state.profile, rgb), state.budget, void 0, domain, size);
+}
+function convertShading(state, shading, pattern) {
 	if (state.seenShadings.has(shading)) return false;
 	state.seenShadings.add(shading);
 	const type = numberOf(shading, "ShadingType");
+	const functionType = functionTypeOf(state, shading);
 	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);
+	const policy = shadingAction(space.kind, type, functionType);
+	if (policy.action === "refuse") {
+		if (type === 1) refuse(`ShadingType 1 FunctionType ${functionType ?? "missing"}`, policy.supported);
+		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"));
+	if (type === 1) {
+		convertType1Shading(state, shading, pattern);
+		return false;
+	}
 	return true;
 }
 function convertGroup(state, owner, maskSource) {
@@ -67,6 +111,47 @@ function convertGroup(state, owner, maskSource) {
 		state.totals.groups++;
 	}
 }
+function convertRuleCImage(state, image, width, height, dictionary) {
+	const source = decodeContent(image, state.budget);
+	if (source.length !== width * height * 3) refuse("effect image sample length", "three 8-bit RGB samples per pixel");
+	const converted = new Uint8Array(width * height * 4);
+	for (let pixel = 0; pixel < width * height; pixel++) {
+		const color = state.convert([
+			(source[pixel * 3] ?? 0) / 255,
+			(source[pixel * 3 + 1] ?? 0) / 255,
+			(source[pixel * 3 + 2] ?? 0) / 255
+		]);
+		for (let channel = 0; channel < 4; channel++) converted[pixel * 4 + channel] = Math.round(Math.max(0, Math.min(1, color[channel] ?? 0)) * 255);
+	}
+	dictionary.ColorSpace = key("DeviceCMYK");
+	const replacement = state.document.context.stream(deflateSync(converted), dictionary);
+	const reference = state.document.context.getObjectRef(image);
+	if (reference) state.document.context.assign(reference, replacement);
+}
+function convertEffectImage(state, image) {
+	if (!image.dict.has(key("SegnaviaGeneratedEffect")) || resolvedColorSpace(state.document, resolved(state, image.dict.get(key("ColorSpace")))).kind !== "rgb") return;
+	const width = numberOf(image.dict, "Width") ?? refuse("effect image Width missing", "a positive Width number");
+	const height = numberOf(image.dict, "Height") ?? refuse("effect image Height missing", "a positive Height number");
+	if (width <= 0 || height <= 0) refuse("effect image dimensions", "positive Width and Height numbers");
+	const dictionary = streamDictionary(image);
+	if (!image.dict.has(key("SegnaviaEffectColor"))) {
+		convertRuleCImage(state, image, width, height, dictionary);
+		return;
+	}
+	const source = arrayNumbers(image.dict, "SegnaviaEffectColor", 3);
+	const color = state.convert(source);
+	const palette = color.map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255));
+	dictionary.ColorSpace = state.document.context.obj([
+		"Indexed",
+		"DeviceCMYK",
+		0,
+		PDFHexString.of(Buffer.from(palette).toString("hex"))
+	]);
+	dictionary.SegnaviaEffectColor = state.document.context.obj(color);
+	const replacement = state.document.context.stream(image.contents, dictionary);
+	const reference = state.document.context.getObjectRef(image);
+	if (reference) state.document.context.assign(reference, replacement);
+}
 function streamDictionary(stream) {
 	const dictionary = { Filter: key("FlateDecode") };
 	for (const [name, value] of stream.dict.entries()) {
@@ -79,8 +164,30 @@ function streamDictionary(stream) {
 	}
 	return dictionary;
 }
+function resolveShadingPattern(state, resources, name) {
+	const patterns = resources?.lookupMaybe(key("Pattern"), PDFDict);
+	const found = dictionaryOf(resolved(state, patterns?.get(PDFName.of(name))));
+	if (found && numberOf(found, "PatternType") === 2) return found;
+}
+function resolveGraphicsState(state, resources, name) {
+	const states = resources?.lookupMaybe(key("ExtGState"), PDFDict);
+	return dictionaryOf(resolved(state, states?.get(PDFName.of(name))));
+}
+function resolveShadingResource(state, resources, name) {
+	const shadings = resources?.lookupMaybe(key("Shading"), PDFDict);
+	return dictionaryOf(resolved(state, shadings?.get(PDFName.of(name))));
+}
+function recordContentBounds(state, stream, resources, budget) {
+	const bytes = decodeContent(stream, budget);
+	const resolve = (name) => resolveShadingPattern(state, resources, name);
+	const resolveGs = (name) => resolveGraphicsState(state, resources, name);
+	const resolveShading = (name) => resolveShadingResource(state, resources, name);
+	if (state.sequence) state.sequence.feed(bytes, resolve, resolveGs, resolveShading);
+	else recordPatternPaintedBounds(bytes, resolve, state.painted, resolveGs, resolveShading, state.shadingPainted);
+}
 function convertContent(state, object, stream, setDirect) {
-	const rewritten = rewriteContent(decodeContent(stream, state.budget), state.convert);
+	const bytes = decodeContent(stream, state.budget);
+	const rewritten = rewriteContent(bytes, 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));
@@ -90,11 +197,19 @@ function convertContent(state, object, stream, setDirect) {
 }
 function newState(document, profile) {
 	return {
-		budget: { decodedBytes: 0 },
+		budget: {
+			calculatorOperations: 0,
+			decodedBytes: 0,
+			shadingSamples: 0
+		},
 		convert: cachedPressColor(profile),
 		document,
+		painted: /* @__PURE__ */ new WeakMap(),
+		profile,
 		seenGroups: /* @__PURE__ */ new WeakSet(),
 		seenShadings: /* @__PURE__ */ new WeakSet(),
+		shadingPainted: /* @__PURE__ */ new WeakMap(),
+		shadingPatterns: /* @__PURE__ */ new WeakMap(),
 		totals: {
 			fills: 0,
 			strokes: 0,
@@ -105,12 +220,27 @@ function newState(document, profile) {
 }
 function rewritePressDocument(document, profile) {
 	const state = newState(document, profile);
+	const boundsBudget = { decodedBytes: 0 };
+	walkPressGraph(document, {
+		beginContentsSequence: () => {
+			state.sequence = createPaintedBoundsTracker(state.painted, state.shadingPainted);
+		},
+		content: (_object, stream, _replace, resources) => recordContentBounds(state, stream, resources, boundsBudget),
+		endContentsSequence: () => {
+			state.sequence = void 0;
+		},
+		function: () => void 0,
+		group: () => void 0,
+		image: () => void 0,
+		replayPageContents: true,
+		shading: (shading, pattern) => indexShadingPattern(state, shading, pattern)
+	});
 	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)
+		image: (image) => convertEffectImage(state, image),
+		shading: (shading, pattern) => convertShading(state, shading, pattern)
 	});
 	return state.totals;
 }

package/dist/press/affine.js

@@ -0,0 +1,60 @@
+//#region src/press/affine.ts
+const IDENTITY_MATRIX = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function affineComponent(values, index) {
+	return values[index] ?? 0;
+}
+function multiplyAffine(left, right) {
+	const a0 = affineComponent(left, 0);
+	const b0 = affineComponent(left, 1);
+	const c0 = affineComponent(left, 2);
+	const d0 = affineComponent(left, 3);
+	const e0 = affineComponent(left, 4);
+	const f0 = affineComponent(left, 5);
+	const a1 = affineComponent(right, 0);
+	const b1 = affineComponent(right, 1);
+	const c1 = affineComponent(right, 2);
+	const d1 = affineComponent(right, 3);
+	const e1 = affineComponent(right, 4);
+	const f1 = affineComponent(right, 5);
+	return [
+		a0 * a1 + c0 * b1,
+		b0 * a1 + d0 * b1,
+		a0 * c1 + c0 * d1,
+		b0 * c1 + d0 * d1,
+		a0 * e1 + c0 * f1 + e0,
+		b0 * e1 + d0 * f1 + f0
+	];
+}
+function invertAffine(matrix) {
+	const a = affineComponent(matrix, 0);
+	const b = affineComponent(matrix, 1);
+	const c = affineComponent(matrix, 2);
+	const d = affineComponent(matrix, 3);
+	const e = affineComponent(matrix, 4);
+	const f = affineComponent(matrix, 5);
+	const det = a * d - b * c;
+	if (det === 0 || !Number.isFinite(det)) return void 0;
+	return [
+		d / det,
+		-b / det,
+		-c / det,
+		a / det,
+		(c * f - d * e) / det,
+		(b * e - a * f) / det
+	];
+}
+function applyAffine(matrix, x, y) {
+	return {
+		x: affineComponent(matrix, 0) * x + affineComponent(matrix, 2) * y + affineComponent(matrix, 4),
+		y: affineComponent(matrix, 1) * x + affineComponent(matrix, 3) * y + affineComponent(matrix, 5)
+	};
+}
+//#endregion
+export { IDENTITY_MATRIX, applyAffine, invertAffine, multiplyAffine };

package/dist/press/calculator-ops.js

@@ -0,0 +1,277 @@
+import { RenderRefusedError } from "../errors.js";
+function calculatorRefuse(found, supported) {
+	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
+}
+function pop(state, operator) {
+	const value = state.stack.pop();
+	if (!value) return calculatorRefuse(`calculator ${operator} stack underflow`, "enough operands");
+	return value;
+}
+function classifiedOperatorName(name) {
+	return /^[A-Za-z][A-Za-z0-9]{0,15}$/.test(name) ? name : "other";
+}
+function pushStack(state, value) {
+	state.stack.push(value);
+	if (state.stack.length > 32) calculatorRefuse(`calculator stack depth ${state.stack.length}`, `at most 32 values`);
+}
+function popNumber(state, operator) {
+	const value = pop(state, operator);
+	if (value.kind !== "n") return calculatorRefuse(`calculator ${operator} operand type`, "a number");
+	return value;
+}
+function popInt(state, operator) {
+	const value = popNumber(state, operator);
+	if (!value.int || !Number.isInteger(value.value)) return calculatorRefuse(`calculator ${operator} operand type`, "an integer");
+	return value.value;
+}
+function popBool(state, operator) {
+	const value = pop(state, operator);
+	if (value.kind !== "b") return calculatorRefuse(`calculator ${operator} operand type`, "a boolean");
+	return value.value;
+}
+function popProc(state, operator) {
+	const value = pop(state, operator);
+	if (value.kind !== "p") return calculatorRefuse(`calculator ${operator} operand type`, "a procedure");
+	return value.body;
+}
+function pushNumber(state, value, int) {
+	if (!Number.isFinite(value)) calculatorRefuse("calculator numeric result", "a finite number");
+	pushStack(state, {
+		kind: "n",
+		value,
+		int: int && Number.isInteger(value)
+	});
+}
+function pushBool(state, value) {
+	pushStack(state, {
+		kind: "b",
+		value
+	});
+}
+function unary(operator, apply) {
+	return (state) => {
+		const operand = popNumber(state, operator);
+		const result = apply(operand.value, operand.int);
+		pushNumber(state, result.value, result.int);
+	};
+}
+function binary(operator, apply) {
+	return (state) => {
+		const right = popNumber(state, operator);
+		const left = popNumber(state, operator);
+		const result = apply(left.value, right.value, left.int && right.int);
+		pushNumber(state, result.value, result.int);
+	};
+}
+function compare(operator, apply) {
+	return (state) => {
+		const right = popNumber(state, operator);
+		pushBool(state, apply(popNumber(state, operator).value, right.value));
+	};
+}
+function equal(state, operator, negate) {
+	const right = pop(state, operator);
+	const left = pop(state, operator);
+	let same = false;
+	if (left.kind === "n" && right.kind === "n") same = left.value === right.value;
+	else if (left.kind === "b" && right.kind === "b") same = left.value === right.value;
+	else calculatorRefuse(`calculator ${operator} operand type`, "two numbers or two booleans");
+	pushBool(state, negate ? !same : same);
+}
+function psRound(value) {
+	return value < 0 ? -Math.round(-value) : Math.round(value);
+}
+function logicalOrBitwise(state, operator, bools, ints) {
+	const right = pop(state, operator);
+	const left = pop(state, operator);
+	if (left.kind === "b" && right.kind === "b") {
+		pushBool(state, bools(left.value, right.value));
+		return;
+	}
+	if (left.kind === "n" && right.kind === "n" && left.int && right.int) {
+		pushNumber(state, ints(left.value, right.value) | 0, true);
+		return;
+	}
+	calculatorRefuse(`calculator ${operator} operand type`, "two booleans or two integers");
+}
+const operators = {
+	abs: unary("abs", (value, int) => ({
+		value: Math.abs(value),
+		int
+	})),
+	add: binary("add", (left, right, ints) => ({
+		value: left + right,
+		int: ints
+	})),
+	atan: (state) => {
+		const den = popNumber(state, "atan");
+		const num = popNumber(state, "atan");
+		if (num.value === 0 && den.value === 0) {
+			pushNumber(state, 0, false);
+			return;
+		}
+		let angle = Math.atan2(num.value, den.value) * 180 / Math.PI;
+		if (angle < 0) angle += 360;
+		pushNumber(state, angle, false);
+	},
+	ceiling: unary("ceiling", (value, int) => ({
+		value: Math.ceil(value),
+		int
+	})),
+	cos: unary("cos", (value) => ({
+		value: Math.cos(value * Math.PI / 180),
+		int: false
+	})),
+	cvi: unary("cvi", (value) => ({
+		value: Math.trunc(value),
+		int: true
+	})),
+	cvr: unary("cvr", (value) => ({
+		value,
+		int: false
+	})),
+	div: binary("div", (left, right) => ({
+		value: left / right,
+		int: false
+	})),
+	exp: binary("exp", (left, right) => ({
+		value: left ** right,
+		int: false
+	})),
+	floor: unary("floor", (value, int) => ({
+		value: Math.floor(value),
+		int
+	})),
+	idiv: (state) => {
+		const right = popInt(state, "idiv");
+		const left = popInt(state, "idiv");
+		if (right === 0) calculatorRefuse("calculator idiv divisor 0", "a non-zero divisor");
+		pushNumber(state, Math.trunc(left / right), true);
+	},
+	ln: unary("ln", (value) => ({
+		value: Math.log(value),
+		int: false
+	})),
+	log: unary("log", (value) => ({
+		value: Math.log10(value),
+		int: false
+	})),
+	mod: (state) => {
+		const right = popInt(state, "mod");
+		const left = popInt(state, "mod");
+		if (right === 0) calculatorRefuse("calculator mod divisor 0", "a non-zero divisor");
+		pushNumber(state, left % right, true);
+	},
+	mul: binary("mul", (left, right, ints) => ({
+		value: left * right,
+		int: ints
+	})),
+	neg: unary("neg", (value, int) => ({
+		value: -value,
+		int
+	})),
+	round: unary("round", (value, int) => ({
+		value: psRound(value),
+		int
+	})),
+	sin: unary("sin", (value) => ({
+		value: Math.sin(value * Math.PI / 180),
+		int: false
+	})),
+	sqrt: unary("sqrt", (value) => ({
+		value: Math.sqrt(value),
+		int: false
+	})),
+	sub: binary("sub", (left, right, ints) => ({
+		value: left - right,
+		int: ints
+	})),
+	truncate: unary("truncate", (value, int) => ({
+		value: Math.trunc(value),
+		int
+	})),
+	and: (state) => logicalOrBitwise(state, "and", (left, right) => left && right, (left, right) => left & right),
+	bitshift: (state) => {
+		const shift = popInt(state, "bitshift");
+		const bits = popInt(state, "bitshift") | 0;
+		if (shift >= 32 || shift <= -32) {
+			pushNumber(state, 0, true);
+			return;
+		}
+		pushNumber(state, shift >= 0 ? bits << shift | 0 : bits >>> -shift | 0, true);
+	},
+	eq: (state) => equal(state, "eq", false),
+	false: (state) => pushBool(state, false),
+	ge: compare("ge", (left, right) => left >= right),
+	gt: compare("gt", (left, right) => left > right),
+	le: compare("le", (left, right) => left <= right),
+	lt: compare("lt", (left, right) => left < right),
+	ne: (state) => equal(state, "ne", true),
+	not: (state) => {
+		const value = pop(state, "not");
+		if (value.kind === "b") {
+			pushBool(state, !value.value);
+			return;
+		}
+		if (value.kind === "n" && value.int) {
+			pushNumber(state, ~value.value | 0, true);
+			return;
+		}
+		calculatorRefuse("calculator not operand type", "a boolean or an integer");
+	},
+	or: (state) => logicalOrBitwise(state, "or", (left, right) => left || right, (left, right) => left | right),
+	true: (state) => pushBool(state, true),
+	xor: (state) => logicalOrBitwise(state, "xor", (left, right) => left !== right, (left, right) => left ^ right),
+	if: (state, exec) => {
+		const body = popProc(state, "if");
+		if (popBool(state, "if")) exec(body);
+	},
+	ifelse: (state, exec) => {
+		const otherwise = popProc(state, "ifelse");
+		const thenBody = popProc(state, "ifelse");
+		exec(popBool(state, "ifelse") ? thenBody : otherwise);
+	},
+	copy: (state) => {
+		const count = popInt(state, "copy");
+		if (count < 0 || state.stack.length < count) calculatorRefuse("calculator copy count", "a non-negative integer within the stack");
+		const copies = state.stack.slice(state.stack.length - count);
+		for (const value of copies) pushStack(state, value);
+	},
+	dup: (state) => {
+		const value = pop(state, "dup");
+		pushStack(state, value);
+		pushStack(state, value);
+	},
+	exch: (state) => {
+		const top = pop(state, "exch");
+		const below = pop(state, "exch");
+		pushStack(state, top);
+		pushStack(state, below);
+	},
+	index: (state) => {
+		const n = popInt(state, "index");
+		if (n < 0 || n >= state.stack.length) calculatorRefuse("calculator index", "a non-negative integer within the stack");
+		const value = state.stack[state.stack.length - 1 - n];
+		if (value) pushStack(state, value);
+	},
+	pop: (state) => {
+		pop(state, "pop");
+	},
+	roll: (state) => {
+		const j = popInt(state, "roll");
+		const n = popInt(state, "roll");
+		if (n < 0 || state.stack.length < n) calculatorRefuse("calculator roll count", "a non-negative integer within the stack");
+		if (n === 0) return;
+		const shift = (j % n + n) % n;
+		const start = state.stack.length - n;
+		const slice = state.stack.splice(start, n);
+		state.stack.push(...slice.slice(n - shift), ...slice.slice(0, n - shift));
+	}
+};
+function applyOperator(name, state, exec) {
+	const handler = operators[name];
+	if (!handler) calculatorRefuse(`calculator operator ${classifiedOperatorName(name)}`, "the PDF calculator operators");
+	handler(state, exec);
+}
+//#endregion
+export { applyOperator, calculatorRefuse, classifiedOperatorName, pushStack };

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 };