@segnavia/render 0.1.0 → 0.3.0

package/dist/press/adapter.js

@@ -0,0 +1,275 @@
+import { RenderRefusedError } from "../errors.js";
+import { cachedPressColor, pressColor } from "./color-policy.js";
+import { groupAction, shadingAction } from "./policy.js";
+import { rewriteContent } from "./content.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, PDFHexString, 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 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, 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) {
+	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 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()) {
+		const label = name.toString().slice(1);
+		if (![
+			"Filter",
+			"DecodeParms",
+			"Length"
+		].includes(label)) dictionary[label] = value;
+	}
+	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 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));
+	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: {
+			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,
+			gradientStops: 0,
+			groups: 0
+		}
+	};
+}
+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: (image) => convertEffectImage(state, image),
+		shading: (shading, pattern) => convertShading(state, shading, pattern)
+	});
+	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/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 };