@segnavia/render 0.2.0 → 0.4.0

package/dist/color/profile.js

@@ -1,6 +1,6 @@
 import { REVERSE_LUT, checked, refuse } from "./types.js";
-import { fixed, need, signature, u32 } from "./binary.js";
 import { destinationBlackPoint, detectSourceBlackPoint } from "./black-point.js";
+import { fixed, need, signature, u32 } from "./binary.js";
 import { matrixTables, parseMab, parseMft } from "./tables.js";
 //#region src/color/profile.ts
 const MAX_PROFILE_BYTES = 33554432;

package/dist/color/tables.js

@@ -1,6 +1,6 @@
 import { REVERSE_LUT, checked, clamp, refuse } from "./types.js";
-import { align4, fixed, need, signature, u16, u32 } from "./binary.js";
 import { invert3, matrix3 } from "./spaces.js";
+import { align4, fixed, need, signature, u16, u32 } from "./binary.js";
 import { interpolate, matrixInput, multilinear, tetrahedral4 } from "./interpolation.js";
 //#region src/color/tables.ts
 function packed(bytes, view, offset, length, width, bounds) {

package/dist/deck-pdf.js

@@ -1,4 +1,5 @@
 import { RenderRefusedError } from "./errors.js";
+import { containFixedPageOverflow } from "./overflow-containment.js";
 import { pdfPixelBox } from "./pdf-geometry.js";
 import { composeImposedPdf, drawClippedPage, embedOnePage } from "./pdf-compose.js";
 import { Imposition, fitPage, impose, pagePlacementLayout } from "@segnavia/format";
@@ -20,6 +21,7 @@ async function regularDeckPdf(deck, opts, services) {
 		html: slide.content.html
 	}] : []);
 	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const slideCss = containFixedPageOverflow(css);
 	const notesGeometry = opts.layout === "notes" ? notesLayoutGeometry(deck.size, opts.notesPaper) : void 0;
 	const [printable, rendered] = await Promise.all([services.renderPdf({
 		viewport: notesGeometry ? {
@@ -46,7 +48,7 @@ async function regularDeckPdf(deck, opts, services) {
 					scripts: deck.scripts === "sandboxed",
 					html: htmlSlideDocument(deck, html, {
 						nonce: newNonce(),
-						css
+						css: slideCss
 					}),
 					boundMs: opts.boundMs
 				}, {
@@ -84,7 +86,7 @@ async function regularDeckPdf(deck, opts, services) {
 	return services.finish(await output.save(), opts);
 }
 async function imposedDeckPdf(deck, imposition, opts, services) {
-	const css = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const css = containFixedPageOverflow(`${services.fontFaces(opts)}${opts.css ?? ""}`);
 	const imposed = impose(imposition, deck.slides.length);
 	const rendered = await Promise.all(deck.slides.map(async (slide, index) => {
 		const single = {

package/dist/effects/adapter.js

@@ -0,0 +1,336 @@
+import { RenderRefusedError } from "../errors.js";
+import { IDENTITY_MATRIX, multiplyAffine } from "../press/affine.js";
+import { visitContentOperations } from "../press/content.js";
+import { decodeContent, dictionaryOf, nameOf, resolvedColorSpace } from "../press/pdf-objects.js";
+import { walkPressGraph } from "../press/visitor.js";
+import { replaceRanges, streamDictionary } from "./content-replacement.js";
+import { softMaskAction } from "./policy.js";
+import { rule1EffectImage } from "./rule-1.js";
+import { EMPTY_EFFECT_GRAPHICS_STATE, advanceEffectGraphicsState, effectFormStructure, effectGraphicsStateOpacity, effectGraphicsStateStructure, effectOpacity } from "./structure.js";
+import { buildRuleCImage, ruleCPlan } from "./rule-c.js";
+import { PDFArray, PDFDict, PDFDocument, PDFName, PDFNumber, PDFRawStream, PDFRef } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/effects/adapter.ts
+const key = (name) => PDFName.of(name);
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function numbers(array) {
+	if (!array) return void 0;
+	const values = [];
+	for (let index = 0; index < array.size(); index++) {
+		const value = array.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0) return void 0;
+		values.push(value);
+	}
+	return values;
+}
+function blackBackdrop(mask) {
+	const backdrop = numbers(mask.lookupMaybe(key("BC"), PDFArray));
+	return backdrop === void 0 || backdrop.length === 1 && backdrop[0] === 0;
+}
+function hasNestedMask(document, resources) {
+	const states = resources?.lookupMaybe(key("ExtGState"), PDFDict);
+	for (const [, object] of states?.entries() ?? []) {
+		const state = dictionaryOf(resolved(document, object));
+		if (dictionaryOf(resolved(document, state?.get(key("SMask"))))) return true;
+	}
+	return false;
+}
+function groupContents(document, source, resources, budget) {
+	const operations = [];
+	visitContentOperations(decodeContent(source, budget), (operation) => operations.push(operation));
+	const states = resources?.lookupMaybe(key("ExtGState"), PDFDict);
+	const stack = [];
+	let graphicsState = EMPTY_EFFECT_GRAPHICS_STATE;
+	let structure = "allowed";
+	let paintState = EMPTY_EFFECT_GRAPHICS_STATE;
+	for (const operation of operations) {
+		graphicsState = advanceEffectGraphicsState(document, operation, states, graphicsState, stack);
+		if (graphicsState.structure === "other") structure = "other";
+		if (operation.operator === "Do") paintState = graphicsState;
+	}
+	const paints = operations.filter(({ operator }) => [
+		"Do",
+		"sh",
+		"f",
+		"f*",
+		"F",
+		"S",
+		"B",
+		"B*",
+		"b",
+		"b*"
+	].includes(operator));
+	if (paints.length !== 1 || paints[0]?.operator !== "Do" || paints[0].operands.length !== 1 || paints[0].operands[0]?.kind !== "name") return {
+		kind: paints.some(({ operator }) => operator !== "Do") ? "vector" : "other",
+		structure: "other"
+	};
+	const xObjects = resources?.lookupMaybe(key("XObject"), PDFDict);
+	const image = resolved(document, xObjects?.get(PDFName.of(paints[0].operands[0].raw.slice(1))));
+	if (!(image instanceof PDFRawStream) || nameOf(image.dict.get(key("Subtype"))) !== "Image") return {
+		kind: "vector",
+		structure: "other"
+	};
+	if (resolvedColorSpace(document, resolved(document, image.dict.get(key("ColorSpace")))).kind !== "gray" || image.dict.has(key("SMask"))) return {
+		kind: "other",
+		structure: "other"
+	};
+	if (effectGraphicsStateOpacity(paintState) !== 1) structure = "other";
+	return {
+		image,
+		kind: "single-image",
+		structure
+	};
+}
+function classifyMask(state, graphicsState, mask, source, resources) {
+	state.masks.add(mask);
+	const group = source.dict.lookupMaybe(key("Group"), PDFDict);
+	const contents = groupContents(state.document, source, resources, state.budget);
+	const image = contents.image;
+	const nested = hasNestedMask(state.document, resources);
+	const opacity = effectOpacity(graphicsState);
+	const structure = rule1Structure(state.document, graphicsState, mask, source, contents.structure, nested);
+	const candidate = {
+		backdrop: blackBackdrop(mask) ? "black" : "other",
+		colorSpace: group && resolvedColorSpace(state.document, resolved(state.document, group.get(key("CS")))).kind === "gray" ? "gray" : "other",
+		contents: contents.kind,
+		structure,
+		subtype: nameOf(mask.get(key("S"))) === "Luminosity" ? "luminosity" : "other"
+	};
+	const bbox = numbers(source.dict.lookupMaybe(key("BBox"), PDFArray));
+	const plan = image && bbox?.length === 4 && opacity !== void 0 ? {
+		bbox,
+		image,
+		mask,
+		opacity
+	} : void 0;
+	state.rule1Candidates.set(graphicsState, {
+		...candidate,
+		plan
+	});
+}
+function rule1Structure(document, graphicsState, mask, source, contents, nested) {
+	return (!mask.has(key("TR")) || nameOf(resolved(document, mask.get(key("TR")))) === "Identity") && !nested && contents === "allowed" && effectGraphicsStateStructure(graphicsState) === "allowed" && effectFormStructure(source.dict) === "allowed" ? "allowed" : "other";
+}
+function finiteNumberEntry(dictionary, label) {
+	const object = dictionary.get(key(label));
+	const value = object instanceof PDFRef ? dictionary.context.lookup(object) : object;
+	const number = value instanceof PDFNumber ? value.asNumber() : void 0;
+	return number !== void 0 && Number.isFinite(number) ? number : void 0;
+}
+function numericOperands(operation, count) {
+	if (operation.operands.length !== count || operation.operands.some(({ kind }) => kind !== "number")) return void 0;
+	return operation.operands.map(({ raw }) => Number(raw));
+}
+const close = (left, right) => Math.abs(left - right) <= .01;
+function matchingRectangle(operation, bbox) {
+	const rectangle = numericOperands(operation, 4);
+	if (!rectangle) return false;
+	const [x = 0, y = 0, width = 0, height = 0] = rectangle;
+	return close(x, bbox[0] ?? 0) && close(y, bbox[1] ?? 0) && close(width, (bbox[2] ?? 0) - (bbox[0] ?? 0)) && close(height, (bbox[3] ?? 0) - (bbox[1] ?? 0));
+}
+function colorFrom(operation) {
+	const definition = {
+		g: ["DeviceGray", 1],
+		rg: ["DeviceRGB", 3],
+		k: ["DeviceCMYK", 4]
+	}[operation.operator];
+	if (!definition) return void 0;
+	const values = numericOperands(operation, definition[1]);
+	return values ? {
+		space: definition[0],
+		values
+	} : void 0;
+}
+function xObjectName(resources, image) {
+	let xObjects = resources.lookupMaybe(key("XObject"), PDFDict);
+	if (!xObjects) {
+		xObjects = resources.context.obj({});
+		resources.set(key("XObject"), xObjects);
+	}
+	let index = 1;
+	while (xObjects.has(key(`SegnaviaEffect${index}`))) index++;
+	const name = `SegnaviaEffect${index}`;
+	xObjects.set(key(name), image);
+	return name;
+}
+function opacityGraphicsStateName(resources, opacity) {
+	if (opacity === 1) return void 0;
+	let states = resources.lookupMaybe(key("ExtGState"), PDFDict);
+	if (!states) {
+		states = resources.context.obj({});
+		resources.set(key("ExtGState"), states);
+	}
+	let index = 1;
+	while (states.has(key(`SegnaviaEffectOpacity${index}`))) index++;
+	const name = `SegnaviaEffectOpacity${index}`;
+	states.set(key(name), resources.context.obj({
+		Type: "ExtGState",
+		ca: opacity
+	}));
+	return name;
+}
+function ruleCCandidate(state, next, graphicsState, resources) {
+	if (!graphicsState || next?.operator !== "Do" || next.operands.length !== 1 || next.operands[0]?.kind !== "name") return void 0;
+	const xObjects = resources.lookupMaybe(key("XObject"), PDFDict);
+	const form = resolved(state.document, xObjects?.get(PDFName.of(next.operands[0].raw.slice(1))));
+	if (!(form instanceof PDFRawStream) || nameOf(form.dict.get(key("Subtype"))) !== "Form") return void 0;
+	return ruleCPlan(state.document, form, graphicsState, state.budget);
+}
+function ruleCReplacement(state, next, graphicsState, resources, printMatrix, plan) {
+	const opacity = graphicsState.has(key("ca")) ? finiteNumberEntry(graphicsState, "ca") : 1;
+	const built = opacity !== void 0 ? buildRuleCImage(state.document, plan, opacity, state.budget, printMatrix) : void 0;
+	if (!built) return void 0;
+	const name = xObjectName(resources, built.image);
+	const [left = 0, bottom = 0, right = 0, top = 0] = plan.bbox;
+	for (const mask of plan.masks) state.ruleCMasks.add(mask);
+	state.appliedRuleC++;
+	return {
+		end: next.end,
+		text: `q ${left} ${bottom} ${right - left} ${top - bottom} re W n ${built.matrix.join(" ")} cm /${name} Do Q`
+	};
+}
+function namedOperand(operation, operator) {
+	const operand = operation.operands[0];
+	return operation.operator === operator && operation.operands.length === 1 && operand?.kind === "name" ? operand : void 0;
+}
+function advanceGraphics(operation, current, stack) {
+	if (operation.operator === "q") {
+		stack.push(current);
+		return current;
+	}
+	if (operation.operator === "Q") return stack.pop() ?? {
+		color: void 0,
+		matrix: IDENTITY_MATRIX
+	};
+	if (operation.operator === "cm") return {
+		...current,
+		matrix: multiplyAffine(current.matrix, numericOperands(operation, 6) ?? IDENTITY_MATRIX)
+	};
+	return {
+		...current,
+		color: colorFrom(operation) ?? current.color
+	};
+}
+function effectReplacement(state, next, following, graphicsState, resources, graphics) {
+	const ruleC = ruleCCandidate(state, next, graphicsState, resources);
+	const rule1 = state.rule1Candidates.get(graphicsState);
+	if (!rule1 && !ruleC?.nested) return void 0;
+	const facts = {
+		backdrop: rule1?.backdrop ?? "other",
+		colorSpace: rule1?.colorSpace ?? "other",
+		contents: rule1?.contents ?? "other",
+		nested: ruleC?.nested ?? false,
+		oneAxis: ruleC?.nested ? ruleC.oneAxis : "unknown",
+		structure: ruleC?.nested ? ruleC.structure : rule1?.structure ?? "other",
+		subtype: rule1?.subtype ?? "other"
+	};
+	const decision = softMaskAction(facts);
+	if (decision === "ruleC" && ruleC?.plan && next) {
+		const replacement = ruleCReplacement(state, next, graphicsState, resources, graphics.matrix, ruleC.plan);
+		return replacement ? {
+			consumed: 1,
+			...replacement
+		} : void 0;
+	}
+	const plan = rule1?.plan;
+	if (decision !== "rule1" || !plan || !graphics.color || !next || !following || next.operator !== "re" || ![
+		"f",
+		"f*",
+		"F"
+	].includes(following.operator) || !matchingRectangle(next, plan.bbox)) return void 0;
+	const name = xObjectName(resources, rule1EffectImage(state.document, state.budget, plan, graphics.color));
+	const opacityName = opacityGraphicsStateName(resources, plan.opacity);
+	const [left = 0, bottom = 0, right = 0, top = 0] = plan.bbox;
+	state.applied.add(plan.mask);
+	const opacity = opacityName ? `/${opacityName} gs ` : "";
+	return {
+		consumed: 2,
+		end: following.end,
+		text: `q ${opacity}${right - left} 0 0 ${bottom - top} ${left} ${top} cm /${name} Do Q`
+	};
+}
+function rewriteContent(state, object, stream, setDirect, resources) {
+	const bytes = decodeContent(stream, state.budget);
+	if (!resources) return;
+	const operations = [];
+	visitContentOperations(bytes, (operation) => operations.push(operation));
+	const graphicsStates = resources.lookupMaybe(key("ExtGState"), PDFDict);
+	const replacements = [];
+	const stack = [];
+	let graphics = {
+		color: void 0,
+		matrix: IDENTITY_MATRIX
+	};
+	for (let index = 0; index < operations.length; index++) {
+		const operation = operations[index];
+		if (!operation) continue;
+		graphics = advanceGraphics(operation, graphics, stack);
+		const operand = namedOperand(operation, "gs");
+		if (!operand) continue;
+		const graphicsState = dictionaryOf(resolved(state.document, graphicsStates?.get(PDFName.of(operand.raw.slice(1)))));
+		if (!graphicsState) continue;
+		const replacement = effectReplacement(state, operations[index + 1], operations[index + 2], graphicsState, resources, graphics);
+		if (!replacement) continue;
+		replacements.push({
+			start: operand.start,
+			...replacement
+		});
+		index += replacement.consumed;
+	}
+	if (replacements.length === 0) return;
+	const replacement = state.document.context.stream(deflateSync(replaceRanges(bytes, replacements)), 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 rewriteEffectsDocument(document) {
+	const state = {
+		applied: /* @__PURE__ */ new WeakSet(),
+		appliedRuleC: 0,
+		budget: { decodedBytes: 0 },
+		document,
+		masks: /* @__PURE__ */ new Set(),
+		rule1Candidates: /* @__PURE__ */ new WeakMap(),
+		ruleCMasks: /* @__PURE__ */ new WeakSet()
+	};
+	walkPressGraph(document, {
+		content: () => void 0,
+		function: () => void 0,
+		group: () => void 0,
+		image: () => void 0,
+		shading: () => false,
+		softMask: (graphicsState, mask, source, resources) => classifyMask(state, graphicsState, mask, source, resources)
+	});
+	state.budget = { decodedBytes: 0 };
+	walkPressGraph(document, {
+		content: (object, stream, replace, resources) => rewriteContent(state, object, stream, replace, resources),
+		function: () => void 0,
+		group: () => void 0,
+		image: () => void 0,
+		shading: () => false
+	});
+	let rule1 = 0;
+	for (const mask of state.masks) if (state.applied.has(mask)) rule1++;
+	let kept = 0;
+	for (const mask of state.masks) if (!state.applied.has(mask) && !state.ruleCMasks.has(mask)) kept++;
+	return {
+		rule1,
+		ruleC: state.appliedRuleC,
+		kept
+	};
+}
+async function rewriteEffectsPdf(bytes) {
+	try {
+		const document = await PDFDocument.load(bytes, { updateMetadata: false });
+		const report = rewriteEffectsDocument(document);
+		return {
+			bytes: report.rule1 === 0 && report.ruleC === 0 ? bytes : await document.save(),
+			report
+		};
+	} 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 { rewriteEffectsDocument, rewriteEffectsPdf };

package/dist/effects/content-replacement.js

@@ -0,0 +1,35 @@
+import { PDFName } from "pdf-lib";
+//#region src/effects/content-replacement.ts
+const key = (name) => PDFName.of(name);
+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 replaceRanges(bytes, replacements) {
+	const encoder = new TextEncoder();
+	let length = bytes.length;
+	for (const item of replacements) length += encoder.encode(item.text).length - (item.end - item.start);
+	const output = new Uint8Array(length);
+	let inputAt = 0;
+	let outputAt = 0;
+	for (const item of replacements) {
+		output.set(bytes.subarray(inputAt, item.start), outputAt);
+		outputAt += item.start - inputAt;
+		const inserted = encoder.encode(item.text);
+		output.set(inserted, outputAt);
+		outputAt += inserted.length;
+		inputAt = item.end;
+	}
+	output.set(bytes.subarray(inputAt), outputAt);
+	return output;
+}
+//#endregion
+export { replaceRanges, streamDictionary };

package/dist/effects/function-evaluator.js

@@ -0,0 +1,72 @@
+import { dictionaryOf, numberOf } from "../press/pdf-objects.js";
+import { PDFArray, PDFName, PDFNumber, PDFRef } from "pdf-lib";
+const MAX_EFFECT_FUNCTION_CHILDREN = 4096;
+const key = (name) => PDFName.of(name);
+const resolved = (document, object) => object instanceof PDFRef ? document.context.lookup(object) : object;
+function numbers(dictionary, label) {
+	const array = dictionary.lookupMaybe(key(label), PDFArray);
+	if (!array) return void 0;
+	const values = [];
+	for (let index = 0; index < array.size(); index++) {
+		const value = array.lookupMaybe(index, PDFNumber)?.asNumber();
+		if (value === void 0 || !Number.isFinite(value)) return void 0;
+		values.push(value);
+	}
+	return values;
+}
+const clamp = (value) => Math.max(0, Math.min(1, value));
+function exponentialEvaluator(fn, channels, domain) {
+	const from = numbers(fn, "C0") ?? [0];
+	const to = numbers(fn, "C1") ?? [1];
+	const exponent = numberOf(fn, "N");
+	if (from.length !== channels || to.length !== channels || exponent === void 0) return void 0;
+	return Object.assign((input) => {
+		const value = clamp((input - (domain[0] ?? 0)) / ((domain[1] ?? 1) - (domain[0] ?? 0))) ** exponent;
+		return from.map((start, index) => start + ((to[index] ?? start) - start) * value);
+	}, { cost: 1 });
+}
+function stitchingEvaluator(context, fn, domain, depth) {
+	const functions = fn.lookupMaybe(key("Functions"), PDFArray);
+	const bounds = numbers(fn, "Bounds") ?? [];
+	const encode = numbers(fn, "Encode") ?? [];
+	if (!functions || functions.size() > MAX_EFFECT_FUNCTION_CHILDREN || functions.size() !== bounds.length + 1 || encode.length !== functions.size() * 2) return void 0;
+	context.path.add(fn);
+	const children = [];
+	for (let index = 0; index < functions.size(); index++) children.push(buildEvaluator(context, functions.get(index), depth + 1));
+	context.path.delete(fn);
+	if (children.some((child) => !child)) return void 0;
+	const evaluators = children;
+	const cost = bounds.length + evaluators.reduce((sum, child) => sum + child.cost, 0);
+	return Object.assign((input) => {
+		const value = Math.max(domain[0] ?? 0, Math.min(domain[1] ?? 1, input));
+		let index = bounds.findIndex((bound) => value < bound);
+		if (index < 0) index = bounds.length;
+		const low = index === 0 ? domain[0] ?? 0 : bounds[index - 1] ?? 0;
+		const high = index === bounds.length ? domain[1] ?? 1 : bounds[index] ?? 1;
+		const encodedLow = encode[index * 2] ?? 0;
+		const encodedHigh = encode[index * 2 + 1] ?? 1;
+		const mapped = high === low ? encodedLow : encodedLow + (value - low) / (high - low) * (encodedHigh - encodedLow);
+		return evaluators[index](mapped);
+	}, { cost });
+}
+function buildEvaluator(context, object, depth) {
+	const fn = dictionaryOf(resolved(context.document, object));
+	if (!fn || depth > 12 || context.path.has(fn)) return void 0;
+	if (context.memo.has(fn)) return context.memo.get(fn);
+	const domain = numbers(fn, "Domain") ?? [0, 1];
+	if (domain.length !== 2 || domain[0] === domain[1]) return void 0;
+	const type = numberOf(fn, "FunctionType");
+	const evaluator = type === 2 ? exponentialEvaluator(fn, context.channels, domain) : type === 3 ? stitchingEvaluator(context, fn, domain, depth) : void 0;
+	context.memo.set(fn, evaluator);
+	return evaluator;
+}
+function functionEvaluator(document, object, channels) {
+	return buildEvaluator({
+		channels,
+		document,
+		memo: /* @__PURE__ */ new WeakMap(),
+		path: /* @__PURE__ */ new WeakSet()
+	}, object, 0);
+}
+//#endregion
+export { functionEvaluator };

package/dist/effects/policy.js

@@ -0,0 +1,10 @@
+//#region src/effects/policy.ts
+function softMaskAction(facts) {
+	if (facts.structure === "other") return "keep";
+	if (facts.nested) return facts.oneAxis === "shared" ? "ruleC" : "keep";
+	if (facts.subtype !== "luminosity") return "keep";
+	if (facts.contents === "single-image" && facts.backdrop === "black" && facts.colorSpace === "gray") return "rule1";
+	return "keep";
+}
+//#endregion
+export { softMaskAction };

package/dist/effects/rule-1.js

@@ -0,0 +1,40 @@
+import { RenderRefusedError } from "../errors.js";
+import { MAX_CONTENT_BYTES, MAX_DOCUMENT_CONTENT_BYTES, numberOf } from "../press/pdf-objects.js";
+import { GENERATED_EFFECT_IMAGE_KEY } from "./types.js";
+import { PDFHexString } from "pdf-lib";
+import { deflateSync } from "node:zlib";
+//#region src/effects/rule-1.ts
+function chargePixels(budget, bytes) {
+	if (bytes > 33554432) throw new RenderRefusedError(`The PDF has unsupported effect image longer than ${MAX_CONTENT_BYTES} bytes; supported: at most ${MAX_CONTENT_BYTES} bytes.`);
+	budget.decodedBytes += bytes;
+	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.`);
+}
+function rule1EffectImage(document, budget, plan, color) {
+	const width = numberOf(plan.image.dict, "Width");
+	const height = numberOf(plan.image.dict, "Height");
+	if (!width || !height) throw new RenderRefusedError("The PDF has unsupported grayscale mask image dimensions; supported: positive Width and Height numbers.");
+	const palette = color.values.map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255));
+	const length = Math.ceil(width / 8) * height;
+	chargePixels(budget, length);
+	const bytes = new Uint8Array(length);
+	const softMask = document.context.getObjectRef(plan.image) ?? plan.image;
+	return document.context.register(document.context.stream(deflateSync(bytes), {
+		Type: "XObject",
+		Subtype: "Image",
+		Width: width,
+		Height: height,
+		ColorSpace: [
+			"Indexed",
+			color.space,
+			0,
+			PDFHexString.of(Buffer.from(palette).toString("hex"))
+		],
+		BitsPerComponent: 1,
+		Filter: "FlateDecode",
+		SMask: softMask,
+		[GENERATED_EFFECT_IMAGE_KEY]: true,
+		SegnaviaEffectColor: color.values
+	}));
+}
+//#endregion
+export { rule1EffectImage };