@pdfme/common 6.1.0 → 6.1.1-dev.11

package/dist/index.js

@@ -1,8 +1,73 @@
 import { z } from "zod";
 import { Buffer } from "buffer";
+import { PDFName } from "@pdfme/pdf-lib";
 import * as acorn from "acorn";
 //#region src/version.ts
-var PDFME_VERSION = "6.1.0";
+var PDFME_VERSION = "6.1.1";
+//#endregion
+//#region src/pageSize.ts
+var PAGE_SIZE_PRESETS = {
+	A3: {
+		width: 297,
+		height: 420
+	},
+	A4: {
+		width: 210,
+		height: 297
+	},
+	A5: {
+		width: 148,
+		height: 210
+	},
+	A6: {
+		width: 105,
+		height: 148
+	},
+	B4: {
+		width: 250,
+		height: 353
+	},
+	B5: {
+		width: 176,
+		height: 250
+	},
+	B6: {
+		width: 125,
+		height: 176
+	},
+	Letter: {
+		width: 215.9,
+		height: 279.4
+	},
+	Legal: {
+		width: 215.9,
+		height: 355.6
+	},
+	Tabloid: {
+		width: 279.4,
+		height: 431.8
+	}
+};
+var resolvePageSize = (size = "A4", orientation = "portrait") => {
+	const resolved = typeof size === "string" ? PAGE_SIZE_PRESETS[size] : {
+		width: size.width,
+		height: size.height
+	};
+	if (!resolved) throw new Error(`@pdfme/common: unknown page size preset "${String(size)}"`);
+	if (orientation === "landscape") return {
+		width: resolved.height,
+		height: resolved.width
+	};
+	return {
+		width: resolved.width,
+		height: resolved.height
+	};
+};
+var detectPaperSize = (width, height, tolerance = 2) => {
+	const entries = Object.entries(PAGE_SIZE_PRESETS);
+	for (const [name, size] of entries) if (Math.abs(width - size.width) <= tolerance && Math.abs(height - size.height) <= tolerance || Math.abs(width - size.height) <= tolerance && Math.abs(height - size.width) <= tolerance) return `${name} ${width < height ? "portrait" : "landscape"}`;
+	return null;
+};
 //#endregion
 //#region src/constants.ts
 var PT_TO_PX_RATIO = 1.333;
@@ -13,8 +78,7 @@ var ZOOM = 3.7795275591;
 * Blank A4 PDF size.
 */
 var BLANK_A4_PDF = {
-	width: 210,
-	height: 297,
+	...PAGE_SIZE_PRESETS.A4,
 	padding: [
 		10,
 		10,
@@ -104,6 +168,9 @@ z.object({
 	"schemas.text.max": z.string(),
 	"schemas.text.fit": z.string(),
 	"schemas.text.dynamicFontSize": z.string(),
+	"schemas.text.overflow": z.string(),
+	"schemas.text.overflowVisible": z.string(),
+	"schemas.text.overflowExpand": z.string(),
 	"schemas.text.format": z.string(),
 	"schemas.text.plain": z.string(),
 	"schemas.text.inlineMarkdown": z.string(),
@@ -133,7 +200,18 @@ z.object({
 	"schemas.date.locale": z.string(),
 	"schemas.select.options": z.string(),
 	"schemas.select.optionPlaceholder": z.string(),
-	"schemas.radioGroup.groupName": z.string()
+	"schemas.radioGroup.groupName": z.string(),
+	"schemas.list.listStyle": z.string(),
+	"schemas.list.bullet": z.string(),
+	"schemas.list.ordered": z.string(),
+	"schemas.list.markerWidth": z.string(),
+	"schemas.list.markerGap": z.string(),
+	"schemas.list.indentSize": z.string(),
+	"schemas.list.itemSpacing": z.string(),
+	"schemas.list.addItem": z.string(),
+	"schemas.list.removeItem": z.string(),
+	"schemas.list.indentItem": z.string(),
+	"schemas.list.outdentItem": z.string()
 });
 z.enum([
 	"viewer",
@@ -145,6 +223,11 @@ z.object({
 	height: z.number(),
 	width: z.number()
 });
+var DynamicLayoutSplitRange = z.object({
+	unit: z.string().min(1),
+	start: z.number(),
+	end: z.number().optional()
+});
 var Schema = z.object({
 	name: z.string(),
 	type: z.string(),
@@ -159,10 +242,7 @@ var Schema = z.object({
 	opacity: z.number().optional(),
 	readOnly: z.boolean().optional(),
 	required: z.boolean().optional(),
-	__bodyRange: z.object({
-		start: z.number(),
-		end: z.number().optional()
-	}).optional(),
+	__splitRange: DynamicLayoutSplitRange.optional(),
 	__isSplit: z.boolean().optional()
 }).passthrough();
 var SchemaForUIAdditionalInfo = z.object({ id: z.string() });
@@ -350,6 +430,130 @@ var isUrlSafeToFetch = (urlString) => {
 	}
 	return true;
 };
+var SAFE_LINK_URI_PROTOCOLS = new Set([
+	"http:",
+	"https:",
+	"mailto:"
+]);
+var INTERNAL_LINK_CACHE_KEY = "pdfme-internal-link-cache";
+var normalizeSafeLinkUri = (uri) => {
+	const trimmed = uri.trim();
+	if (!trimmed) return void 0;
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return;
+	}
+	return SAFE_LINK_URI_PROTOCOLS.has(parsed.protocol.toLowerCase()) ? trimmed : void 0;
+};
+var getInternalLinkTarget = (href) => {
+	const trimmed = href.trim();
+	if (!trimmed.startsWith("#") || trimmed.length === 1) return void 0;
+	let target = trimmed.slice(1);
+	try {
+		target = decodeURIComponent(target);
+	} catch {}
+	target = target.trim();
+	if (!target || Array.from(target).some((char) => {
+		const code = char.charCodeAt(0);
+		return code < 32 || code === 127;
+	})) return;
+	return target;
+};
+var normalizeInternalLinkHref = (href) => {
+	const target = getInternalLinkTarget(href);
+	return target ? `#${target}` : void 0;
+};
+var normalizeLinkHref = (href) => normalizeSafeLinkUri(href) ?? normalizeInternalLinkHref(href);
+var getInternalLinkCache = (_cache) => {
+	let cache = _cache.get(INTERNAL_LINK_CACHE_KEY);
+	if (!cache) {
+		cache = {
+			anchors: /* @__PURE__ */ new Map(),
+			annotations: []
+		};
+		_cache.set(INTERNAL_LINK_CACHE_KEY, cache);
+	}
+	return cache;
+};
+var resetInternalLinkAnnotations = (_cache) => {
+	_cache.set(INTERNAL_LINK_CACHE_KEY, {
+		anchors: /* @__PURE__ */ new Map(),
+		annotations: []
+	});
+};
+var registerInternalLinkAnchor = (arg) => {
+	const { _cache, name, page, x, y } = arg;
+	if (!name) return;
+	const cache = getInternalLinkCache(_cache);
+	const anchors = cache.anchors.get(name) ?? [];
+	anchors.push({
+		name,
+		page,
+		x,
+		y
+	});
+	cache.anchors.set(name, anchors);
+};
+var registerInternalLinkAnnotation = (arg) => {
+	const { _cache, page, targetName, rect, borderWidth } = arg;
+	if (!targetName || rect.width <= 0 || rect.height <= 0) return;
+	getInternalLinkCache(_cache).annotations.push({
+		page,
+		targetName,
+		rect,
+		borderWidth
+	});
+};
+var addGoToLinkAnnotation = (arg) => {
+	const { pdfDoc, page, target, rect, borderWidth = 0 } = arg;
+	if (rect.width <= 0 || rect.height <= 0) return;
+	const annotationRef = pdfDoc.context.register(pdfDoc.context.obj({
+		Type: PDFName.of("Annot"),
+		Subtype: PDFName.of("Link"),
+		Rect: [
+			rect.x,
+			rect.y,
+			rect.x + rect.width,
+			rect.y + rect.height
+		],
+		Border: [
+			0,
+			0,
+			borderWidth
+		],
+		A: {
+			Type: PDFName.of("Action"),
+			S: PDFName.of("GoTo"),
+			D: [
+				target.page.ref,
+				PDFName.of("XYZ"),
+				target.x,
+				target.y,
+				null
+			]
+		}
+	}));
+	page.node.addAnnot(annotationRef);
+};
+var applyInternalLinkAnnotations = (arg) => {
+	const { _cache, pdfDoc } = arg;
+	const cache = getInternalLinkCache(_cache);
+	cache.annotations.forEach((annotation) => {
+		const anchors = cache.anchors.get(annotation.targetName) ?? [];
+		if (anchors.length === 0) throw new Error(`[@pdfme/generator] Internal link target "#${annotation.targetName}" was not found.`);
+		if (anchors.length > 1) throw new Error(`[@pdfme/generator] Internal link target "#${annotation.targetName}" is ambiguous because multiple schemas use that name.`);
+		addGoToLinkAnnotation({
+			pdfDoc,
+			page: annotation.page,
+			target: anchors[0],
+			rect: annotation.rect,
+			borderWidth: annotation.borderWidth
+		});
+	});
+	resetInternalLinkAnnotations(_cache);
+};
 var getB64BasePdf = async (customPdf) => {
 	if (typeof customPdf === "string" && !customPdf.startsWith("data:application/pdf;") && typeof window !== "undefined") {
 		if (!isUrlSafeToFetch(customPdf)) throw Error("[@pdfme/common] Invalid or unsafe URL for basePdf. Only http: and https: URLs pointing to public hosts are allowed.");
@@ -431,191 +635,6 @@ var checkGenerateProps = (data) => {
 	checkProps(data, GenerateProps);
 };
 //#endregion
-//#region src/dynamicTemplate.ts
-/** Floating point tolerance for comparisons */
-var EPSILON = .01;
-/** Calculate the content height of a page (drawable area excluding padding) */
-var getContentHeight = (basePdf) => basePdf.height - basePdf.padding[0] - basePdf.padding[2];
-/** Get the input value for a schema */
-var getSchemaValue = (schema, input) => (schema.readOnly ? schema.content : input?.[schema.name]) || "";
-/**
-* Normalize schemas within a single page into layout items.
-* Returns items sorted by Y coordinate with their order preserved.
-*/
-function normalizePageSchemas(pageSchemas, paddingTop) {
-	const items = [];
-	const orderMap = /* @__PURE__ */ new Map();
-	pageSchemas.forEach((schema, index) => {
-		const localY = Math.max(0, schema.position.y - paddingTop);
-		items.push({
-			schema: cloneDeep(schema),
-			baseY: localY,
-			height: schema.height,
-			dynamicHeights: [schema.height]
-		});
-		orderMap.set(schema.name, index);
-	});
-	items.sort((a, b) => {
-		if (Math.abs(a.baseY - b.baseY) > EPSILON) return a.baseY - b.baseY;
-		return (orderMap.get(a.schema.name) ?? 0) - (orderMap.get(b.schema.name) ?? 0);
-	});
-	return {
-		items,
-		orderMap
-	};
-}
-/**
-* Place rows on pages, splitting across pages as needed.
-* @returns The final global Y coordinate after placement
-*/
-function placeRowsOnPages(schema, dynamicHeights, startGlobalY, contentHeight, paddingTop, pages) {
-	let currentRowIndex = 0;
-	let currentPageIndex = Math.floor(startGlobalY / contentHeight);
-	let currentYInPage = startGlobalY % contentHeight;
-	if (currentYInPage < 0) currentYInPage = 0;
-	let actualGlobalEndY = 0;
-	const isSplittable = dynamicHeights.length > 1;
-	while (currentRowIndex < dynamicHeights.length) {
-		while (pages.length <= currentPageIndex) pages.push([]);
-		const spaceLeft = contentHeight - currentYInPage;
-		if (dynamicHeights[currentRowIndex] > spaceLeft + EPSILON) {
-			if (!(Math.abs(spaceLeft - contentHeight) <= EPSILON)) {
-				currentPageIndex++;
-				currentYInPage = 0;
-				continue;
-			}
-		}
-		let chunkHeight = 0;
-		const startRowIndex = currentRowIndex;
-		while (currentRowIndex < dynamicHeights.length) {
-			const h = dynamicHeights[currentRowIndex];
-			if (currentYInPage + chunkHeight + h <= contentHeight + EPSILON) {
-				chunkHeight += h;
-				currentRowIndex++;
-			} else break;
-		}
-		const isAtPageTop = currentYInPage <= EPSILON;
-		if (isSplittable && startRowIndex === 0 && currentRowIndex === 1 && dynamicHeights.length > 1 && !isAtPageTop) {
-			currentRowIndex = 0;
-			currentPageIndex++;
-			currentYInPage = 0;
-			continue;
-		}
-		if (currentRowIndex === startRowIndex) {
-			chunkHeight += dynamicHeights[currentRowIndex];
-			currentRowIndex++;
-		}
-		const newSchema = {
-			...schema,
-			height: chunkHeight,
-			position: {
-				...schema.position,
-				y: currentYInPage + paddingTop
-			}
-		};
-		if (isSplittable) {
-			newSchema.__bodyRange = {
-				start: startRowIndex === 0 ? 0 : startRowIndex - 1,
-				end: currentRowIndex - 1
-			};
-			newSchema.__isSplit = startRowIndex > 0;
-		}
-		pages[currentPageIndex].push(newSchema);
-		currentYInPage += chunkHeight;
-		if (currentYInPage >= contentHeight - EPSILON) {
-			currentPageIndex++;
-			currentYInPage = 0;
-		}
-		actualGlobalEndY = currentPageIndex * contentHeight + currentYInPage;
-	}
-	return actualGlobalEndY;
-}
-/** Sort elements within each page by their original order */
-function sortPagesByOrder(pages, orderMap) {
-	pages.forEach((page) => {
-		page.sort((a, b) => (orderMap.get(a.name) ?? 0) - (orderMap.get(b.name) ?? 0));
-	});
-}
-/** Remove trailing empty pages */
-function removeTrailingEmptyPages(pages) {
-	while (pages.length > 1 && pages[pages.length - 1].length === 0) pages.pop();
-}
-/**
-* Process a single template page that has dynamic content.
-* Uses the same layout algorithm as the original implementation,
-* but scoped to a single page's schemas.
-*/
-function processDynamicPage(items, orderMap, contentHeight, paddingTop) {
-	const pages = [];
-	let totalYOffset = 0;
-	for (const item of items) {
-		const currentGlobalStartY = item.baseY + totalYOffset;
-		totalYOffset = placeRowsOnPages(item.schema, item.dynamicHeights, currentGlobalStartY, contentHeight, paddingTop, pages) - (item.baseY + item.height);
-	}
-	sortPagesByOrder(pages, orderMap);
-	removeTrailingEmptyPages(pages);
-	return pages;
-}
-/**
-* Process a template containing tables with dynamic heights
-* and generate a new template with proper page breaks.
-*
-* Processing is done page-by-page:
-* - Pages with height changes are processed with full layout calculations
-* - Pages without height changes are copied as-is (no offset propagation between pages)
-*
-* This reduces computation cost by:
-* 1. Limiting layout calculations to pages that need them
-* 2. Avoiding cross-page offset propagation for static pages
-*/
-var getDynamicTemplate = async (arg) => {
-	const { template, input, options, _cache, getDynamicHeights } = arg;
-	const basePdf = template.basePdf;
-	if (!isBlankPdf(basePdf)) return template;
-	const contentHeight = getContentHeight(basePdf);
-	const paddingTop = basePdf.padding[0];
-	const resultPages = [];
-	const PARALLEL_LIMIT = 10;
-	for (let pageIndex = 0; pageIndex < template.schemas.length; pageIndex++) {
-		const pageSchemas = template.schemas[pageIndex];
-		const { items, orderMap } = normalizePageSchemas(pageSchemas, paddingTop);
-		for (let i = 0; i < items.length; i += PARALLEL_LIMIT) {
-			const chunk = items.slice(i, i + PARALLEL_LIMIT);
-			const chunkResults = await Promise.all(chunk.map((item) => {
-				return getDynamicHeights(getSchemaValue(item.schema, input), {
-					schema: item.schema,
-					basePdf,
-					options,
-					_cache
-				}).then((heights) => heights.length === 0 ? [0] : heights);
-			}));
-			for (let j = 0; j < chunkResults.length; j++) items[i + j].dynamicHeights = chunkResults[j];
-		}
-		const processedPages = processDynamicPage(items, orderMap, contentHeight, paddingTop);
-		resultPages.push(...processedPages);
-	}
-	removeTrailingEmptyPages(resultPages);
-	if (resultPages.length === template.schemas.length) {
-		let unchanged = true;
-		for (let i = 0; i < resultPages.length && unchanged; i++) {
-			if (resultPages[i].length !== template.schemas[i].length) {
-				unchanged = false;
-				break;
-			}
-			for (let j = 0; j < resultPages[i].length && unchanged; j++) {
-				const orig = template.schemas[i][j];
-				const result = resultPages[i][j];
-				if (Math.abs(orig.height - result.height) > EPSILON || Math.abs(orig.position.y - result.position.y) > EPSILON) unchanged = false;
-			}
-		}
-		if (unchanged) return template;
-	}
-	return {
-		basePdf,
-		schemas: resultPages
-	};
-};
-//#endregion
 //#region src/expression.ts
 var expressionCache = /* @__PURE__ */ new Map();
 /**
@@ -935,6 +954,223 @@ var replacePlaceholders = (arg) => {
 	});
 };
 //#endregion
+//#region src/dynamicTemplate.ts
+/** Floating point tolerance for comparisons */
+var EPSILON = .01;
+/** Calculate the content height of a page (drawable area excluding padding) */
+var getContentHeight = (basePdf) => basePdf.height - basePdf.padding[0] - basePdf.padding[2];
+/** Get the input value for a schema */
+var getSchemaValue = (schema, input, schemas) => {
+	if (!schema.readOnly) return input?.[schema.name] || "";
+	if (schema.type !== "text" && schema.type !== "multiVariableText") return schema.content || "";
+	return replacePlaceholders({
+		content: schema.content || "",
+		variables: input,
+		schemas
+	});
+};
+/**
+* Normalize schemas within a single page into layout items.
+* Returns items sorted by Y coordinate with their order preserved.
+*/
+function normalizePageSchemas(pageSchemas, paddingTop) {
+	const items = [];
+	const orderMap = /* @__PURE__ */ new Map();
+	pageSchemas.forEach((schema, index) => {
+		const localY = Math.max(0, schema.position.y - paddingTop);
+		items.push({
+			schema: cloneDeep(schema),
+			baseY: localY,
+			height: schema.height,
+			dynamicLayout: { heights: [schema.height] }
+		});
+		orderMap.set(schema.name, index);
+	});
+	items.sort((a, b) => {
+		if (Math.abs(a.baseY - b.baseY) > EPSILON) return a.baseY - b.baseY;
+		return (orderMap.get(a.schema.name) ?? 0) - (orderMap.get(b.schema.name) ?? 0);
+	});
+	return {
+		items,
+		orderMap
+	};
+}
+/**
+* Place height units on pages, splitting across pages as needed.
+* @returns The final global Y coordinate after placement
+*/
+function placeUnitsOnPages(schema, dynamicLayout, startGlobalY, contentHeight, paddingTop, pages) {
+	const dynamicHeights = dynamicLayout.heights;
+	let currentUnitIndex = 0;
+	let currentPageIndex = Math.floor(startGlobalY / contentHeight);
+	let currentYInPage = startGlobalY % contentHeight;
+	if (currentYInPage < 0) currentYInPage = 0;
+	let actualGlobalEndY = 0;
+	const isSplittable = dynamicHeights.length > 1;
+	while (currentUnitIndex < dynamicHeights.length) {
+		while (pages.length <= currentPageIndex) pages.push([]);
+		const spaceLeft = contentHeight - currentYInPage;
+		if (dynamicHeights[currentUnitIndex] > spaceLeft + EPSILON) {
+			if (!(Math.abs(spaceLeft - contentHeight) <= EPSILON)) {
+				currentPageIndex++;
+				currentYInPage = 0;
+				continue;
+			}
+		}
+		let chunkHeight = 0;
+		const startUnitIndex = currentUnitIndex;
+		while (currentUnitIndex < dynamicHeights.length) {
+			const h = dynamicHeights[currentUnitIndex];
+			if (currentYInPage + chunkHeight + h <= contentHeight + EPSILON) {
+				chunkHeight += h;
+				currentUnitIndex++;
+			} else break;
+		}
+		const isAtPageTop = currentYInPage <= EPSILON;
+		if (dynamicLayout.avoidFirstUnitOnly && isSplittable && startUnitIndex === 0 && currentUnitIndex === 1 && dynamicHeights.length > 1 && !isAtPageTop) {
+			currentUnitIndex = 0;
+			currentPageIndex++;
+			currentYInPage = 0;
+			continue;
+		}
+		if (currentUnitIndex === startUnitIndex) {
+			chunkHeight += dynamicHeights[currentUnitIndex];
+			currentUnitIndex++;
+		}
+		const patch = dynamicLayout.patchSplitSchema?.({
+			schema,
+			start: startUnitIndex,
+			end: currentUnitIndex,
+			isSplit: startUnitIndex > 0,
+			chunkHeight
+		}) ?? {};
+		const newSchema = {
+			...schema,
+			...patch,
+			height: chunkHeight,
+			position: {
+				...schema.position,
+				y: currentYInPage + paddingTop
+			}
+		};
+		pages[currentPageIndex].push(newSchema);
+		currentYInPage += chunkHeight;
+		if (currentYInPage >= contentHeight - EPSILON) {
+			currentPageIndex++;
+			currentYInPage = 0;
+		}
+		actualGlobalEndY = currentPageIndex * contentHeight + currentYInPage;
+	}
+	return actualGlobalEndY;
+}
+/** Sort elements within each page by their original order */
+function sortPagesByOrder(pages, orderMap) {
+	pages.forEach((page) => {
+		page.sort((a, b) => (orderMap.get(a.name) ?? 0) - (orderMap.get(b.name) ?? 0));
+	});
+}
+/** Remove trailing empty pages */
+function removeTrailingEmptyPages(pages) {
+	while (pages.length > 1 && pages[pages.length - 1].length === 0) pages.pop();
+}
+/**
+* Process a single template page that has dynamic content.
+* Uses the same layout algorithm as the original implementation,
+* but scoped to a single page's schemas.
+*/
+function processDynamicPage(items, orderMap, contentHeight, paddingTop) {
+	const pages = [];
+	let totalYOffset = 0;
+	for (const item of items) {
+		const currentGlobalStartY = item.baseY + totalYOffset;
+		totalYOffset = placeUnitsOnPages(item.schema, item.dynamicLayout, currentGlobalStartY, contentHeight, paddingTop, pages) - (item.baseY + item.height);
+	}
+	sortPagesByOrder(pages, orderMap);
+	removeTrailingEmptyPages(pages);
+	return pages;
+}
+var normalizeDynamicLayoutResult = (result) => {
+	const dynamicLayout = Array.isArray(result) ? { heights: result } : result;
+	return {
+		...dynamicLayout,
+		heights: dynamicLayout.heights.length === 0 ? [0] : dynamicLayout.heights
+	};
+};
+/**
+* Process a template containing tables with dynamic heights
+* and generate a new template with proper page breaks.
+*
+* Processing is done page-by-page:
+* - Pages with height changes are processed with full layout calculations
+* - Pages without height changes are copied as-is (no offset propagation between pages)
+*
+* This reduces computation cost by:
+* 1. Limiting layout calculations to pages that need them
+* 2. Avoiding cross-page offset propagation for static pages
+*/
+var getDynamicTemplate = async (arg) => {
+	const { template, input, options, _cache, getDynamicHeights } = arg;
+	const basePdf = template.basePdf;
+	if (!isBlankPdf(basePdf)) return template;
+	const contentHeight = getContentHeight(basePdf);
+	const paddingTop = basePdf.padding[0];
+	const resultPages = [];
+	const PARALLEL_LIMIT = 10;
+	for (let pageIndex = 0; pageIndex < template.schemas.length; pageIndex++) {
+		const pageSchemas = template.schemas[pageIndex];
+		const { items, orderMap } = normalizePageSchemas(pageSchemas, paddingTop);
+		for (let i = 0; i < items.length; i += PARALLEL_LIMIT) {
+			const chunk = items.slice(i, i + PARALLEL_LIMIT);
+			const chunkResults = await Promise.all(chunk.map((item) => {
+				return getDynamicHeights(getSchemaValue(item.schema, input, template.schemas), {
+					schema: item.schema,
+					basePdf,
+					options,
+					_cache
+				}).then(normalizeDynamicLayoutResult);
+			}));
+			for (let j = 0; j < chunkResults.length; j++) items[i + j].dynamicLayout = chunkResults[j];
+		}
+		const processedPages = processDynamicPage(items, orderMap, contentHeight, paddingTop);
+		resultPages.push(...processedPages);
+	}
+	removeTrailingEmptyPages(resultPages);
+	if (resultPages.length === template.schemas.length) {
+		let unchanged = true;
+		for (let i = 0; i < resultPages.length && unchanged; i++) {
+			if (resultPages[i].length !== template.schemas[i].length) {
+				unchanged = false;
+				break;
+			}
+			for (let j = 0; j < resultPages[i].length && unchanged; j++) {
+				const orig = template.schemas[i][j];
+				const result = resultPages[i][j];
+				if (Math.abs(orig.height - result.height) > EPSILON || Math.abs(orig.position.y - result.position.y) > EPSILON) unchanged = false;
+			}
+		}
+		if (unchanged) return template;
+	}
+	return {
+		basePdf,
+		schemas: resultPages
+	};
+};
+//#endregion
+//#region src/splitRange.ts
+var createDynamicLayoutSplitRange = (unit, start, end) => ({
+	unit,
+	start,
+	...end === void 0 ? {} : { end }
+});
+var getDynamicLayoutSplitRange = (schema, unit) => {
+	const range = schema.__splitRange;
+	if (range?.unit !== unit) return void 0;
+	return {
+		start: range.start,
+		...range.end === void 0 ? {} : { end: range.end }
+	};
+};
+//#endregion
 //#region src/pluginRegistry.ts
 /**
 * Wraps plugins collection with utility methods
@@ -961,6 +1197,6 @@ var pluginRegistry = (plugins) => {
 	};
 };
 //#endregion
-export { BLANK_A4_PDF, BLANK_PDF, CUSTOM_A4_PDF, DEFAULT_FONT_NAME, MM_TO_PT_RATIO, PDFME_VERSION, PT_TO_MM_RATIO, PT_TO_PX_RATIO, ZOOM, b64toUint8Array, checkDesignerProps, checkFont, checkGenerateProps, checkInputs, checkPreviewProps, checkTemplate, checkUIOptions, checkUIProps, cloneDeep, getB64BasePdf, getDefaultFont, getDynamicTemplate, getFallbackFontName, getInputFromTemplate, isBlankPdf, isHexValid, isUrlSafeToFetch, mm2pt, pluginRegistry, pt2mm, pt2px, px2mm, replacePlaceholders };
+export { BLANK_A4_PDF, BLANK_PDF, CUSTOM_A4_PDF, DEFAULT_FONT_NAME, MM_TO_PT_RATIO, PAGE_SIZE_PRESETS, PDFME_VERSION, PT_TO_MM_RATIO, PT_TO_PX_RATIO, ZOOM, applyInternalLinkAnnotations, b64toUint8Array, checkDesignerProps, checkFont, checkGenerateProps, checkInputs, checkPreviewProps, checkTemplate, checkUIOptions, checkUIProps, cloneDeep, createDynamicLayoutSplitRange, detectPaperSize, getB64BasePdf, getDefaultFont, getDynamicLayoutSplitRange, getDynamicTemplate, getFallbackFontName, getInputFromTemplate, getInternalLinkTarget, isBlankPdf, isHexValid, isUrlSafeToFetch, mm2pt, normalizeInternalLinkHref, normalizeLinkHref, normalizeSafeLinkUri, pluginRegistry, pt2mm, pt2px, px2mm, registerInternalLinkAnchor, registerInternalLinkAnnotation, replacePlaceholders, resetInternalLinkAnnotations, resolvePageSize };
 
 //# sourceMappingURL=index.js.map