@orbat-mapper/tactical-map-sheet 0.1.0

package/dist/pdf.mjs

@@ -0,0 +1,677 @@
+import { a as POINTS_PER_MILLIMETRE, i as MILLIMETRES_PER_CSS_PIXEL, n as createTacticalMapSheetDocument, o as openSansCentralBaselineOffset, r as formatDecimal } from "./create-tactical-map-sheet-6DtvTi2G.mjs";
+import { jsPDF } from "jspdf";
+//#region src/pdf-transparency.ts
+const FORM_DICTIONARY_MARKER = new TextEncoder().encode("/Subtype /Form\n/BBox");
+const TRANSPARENCY_GROUP_DICTIONARY = new TextEncoder().encode("/Subtype /Form\n/Group <</S /Transparency /I true /K false>>\n/BBox");
+function byteSequenceAt(bytes, sequence, offset) {
+	if (offset + sequence.length > bytes.length) return false;
+	for (let index = 0; index < sequence.length; index += 1) if (bytes[offset + index] !== sequence[index]) return false;
+	return true;
+}
+/**
+* Mark jsPDF Form XObjects as isolated transparency groups and repair the
+* classic cross-reference table after inserting the additional dictionaries.
+*/
+function insertTransparencyGroupDictionaries(bytes) {
+	const offsets = [];
+	for (let offset = 0; offset <= bytes.length - FORM_DICTIONARY_MARKER.length; offset += 1) if (byteSequenceAt(bytes, FORM_DICTIONARY_MARKER, offset)) {
+		offsets.push(offset);
+		offset += FORM_DICTIONARY_MARKER.length - 1;
+	}
+	if (offsets.length === 0) return bytes;
+	const addedBytes = offsets.length * (TRANSPARENCY_GROUP_DICTIONARY.length - FORM_DICTIONARY_MARKER.length);
+	const expanded = new Uint8Array(bytes.length + addedBytes);
+	let sourceOffset = 0;
+	let targetOffset = 0;
+	for (const offset of offsets) {
+		expanded.set(bytes.subarray(sourceOffset, offset), targetOffset);
+		targetOffset += offset - sourceOffset;
+		expanded.set(TRANSPARENCY_GROUP_DICTIONARY, targetOffset);
+		targetOffset += TRANSPARENCY_GROUP_DICTIONARY.length;
+		sourceOffset = offset + FORM_DICTIONARY_MARKER.length;
+	}
+	expanded.set(bytes.subarray(sourceOffset), targetOffset);
+	const text = new TextDecoder("latin1").decode(expanded);
+	const xrefOffset = text.lastIndexOf("\nxref\n") + 1;
+	const trailer = text.slice(xrefOffset).match(/trailer\n([\s\S]*?)\nstartxref\n/);
+	const size = trailer?.[1]?.match(/\/Size (\d+)/)?.[1];
+	if (xrefOffset <= 0 || !trailer?.[1] || !size) throw new Error("Unable to rebuild the deterministic PDF cross-reference table");
+	const objectOffsets = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(/(?:^|\n)(\d+) 0 obj\n/g)) objectOffsets.set(Number(match[1]), match.index + (match[0].startsWith("\n") ? 1 : 0));
+	const objectCount = Number(size);
+	const entries = ["0000000000 65535 f "];
+	for (let objectNumber = 1; objectNumber < objectCount; objectNumber += 1) {
+		const offset = objectOffsets.get(objectNumber);
+		if (offset === void 0) throw new Error(`Missing PDF object ${objectNumber}`);
+		entries.push(`${String(offset).padStart(10, "0")} 00000 n `);
+	}
+	const rebuiltXref = new TextEncoder().encode(`xref\n0 ${objectCount}\n${entries.join("\n")}\ntrailer\n${trailer[1]}\nstartxref\n${xrefOffset}\n%%EOF`);
+	const result = new Uint8Array(xrefOffset + rebuiltXref.length);
+	result.set(expanded.subarray(0, xrefOffset));
+	result.set(rebuiltXref, xrefOffset);
+	return result;
+}
+//#endregion
+//#region src/pdf.ts
+const DEFAULT_VECTOR_PAINT = {
+	strokeWidth: 1,
+	lineCap: "butt",
+	lineJoin: "miter",
+	dash: [],
+	opacity: 1,
+	fillOpacity: 1,
+	strokeOpacity: 1,
+	fontSize: 16,
+	textAnchor: "start"
+};
+const FIXED_CREATION_DATE = "D:20000101000000+00'00'";
+const FIXED_FILE_ID = "00000000000000000000000000000001";
+/** jsPDF accepts opaque CSS hex colors but not alpha-bearing CSS colors. */
+function pdfColor(input) {
+	const color = input.trim();
+	const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(color);
+	if (hex) {
+		if (hex[1].length === 3 || hex[1].length === 6) return {
+			color,
+			alpha: 1
+		};
+		const digits = hex[1].length <= 4 ? hex[1].replace(/./g, (value) => value + value) : hex[1];
+		return {
+			color: `#${digits.slice(0, 6)}`,
+			alpha: digits.length === 8 ? parseInt(digits.slice(6, 8), 16) / 255 : 1
+		};
+	}
+	const rgb = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(color);
+	if (!rgb) return {
+		color,
+		alpha: 1
+	};
+	if (rgb[4] === void 0) return {
+		color,
+		alpha: 1
+	};
+	const channels = rgb.slice(1, 4).map(Number);
+	if (channels.some((channel) => !Number.isFinite(channel))) return {
+		color,
+		alpha: 1
+	};
+	return {
+		color: `#${channels.map((channel) => Math.round(channel).toString(16).padStart(2, "0")).join("")}`,
+		alpha: rgb[4] === void 0 ? 1 : Number(rgb[4])
+	};
+}
+function numberAttribute(attributes, name, fallback = 0) {
+	const value = attributes[name];
+	return typeof value === "number" ? value : fallback;
+}
+function stringAttribute(attributes, name) {
+	const value = attributes[name];
+	return typeof value === "string" ? value : void 0;
+}
+function arrayAttribute(attributes, name) {
+	const value = attributes[name];
+	return Array.isArray(value) ? value : void 0;
+}
+function inheritedPaint(parent, node) {
+	const attributes = node.attributes;
+	const fill = stringAttribute(attributes, "fill") ?? parent.fill;
+	const stroke = stringAttribute(attributes, "stroke") ?? parent.stroke;
+	return {
+		fill: fill === "none" ? void 0 : fill,
+		stroke: stroke === "none" ? void 0 : stroke,
+		strokeWidth: numberAttribute(attributes, "stroke-width", parent.strokeWidth),
+		lineCap: stringAttribute(attributes, "stroke-linecap") ?? parent.lineCap,
+		lineJoin: stringAttribute(attributes, "stroke-linejoin") ?? parent.lineJoin,
+		dash: arrayAttribute(attributes, "stroke-dasharray") ?? parent.dash,
+		opacity: parent.opacity,
+		fillOpacity: numberAttribute(attributes, "fill-opacity", parent.fillOpacity),
+		strokeOpacity: numberAttribute(attributes, "stroke-opacity", parent.strokeOpacity),
+		fontSize: numberAttribute(attributes, "font-size", parent.fontSize),
+		textAnchor: stringAttribute(attributes, "text-anchor") ?? parent.textAnchor
+	};
+}
+function applyStroke(pdf, paint) {
+	if (!paint.stroke) return;
+	pdf.setDrawColor(paint.stroke);
+	pdf.setLineWidth(paint.strokeWidth);
+	pdf.setLineCap(paint.lineCap);
+	pdf.setLineJoin(paint.lineJoin);
+	pdf.setLineDashPattern([...paint.dash], 0);
+}
+function paintPath(pdf, paint, patternKey) {
+	const fill = paint.fill ? pdfColor(paint.fill) : void 0;
+	const stroke = paint.stroke ? pdfColor(paint.stroke) : void 0;
+	if (fill) pdf.setFillColor(fill.color);
+	applyStroke(pdf, {
+		...paint,
+		stroke: stroke?.color
+	});
+	pdf.setGState(pdf.GState({
+		opacity: paint.opacity * paint.fillOpacity * (fill?.alpha ?? 1),
+		"stroke-opacity": paint.opacity * paint.strokeOpacity * (stroke?.alpha ?? 1)
+	}));
+	const pattern = patternKey ? { key: patternKey } : void 0;
+	if ((paint.fill || pattern) && paint.stroke) pdf.fillStroke(pattern);
+	else if (paint.fill || pattern) pdf.fill(pattern);
+	else if (paint.stroke) pdf.stroke();
+	else pdf.discardPath();
+}
+function quadraticToCubic(startX, startY, controlX, controlY, endX, endY) {
+	return [
+		startX + 2 / 3 * (controlX - startX),
+		startY + 2 / 3 * (controlY - startY),
+		endX + 2 / 3 * (controlX - endX),
+		endY + 2 / 3 * (controlY - endY),
+		endX,
+		endY
+	];
+}
+function vectorAngle(ux, uy, vx, vy) {
+	const length = Math.hypot(ux, uy) * Math.hypot(vx, vy);
+	if (length === 0) return 0;
+	const angle = Math.acos(Math.max(-1, Math.min(1, (ux * vx + uy * vy) / length)));
+	return ux * vy - uy * vx < 0 ? -angle : angle;
+}
+function arcToCubics(startX, startY, values) {
+	let radiusX = Math.abs(values[0]);
+	let radiusY = Math.abs(values[1]);
+	const rotationDegrees = values[2];
+	const largeArc = values[3];
+	const sweep = values[4];
+	const endX = values[5];
+	const endY = values[6];
+	if (radiusX === 0 || radiusY === 0 || startX === endX && startY === endY) return {
+		operations: [{
+			op: "l",
+			c: [endX, endY]
+		}],
+		endX,
+		endY
+	};
+	const rotation = rotationDegrees * Math.PI / 180;
+	const cos = Math.cos(rotation);
+	const sin = Math.sin(rotation);
+	const halfDx = (startX - endX) / 2;
+	const halfDy = (startY - endY) / 2;
+	const transformedX = cos * halfDx + sin * halfDy;
+	const transformedY = -sin * halfDx + cos * halfDy;
+	const radiiScale = transformedX * transformedX / (radiusX * radiusX) + transformedY * transformedY / (radiusY * radiusY);
+	if (radiiScale > 1) {
+		const factor = Math.sqrt(radiiScale);
+		radiusX *= factor;
+		radiusY *= factor;
+	}
+	const numerator = Math.max(0, radiusX * radiusX * radiusY * radiusY - radiusX * radiusX * transformedY * transformedY - radiusY * radiusY * transformedX * transformedX);
+	const denominator = radiusX * radiusX * transformedY * transformedY + radiusY * radiusY * transformedX * transformedX;
+	const coefficient = denominator === 0 ? 0 : (Boolean(largeArc) === Boolean(sweep) ? -1 : 1) * Math.sqrt(numerator / denominator);
+	const centerPrimeX = coefficient * radiusX * transformedY / radiusY;
+	const centerPrimeY = -coefficient * radiusY * transformedX / radiusX;
+	const centerX = cos * centerPrimeX - sin * centerPrimeY + (startX + endX) / 2;
+	const centerY = sin * centerPrimeX + cos * centerPrimeY + (startY + endY) / 2;
+	const ux = (transformedX - centerPrimeX) / radiusX;
+	const uy = (transformedY - centerPrimeY) / radiusY;
+	const vx = (-transformedX - centerPrimeX) / radiusX;
+	const vy = (-transformedY - centerPrimeY) / radiusY;
+	const startAngle = vectorAngle(1, 0, ux, uy);
+	let deltaAngle = vectorAngle(ux, uy, vx, vy);
+	if (!sweep && deltaAngle > 0) deltaAngle -= Math.PI * 2;
+	if (sweep && deltaAngle < 0) deltaAngle += Math.PI * 2;
+	const segments = Math.ceil(Math.abs(deltaAngle) / (Math.PI / 2));
+	const segmentAngle = deltaAngle / segments;
+	const operations = [];
+	const point = (angle) => [centerX + radiusX * Math.cos(angle) * cos - radiusY * Math.sin(angle) * sin, centerY + radiusX * Math.cos(angle) * sin + radiusY * Math.sin(angle) * cos];
+	for (let index = 0; index < segments; index += 1) {
+		const from = startAngle + index * segmentAngle;
+		const to = from + segmentAngle;
+		const alpha = 4 / 3 * Math.tan((to - from) / 4);
+		const [toX, toY] = point(to);
+		const derivative = (angle) => [-radiusX * Math.sin(angle) * cos - radiusY * Math.cos(angle) * sin, -radiusX * Math.sin(angle) * sin + radiusY * Math.cos(angle) * cos];
+		const [fromDx, fromDy] = derivative(from);
+		const [toDx, toDy] = derivative(to);
+		const [fromX, fromY] = point(from);
+		operations.push({
+			op: "c",
+			c: [
+				fromX + alpha * fromDx,
+				fromY + alpha * fromDy,
+				toX - alpha * toDx,
+				toY - alpha * toDy,
+				toX,
+				toY
+			]
+		});
+	}
+	return {
+		operations,
+		endX,
+		endY
+	};
+}
+function svgPathOperations(operations) {
+	const result = [];
+	let x = 0;
+	let y = 0;
+	let subpathX = 0;
+	let subpathY = 0;
+	let cubicControlX = 0;
+	let cubicControlY = 0;
+	let quadraticControlX = 0;
+	let quadraticControlY = 0;
+	let previous = "";
+	for (const operation of operations) {
+		const values = [...operation.values];
+		const absoluteX = (value) => operation.relative ? x + value : value;
+		const absoluteY = (value) => operation.relative ? y + value : value;
+		if (operation.command === "Z") {
+			result.push({
+				op: "h",
+				c: []
+			});
+			x = subpathX;
+			y = subpathY;
+		} else if (operation.command === "M" || operation.command === "L") {
+			x = absoluteX(values[0]);
+			y = absoluteY(values[1]);
+			result.push({
+				op: operation.command === "M" ? "m" : "l",
+				c: [x, y]
+			});
+			if (operation.command === "M") [subpathX, subpathY] = [x, y];
+		} else if (operation.command === "H") {
+			x = absoluteX(values[0]);
+			result.push({
+				op: "l",
+				c: [x, y]
+			});
+		} else if (operation.command === "V") {
+			y = absoluteY(values[0]);
+			result.push({
+				op: "l",
+				c: [x, y]
+			});
+		} else if (operation.command === "C") {
+			const control1X = absoluteX(values[0]);
+			const control1Y = absoluteY(values[1]);
+			cubicControlX = absoluteX(values[2]);
+			cubicControlY = absoluteY(values[3]);
+			x = absoluteX(values[4]);
+			y = absoluteY(values[5]);
+			result.push({
+				op: "c",
+				c: [
+					control1X,
+					control1Y,
+					cubicControlX,
+					cubicControlY,
+					x,
+					y
+				]
+			});
+		} else if (operation.command === "S") {
+			const control1X = previous === "C" || previous === "S" ? 2 * x - cubicControlX : x;
+			const control1Y = previous === "C" || previous === "S" ? 2 * y - cubicControlY : y;
+			cubicControlX = absoluteX(values[0]);
+			cubicControlY = absoluteY(values[1]);
+			x = absoluteX(values[2]);
+			y = absoluteY(values[3]);
+			result.push({
+				op: "c",
+				c: [
+					control1X,
+					control1Y,
+					cubicControlX,
+					cubicControlY,
+					x,
+					y
+				]
+			});
+		} else if (operation.command === "Q" || operation.command === "T") {
+			const controlX = operation.command === "T" && (previous === "Q" || previous === "T") ? 2 * x - quadraticControlX : operation.command === "Q" ? absoluteX(values[0]) : x;
+			const controlY = operation.command === "T" && (previous === "Q" || previous === "T") ? 2 * y - quadraticControlY : operation.command === "Q" ? absoluteY(values[1]) : y;
+			const endIndex = operation.command === "Q" ? 2 : 0;
+			const endX = absoluteX(values[endIndex]);
+			const endY = absoluteY(values[endIndex + 1]);
+			result.push({
+				op: "c",
+				c: quadraticToCubic(x, y, controlX, controlY, endX, endY)
+			});
+			[quadraticControlX, quadraticControlY, x, y] = [
+				controlX,
+				controlY,
+				endX,
+				endY
+			];
+		} else if (operation.command === "A") {
+			const arcValues = [
+				values[0],
+				values[1],
+				values[2],
+				values[3],
+				values[4],
+				absoluteX(values[5]),
+				absoluteY(values[6])
+			];
+			const arc = arcToCubics(x, y, arcValues);
+			result.push(...arc.operations);
+			[x, y] = [arc.endX, arc.endY];
+		}
+		previous = operation.command;
+	}
+	return result;
+}
+function transformMatrix(pdf, transform) {
+	const values = transform.values;
+	if (transform.type === "matrix") return pdf.Matrix(...values);
+	if (transform.type === "translate") return pdf.Matrix(1, 0, 0, 1, values[0], values[1] ?? 0);
+	if (transform.type === "scale") return pdf.Matrix(values[0], 0, 0, values[1] ?? values[0], 0, 0);
+	const radians = values[0] * Math.PI / 180;
+	const rotation = pdf.Matrix(Math.cos(radians), Math.sin(radians), -Math.sin(radians), Math.cos(radians), 0, 0);
+	if (values.length === 1) return rotation;
+	const [cx, cy] = values.slice(1);
+	return pdf.Matrix(1, 0, 0, 1, cx, cy).multiply(rotation).multiply(pdf.Matrix(1, 0, 0, 1, -cx, -cy));
+}
+function renderOpacityGroup(pdf, context, opacity, render) {
+	if (opacity === 0) return;
+	if (opacity === 1) return render();
+	const key = `opacity-${context.formIds.next++}`;
+	const [x, y, width, height] = context.bounds;
+	pdf.beginFormObject(x, y, width, height, pdf.Matrix(1, 0, 0, 1, 0, 0));
+	render();
+	pdf.endFormObject(key);
+	pdf.saveGraphicsState();
+	pdf.setGState(pdf.GState({
+		opacity,
+		"stroke-opacity": opacity
+	}));
+	pdf.doFormObject(key, pdf.Matrix(1, 0, 0, 1, 0, 0));
+	pdf.restoreGraphicsState();
+}
+function renderVectorNode(pdf, node, parentPaint, context, ignoreNodeOpacity = false) {
+	const nodeOpacity = numberAttribute(node.attributes, "opacity", 1);
+	if (!ignoreNodeOpacity && nodeOpacity !== 1) {
+		renderOpacityGroup(pdf, context, nodeOpacity, () => renderVectorNode(pdf, node, parentPaint, context, true));
+		return;
+	}
+	const paint = inheritedPaint(parentPaint, node);
+	pdf.saveGraphicsState();
+	if (node.kind === "group") {
+		for (const transform of node.transforms) pdf.setCurrentTransformationMatrix(transformMatrix(pdf, transform));
+		for (const child of node.children) renderVectorNode(pdf, child, paint, context);
+		pdf.restoreGraphicsState();
+		return;
+	}
+	if (node.kind === "text") {
+		const x = numberAttribute(node.attributes, "x");
+		const y = numberAttribute(node.attributes, "y");
+		pdf.setFont("Open Sans", "normal", 400);
+		pdf.setFontSize(paint.fontSize * POINTS_PER_MILLIMETRE);
+		const renderedWidth = pdf.getTextWidth(node.text);
+		const renderedLeft = paint.textAnchor === "middle" ? -renderedWidth / 2 : paint.textAnchor === "end" ? -renderedWidth : 0;
+		const fill = pdfColor(paint.fill ?? "#000000");
+		pdf.setTextColor(fill.color);
+		pdf.setGState(pdf.GState({ opacity: paint.opacity * paint.fillOpacity * fill.alpha }));
+		pdf.text(node.text, x + renderedLeft, y, {
+			align: "left",
+			baseline: "alphabetic"
+		});
+		pdf.restoreGraphicsState();
+		return;
+	}
+	if (node.kind === "path") pdf.path(svgPathOperations(node.operations));
+	else if (node.kind === "circle") pdf.circle(numberAttribute(node.attributes, "cx"), numberAttribute(node.attributes, "cy"), numberAttribute(node.attributes, "r"), null);
+	else if (node.kind === "ellipse") pdf.ellipse(numberAttribute(node.attributes, "cx"), numberAttribute(node.attributes, "cy"), numberAttribute(node.attributes, "rx"), numberAttribute(node.attributes, "ry"), null);
+	else if (node.kind === "rect") {
+		const x = numberAttribute(node.attributes, "x");
+		const y = numberAttribute(node.attributes, "y");
+		const width = numberAttribute(node.attributes, "width");
+		const height = numberAttribute(node.attributes, "height");
+		const rawRadiusX = numberAttribute(node.attributes, "rx", numberAttribute(node.attributes, "ry"));
+		const rawRadiusY = numberAttribute(node.attributes, "ry", rawRadiusX);
+		const radiusX = Math.min(rawRadiusX, width / 2);
+		const radiusY = Math.min(rawRadiusY, height / 2);
+		if (radiusX > 0 || radiusY > 0) pdf.roundedRect(x, y, width, height, radiusX, radiusY, null);
+		else pdf.rect(x, y, width, height, null);
+	} else if (node.kind === "line") pdf.path([{
+		op: "m",
+		c: [numberAttribute(node.attributes, "x1"), numberAttribute(node.attributes, "y1")]
+	}, {
+		op: "l",
+		c: [numberAttribute(node.attributes, "x2"), numberAttribute(node.attributes, "y2")]
+	}]);
+	else if (node.kind === "polyline" || node.kind === "polygon") {
+		const operations = [];
+		for (let index = 0; index < node.points.length; index += 2) operations.push({
+			op: index === 0 ? "m" : "l",
+			c: [node.points[index], node.points[index + 1]]
+		});
+		if (node.kind === "polygon") operations.push({
+			op: "h",
+			c: []
+		});
+		pdf.path(operations);
+	}
+	paintPath(pdf, paint);
+	pdf.restoreGraphicsState();
+}
+function sceneTextFont(text) {
+	if (text.fontStyle === "italic") return {
+		style: "italic",
+		weight: 400,
+		resourceStyle: "Italic"
+	};
+	if (text.fontWeight === 300) return {
+		style: "normal",
+		weight: 300,
+		resourceStyle: "Light"
+	};
+	return {
+		style: "normal",
+		weight: 400,
+		resourceStyle: "Regular"
+	};
+}
+function renderText(pdf, text) {
+	const backgroundLeft = text.anchor === "start" ? 0 : text.anchor === "end" ? -text.widthMm : -text.widthMm / 2;
+	pdf.saveGraphicsState();
+	const radians = text.rotationDegrees * Math.PI / 180;
+	pdf.setCurrentTransformationMatrix(pdf.Matrix(1, 0, 0, 1, text.position.xMm, text.position.yMm));
+	pdf.setCurrentTransformationMatrix(pdf.Matrix(Math.cos(radians), Math.sin(radians), -Math.sin(radians), Math.cos(radians), 0, 0));
+	pdf.setCurrentTransformationMatrix(pdf.Matrix(1, 0, 0, 1, -text.position.xMm, -text.position.yMm));
+	if (text.background) {
+		pdf.setFillColor("#ffffff");
+		pdf.rect(text.position.xMm + backgroundLeft, text.position.yMm - text.heightMm / 2, text.widthMm, text.heightMm, "F");
+	}
+	const font = sceneTextFont(text);
+	pdf.setFont("Open Sans", font.style, font.weight);
+	pdf.setFontSize(text.fontSizeMm * POINTS_PER_MILLIMETRE);
+	const renderedWidthMm = pdf.getTextWidth(text.text);
+	const renderedLeft = text.anchor === "start" ? 0 : text.anchor === "end" ? -renderedWidthMm : -renderedWidthMm / 2;
+	const baselineOffsetMm = openSansCentralBaselineOffset(font.resourceStyle, text.fontSizeMm / MILLIMETRES_PER_CSS_PIXEL) * MILLIMETRES_PER_CSS_PIXEL;
+	const fill = pdfColor(text.color);
+	const stroke = text.haloColor ? pdfColor(text.haloColor) : void 0;
+	pdf.setTextColor(fill.color);
+	if (text.haloColor) {
+		pdf.setDrawColor(stroke.color);
+		pdf.setLineWidth(text.haloWidthMm ?? 0);
+	}
+	if (fill.alpha !== 1 || (stroke?.alpha ?? 1) !== 1) pdf.setGState(pdf.GState({
+		opacity: fill.alpha,
+		"stroke-opacity": stroke?.alpha ?? fill.alpha
+	}));
+	pdf.text(text.text, text.position.xMm + renderedLeft, text.position.yMm + baselineOffsetMm, {
+		align: "left",
+		baseline: "alphabetic",
+		...text.haloColor ? { renderingMode: "fillThenStroke" } : {}
+	});
+	pdf.restoreGraphicsState();
+}
+function renderElement(pdf, element, formIds) {
+	if (element.kind === "text") return renderText(pdf, element);
+	if (element.kind === "vector-symbol") {
+		pdf.saveGraphicsState();
+		pdf.setCurrentTransformationMatrix(pdf.Matrix(1, 0, 0, 1, element.position.xMm, element.position.yMm));
+		const angle = element.rotationDegrees * Math.PI / 180;
+		pdf.setCurrentTransformationMatrix(pdf.Matrix(Math.cos(angle), Math.sin(angle), -Math.sin(angle), Math.cos(angle), 0, 0));
+		pdf.setCurrentTransformationMatrix(pdf.Matrix(element.scaleMmPerUnit, 0, 0, element.scaleMmPerUnit, 0, 0));
+		pdf.setCurrentTransformationMatrix(pdf.Matrix(1, 0, 0, 1, -element.anchor.x, -element.anchor.y));
+		const [viewX, viewY, viewWidth, viewHeight] = element.viewBox;
+		const viewportScale = Math.min(element.width / viewWidth, element.height / viewHeight);
+		const offsetX = (element.width - viewWidth * viewportScale) / 2 - viewX * viewportScale;
+		const offsetY = (element.height - viewHeight * viewportScale) / 2 - viewY * viewportScale;
+		pdf.setCurrentTransformationMatrix(pdf.Matrix(viewportScale, 0, 0, viewportScale, offsetX, offsetY));
+		const paint = {
+			...DEFAULT_VECTOR_PAINT,
+			fill: "#000000"
+		};
+		const context = {
+			bounds: element.viewBox,
+			formIds
+		};
+		renderOpacityGroup(pdf, context, element.opacity, () => {
+			for (const node of element.nodes) renderVectorNode(pdf, node, paint, context);
+		});
+		pdf.restoreGraphicsState();
+		return;
+	}
+	const [first, ...rest] = element.points;
+	if (!first) throw new Error("Cannot serialize an empty path");
+	pdf.path([
+		{
+			op: "m",
+			c: [first.xMm, first.yMm]
+		},
+		...rest.map((point) => ({
+			op: "l",
+			c: [point.xMm, point.yMm]
+		})),
+		...element.closed ? [{
+			op: "h",
+			c: []
+		}] : []
+	]);
+	paintPath(pdf, {
+		...DEFAULT_VECTOR_PAINT,
+		fill: element.fillColor,
+		stroke: element.strokeColor,
+		strokeWidth: element.strokeWidthMm,
+		lineCap: element.lineCap,
+		lineJoin: element.lineJoin,
+		dash: element.strokeDashMm
+	}, element.fillPatternId);
+}
+function patternPaint(paint) {
+	return {
+		...DEFAULT_VECTOR_PAINT,
+		fill: paint.fillColor,
+		stroke: paint.stroke?.color,
+		strokeWidth: paint.stroke?.widthMm ?? DEFAULT_VECTOR_PAINT.strokeWidth,
+		lineCap: paint.stroke?.lineCap ?? DEFAULT_VECTOR_PAINT.lineCap,
+		dash: paint.stroke?.dashMm ?? []
+	};
+}
+function renderPatternCommand(pdf, command) {
+	if (command.type === "circle") pdf.circle(command.center.xMm, command.center.yMm, command.radiusMm, null);
+	else {
+		const operations = command.operations.map((operation) => {
+			if (operation.type === "close") return {
+				op: "h",
+				c: []
+			};
+			if (operation.type === "cubic") return {
+				op: "c",
+				c: [
+					operation.control1.xMm,
+					operation.control1.yMm,
+					operation.control2.xMm,
+					operation.control2.yMm,
+					operation.to.xMm,
+					operation.to.yMm
+				]
+			};
+			return {
+				op: operation.type === "move" ? "m" : "l",
+				c: [operation.to.xMm, operation.to.yMm]
+			};
+		});
+		pdf.path(operations);
+	}
+	paintPath(pdf, patternPaint(command.paint));
+}
+function registerPattern(pdf, pattern, pageHeightMm) {
+	const identity = pattern.identity;
+	const matrix = pdf.Matrix(POINTS_PER_MILLIMETRE, 0, 0, -POINTS_PER_MILLIMETRE, identity.phaseXMm * POINTS_PER_MILLIMETRE, (pageHeightMm - identity.phaseYMm) * POINTS_PER_MILLIMETRE);
+	const tiling = pdf.TilingPattern([
+		0,
+		0,
+		identity.tileWidthMm,
+		identity.tileHeightMm
+	], identity.tileWidthMm, identity.tileHeightMm, void 0, matrix);
+	pdf.beginTilingPattern(tiling);
+	for (const command of pattern.commands) renderPatternCommand(pdf, command);
+	pdf.endTilingPattern(identity.id, tiling);
+}
+function registerFont(pdf, font) {
+	const fileName = `OpenSans-${font.style}.ttf`;
+	const style = font.style === "Italic" ? "italic" : "normal";
+	const weight = font.style === "Light" ? 300 : 400;
+	pdf.addFileToVFS(fileName, font.base64);
+	pdf.addFont(fileName, "Open Sans", style, weight, "Identity-H");
+}
+function canonicalizeScene(scene) {
+	return JSON.parse(JSON.stringify(scene, (_key, value) => typeof value === "number" ? Number(formatDecimal(value)) : value));
+}
+function renderLayers(pdf, layers, formIds) {
+	for (const layer of layers) for (const graphic of layer.graphics) for (const element of graphic.elements) renderElement(pdf, element, formIds);
+}
+function serializePdf(inputScene) {
+	const scene = canonicalizeScene(inputScene);
+	const pdf = new jsPDF({
+		orientation: scene.page.widthMm >= scene.page.heightMm ? "landscape" : "portrait",
+		unit: "mm",
+		format: [scene.page.widthMm, scene.page.heightMm],
+		compress: false,
+		precision: 6,
+		putOnlyUsedFonts: true
+	});
+	pdf.setCreationDate(FIXED_CREATION_DATE);
+	pdf.setFileId(FIXED_FILE_ID);
+	pdf.setProperties({ creator: "@orbat-mapper/tactical-map-sheet" });
+	const formIds = { next: 0 };
+	for (const font of scene.fonts) registerFont(pdf, font);
+	pdf.advancedAPI((advanced) => {
+		for (const pattern of scene.patterns) registerPattern(advanced, pattern, scene.page.heightMm);
+		if (scene.backgroundColor) {
+			const background = pdfColor(scene.backgroundColor);
+			if (background.alpha === 1) {
+				advanced.setFillColor(background.color);
+				advanced.rect(0, 0, scene.page.widthMm, scene.page.heightMm, "F");
+			} else {
+				advanced.saveGraphicsState();
+				advanced.setFillColor(background.color);
+				advanced.setGState(advanced.GState({ opacity: background.alpha }));
+				advanced.rect(0, 0, scene.page.widthMm, scene.page.heightMm, "F");
+				advanced.restoreGraphicsState();
+			}
+		}
+		advanced.saveGraphicsState();
+		advanced.rect(scene.mapFrame.xMm, scene.mapFrame.yMm, scene.mapFrame.widthMm, scene.mapFrame.heightMm, null);
+		advanced.clip();
+		advanced.discardPath();
+		renderLayers(advanced, scene.layers, formIds);
+		advanced.restoreGraphicsState();
+		renderLayers(advanced, scene.marginalia ?? [], formIds);
+	});
+	return insertTransparencyGroupDictionaries(new Uint8Array(pdf.output("arraybuffer")));
+}
+function renderMapSheetPdf(request) {
+	const { scene, result } = createTacticalMapSheetDocument(request);
+	return {
+		pdf: serializePdf(scene),
+		footprint: result.footprint,
+		warnings: result.warnings,
+		metadata: result.metadata,
+		resources: result.resources
+	};
+}
+//#endregion
+export { renderMapSheetPdf };