@pdfme/schemas 6.1.0 → 6.1.1-dev.11

package/dist/list/constants.d.ts

@@ -0,0 +1,10 @@
+import type { LIST_STYLE } from './types.js';
+export declare const LIST_STYLE_BULLET: LIST_STYLE;
+export declare const LIST_STYLE_ORDERED: LIST_STYLE;
+export declare const DEFAULT_LIST_STYLE: LIST_STYLE;
+export declare const DEFAULT_MARKER = "\u2022";
+export declare const DEFAULT_MARKER_WIDTH = 6;
+export declare const DEFAULT_MARKER_GAP = 2;
+export declare const DEFAULT_INDENT_SIZE = 6;
+export declare const DEFAULT_ITEM_SPACING = 1;
+export declare const MAX_INDENT_LEVEL = 8;

package/dist/list/dynamicTemplate.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicLayoutArgs, DynamicLayoutResult } from '@pdfme/common';
+export declare const getDynamicLayoutForList: (value: string, args: DynamicLayoutArgs) => Promise<DynamicLayoutResult>;

package/dist/list/helper.d.ts

@@ -0,0 +1,15 @@
+import { CommonOptions } from '@pdfme/common';
+import type { ListItem, ListLayout, ListSchema } from './types.js';
+export declare const normalizeListItems: (value: unknown) => string[];
+export declare const parseListItem: (value: string) => ListItem;
+export declare const normalizeListItemEntries: (value: unknown) => ListItem[];
+export declare const serializeListItems: (items: ListItem[]) => string;
+export declare const getListMarkers: (schema: ListSchema, items: string[]) => string[];
+export declare const calculateListLayout: (arg: {
+    schema: ListSchema;
+    items: string[];
+    markerItems?: string[];
+    startIndex: number;
+    options: CommonOptions;
+    _cache: Map<string | number, unknown>;
+}) => Promise<ListLayout>;

package/dist/list/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@pdfme/common';
+import type { ListSchema } from './types.js';
+declare const listSchema: Plugin<ListSchema>;
+export default listSchema;

package/dist/list/pdfRender.d.ts

@@ -0,0 +1,3 @@
+import type { PDFRenderProps } from '@pdfme/common';
+import type { ListSchema } from './types.js';
+export declare const pdfRender: (arg: PDFRenderProps<ListSchema>) => Promise<void>;

package/dist/list/propPanel.d.ts

@@ -0,0 +1,3 @@
+import type { PropPanel } from '@pdfme/common';
+import type { ListSchema } from './types.js';
+export declare const propPanel: PropPanel<ListSchema>;

package/dist/list/types.d.ts

@@ -0,0 +1,31 @@
+import type { TextSchema } from '../text/types.js';
+export type LIST_STYLE = 'bullet' | 'ordered';
+export type ListSchema = TextSchema & {
+    listStyle: LIST_STYLE;
+    markerWidth: number;
+    markerGap: number;
+    indentSize?: number;
+    itemSpacing: number;
+};
+export type ListItem = {
+    text: string;
+    level: number;
+};
+export type ListItemLayout = {
+    item: string;
+    itemIndex: number;
+    level: number;
+    marker: string;
+    lines: string[];
+    height: number;
+    markerX: number;
+    bodyX: number;
+    bodyWidth: number;
+};
+export type ListLayout = {
+    items: ListItemLayout[];
+    totalHeight: number;
+    markerWidth: number;
+    markerGap: number;
+    indentSize: number;
+};

package/dist/list/uiRender.d.ts

@@ -0,0 +1,3 @@
+import { UIRenderProps } from '@pdfme/common';
+import type { ListSchema } from './types.js';
+export declare const uiRender: (arg: UIRenderProps<ListSchema>) => Promise<void>;

package/dist/lists.d.ts

@@ -0,0 +1,4 @@
+export { getDynamicLayoutForList } from './list/dynamicTemplate.js';
+export { createListItemSplitRange, getListItemRange, LIST_ITEM_SPLIT_UNIT } from './splitRange.js';
+export { normalizeListItems, normalizeListItemEntries, serializeListItems, getListMarkers, calculateListLayout, } from './list/helper.js';
+export type { ListItem, ListSchema, ListLayout, ListItemLayout, LIST_STYLE } from './list/types.js';

package/dist/lists.js

@@ -0,0 +1,3 @@
+import { a as createListItemSplitRange, c as getListItemRange, n as LIST_ITEM_SPLIT_UNIT } from "./splitRange-CpXivbmJ.js";
+import { a as normalizeListItems, i as normalizeListItemEntries, n as calculateListLayout, o as serializeListItems, r as getListMarkers, t as getDynamicLayoutForList } from "./dynamicTemplate-Fn7mpUsu.js";
+export { LIST_ITEM_SPLIT_UNIT, calculateListLayout, createListItemSplitRange, getDynamicLayoutForList, getListItemRange, getListMarkers, normalizeListItemEntries, normalizeListItems, serializeListItems };

package/dist/measure-Bjmh9Ro3.js

@@ -0,0 +1,585 @@
+import { B as SYNTHETIC_BOLD_OFFSET_RATIO, P as FONT_SIZE_ADJUSTMENT, d as calculateDynamicFontSize, g as heightOfFontAtSize, h as getFontKitFont, u as getTextLineRange, v as splitTextToSize, y as widthOfTextAtSize } from "./splitRange-CpXivbmJ.js";
+import { getDefaultFont, getFallbackFontName, mm2pt, normalizeLinkHref, pt2mm } from "@pdfme/common";
+//#region src/text/inlineMarkdown.ts
+var MARKDOWN_ESCAPABLE_CHARS = new Set([
+	"\\",
+	"*",
+	"~",
+	"`",
+	"[",
+	"]",
+	"(",
+	")"
+]);
+var MARKDOWN_ESCAPE_PATTERN = /[\\*~`[\]()]/g;
+var MARKDOWN_UNESCAPE_PATTERN = /\\([\\*~`[\]()])/g;
+var sameStyle = (a, b) => Boolean(a.bold) === Boolean(b.bold) && Boolean(a.italic) === Boolean(b.italic) && Boolean(a.strikethrough) === Boolean(b.strikethrough) && Boolean(a.code) === Boolean(b.code) && a.href === b.href;
+var appendRun = (runs, text, style) => {
+	if (!text) return;
+	const lastRun = runs.at(-1);
+	if (lastRun && sameStyle(lastRun, style)) {
+		lastRun.text += text;
+		return;
+	}
+	runs.push({
+		text,
+		...style.bold ? { bold: true } : {},
+		...style.italic ? { italic: true } : {},
+		...style.strikethrough ? { strikethrough: true } : {},
+		...style.code ? { code: true } : {},
+		...style.href ? { href: style.href } : {}
+	});
+};
+var findClosingDelimiter = (value, delimiter, from) => {
+	for (let i = from; i < value.length; i++) {
+		if (value[i] === "\\") {
+			i += 1;
+			continue;
+		}
+		if (delimiter !== "`" && value[i] === "`") {
+			const codeEnd = findClosingDelimiter(value, "`", i + 1);
+			if (codeEnd === -1) continue;
+			i = codeEnd;
+			continue;
+		}
+		if (value.startsWith(delimiter, i)) return i;
+	}
+	return -1;
+};
+var getDelimiter = (value, index) => {
+	if (value[index] === "`") return "`";
+	if (value.startsWith("***", index)) return "***";
+	if (value.startsWith("**", index)) return "**";
+	if (value.startsWith("~~", index)) return "~~";
+	if (value[index] === "*") return "*";
+	return "";
+};
+var findLinkLabelEnd = (value, from, to) => {
+	for (let index = from; index < to; index += 1) {
+		if (value[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (value[index] === "]") return index;
+	}
+	return -1;
+};
+var findLinkDestinationEnd = (value, from, to) => {
+	let depth = 0;
+	for (let index = from; index < to; index += 1) {
+		if (value[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (value[index] === "(") {
+			depth += 1;
+			continue;
+		}
+		if (value[index] === ")") {
+			if (depth === 0) return index;
+			depth -= 1;
+		}
+	}
+	return -1;
+};
+var parseLinkAt = (value, index, to) => {
+	if (value[index] !== "[") return void 0;
+	const labelEnd = findLinkLabelEnd(value, index + 1, to);
+	if (labelEnd === -1 || value[labelEnd + 1] !== "(") return void 0;
+	const destinationStart = labelEnd + 2;
+	const destinationEnd = findLinkDestinationEnd(value, destinationStart, to);
+	if (destinationEnd === -1) return void 0;
+	const safeHref = normalizeLinkHref(value.slice(destinationStart, destinationEnd).replace(MARKDOWN_UNESCAPE_PATTERN, "$1"));
+	if (!safeHref) return void 0;
+	return {
+		labelStart: index + 1,
+		labelEnd,
+		href: safeHref,
+		end: destinationEnd + 1
+	};
+};
+var mergeStyle = (style, delimiter) => {
+	if (delimiter === "***") return {
+		...style,
+		bold: true,
+		italic: true
+	};
+	if (delimiter === "**") return {
+		...style,
+		bold: true
+	};
+	if (delimiter === "*") return {
+		...style,
+		italic: true
+	};
+	if (delimiter === "~~") return {
+		...style,
+		strikethrough: true
+	};
+	return style;
+};
+var parseRange = (value, from, to, style) => {
+	const runs = [];
+	let buffer = "";
+	const flush = () => {
+		appendRun(runs, buffer, style);
+		buffer = "";
+	};
+	for (let index = from; index < to; index++) {
+		const char = value[index];
+		if (char === "\\" && index + 1 < to && MARKDOWN_ESCAPABLE_CHARS.has(value[index + 1])) {
+			buffer += value[index + 1];
+			index += 1;
+			continue;
+		}
+		const link = style.href ? void 0 : parseLinkAt(value, index, to);
+		if (link) {
+			flush();
+			parseRange(value, link.labelStart, link.labelEnd, {
+				...style,
+				href: link.href
+			}).forEach((run) => appendRun(runs, run.text, run));
+			index = link.end - 1;
+			continue;
+		}
+		const delimiter = getDelimiter(value, index);
+		if (!delimiter) {
+			buffer += char;
+			continue;
+		}
+		const closingIndex = findClosingDelimiter(value, delimiter, index + delimiter.length);
+		if (closingIndex === -1 || closingIndex + delimiter.length > to) {
+			buffer += char;
+			continue;
+		}
+		flush();
+		if (delimiter === "`") appendRun(runs, value.slice(index + 1, closingIndex).replace(MARKDOWN_UNESCAPE_PATTERN, "$1"), {
+			...style,
+			code: true
+		});
+		else parseRange(value, index + delimiter.length, closingIndex, mergeStyle(style, delimiter)).forEach((run) => appendRun(runs, run.text, run));
+		index = closingIndex + delimiter.length - 1;
+	}
+	flush();
+	return runs;
+};
+var parseInlineMarkdown = (value) => {
+	if (!value) return [];
+	return parseRange(value, 0, value.length, {});
+};
+var escapeInlineMarkdown = (value) => value.replace(MARKDOWN_ESCAPE_PATTERN, (char) => `\\${char}`);
+var stripInlineMarkdown = (value) => parseInlineMarkdown(value).map((run) => run.text).join("");
+//#endregion
+//#region src/text/richText.ts
+var richTextWordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+var richTextGraphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var getBaseFontName = (schema, font) => schema.fontName && font[schema.fontName] ? schema.fontName : getFallbackFontName(font);
+var getLoadedFontName = (font, fontName) => fontName && font[fontName] ? fontName : void 0;
+var isInlineMarkdownTextSchema = (schema) => schema.textFormat === "inline-markdown" && !(schema.type === "text" && schema.readOnly !== true);
+var resolveFontVariant = (run, schema, font) => {
+	const baseFontName = getBaseFontName(schema, font);
+	const variants = schema.fontVariants ?? {};
+	const fallback = schema.fontVariantFallback ?? "synthetic";
+	let fontName = baseFontName;
+	let needsBold = Boolean(run.bold);
+	let needsItalic = Boolean(run.italic);
+	if (run.code) fontName = getLoadedFontName(font, variants.code) ?? baseFontName;
+	else if (run.bold && run.italic) {
+		const boldItalic = getLoadedFontName(font, variants.boldItalic);
+		const italic = getLoadedFontName(font, variants.italic);
+		const bold = getLoadedFontName(font, variants.bold);
+		if (boldItalic) {
+			fontName = boldItalic;
+			needsBold = false;
+			needsItalic = false;
+		} else if (italic) {
+			fontName = italic;
+			needsItalic = false;
+		} else if (bold) {
+			fontName = bold;
+			needsBold = false;
+		}
+	} else if (run.bold) {
+		const bold = getLoadedFontName(font, variants.bold);
+		if (bold) {
+			fontName = bold;
+			needsBold = false;
+		}
+	} else if (run.italic) {
+		const italic = getLoadedFontName(font, variants.italic);
+		if (italic) {
+			fontName = italic;
+			needsItalic = false;
+		}
+	}
+	if ((needsBold || needsItalic || run.code && !getLoadedFontName(font, variants.code)) && fallback === "error") throw new Error(`[@pdfme/schemas] Missing font variant for markdown text in field "${schema.name}".`);
+	return {
+		fontName,
+		syntheticBold: fallback !== "plain" && needsBold,
+		syntheticItalic: fallback !== "plain" && needsItalic
+	};
+};
+var resolveRichTextRuns = async (arg) => {
+	const { runs, schema, font, _cache } = arg;
+	const fontKitCache = /* @__PURE__ */ new Map();
+	const getResolvedFontKitFont = async (fontName) => {
+		const cached = fontKitCache.get(fontName);
+		if (cached) return cached;
+		const fontKitFont = await getFontKitFont(fontName, font, _cache);
+		fontKitCache.set(fontName, fontKitFont);
+		return fontKitFont;
+	};
+	return Promise.all(runs.map(async (run) => {
+		const resolution = resolveFontVariant(run, schema, font);
+		return {
+			...run,
+			...resolution,
+			fontKitFont: await getResolvedFontKitFont(resolution.fontName)
+		};
+	}));
+};
+var measureRunText = (run, text, fontSize, characterSpacing) => {
+	const syntheticBoldWidth = run.syntheticBold ? fontSize * SYNTHETIC_BOLD_OFFSET_RATIO * 2 : 0;
+	const syntheticItalicWidth = run.syntheticItalic ? heightOfFontAtSize(run.fontKitFont, fontSize) * Math.tan(12 * Math.PI / 180) : 0;
+	return widthOfTextAtSize(text, run.fontKitFont, fontSize, characterSpacing) + syntheticBoldWidth + syntheticItalicWidth;
+};
+var createLine = () => ({
+	runs: [],
+	width: 0,
+	hardBreak: false
+});
+var pushRunToLine = (line, run, text, fontSize, characterSpacing) => {
+	if (!text) return;
+	const width = measureRunText(run, text, fontSize, characterSpacing);
+	if (line.runs.length > 0) line.width += characterSpacing;
+	line.runs.push({
+		...run,
+		text,
+		width
+	});
+	line.width += width;
+};
+var measurePiecesWidth = (pieces, fontSize, characterSpacing) => {
+	let width = 0;
+	let hasText = false;
+	pieces.forEach((piece) => {
+		if (!piece.text) return;
+		if (hasText) width += characterSpacing;
+		width += measureRunText(piece.run, piece.text, fontSize, characterSpacing);
+		hasText = true;
+	});
+	return width;
+};
+var sliceRunPieces = (pieces, startIndex, endIndex) => {
+	const result = [];
+	let offset = 0;
+	pieces.forEach((piece) => {
+		const pieceStart = offset;
+		const pieceEnd = pieceStart + piece.text.length;
+		const sliceStart = Math.max(startIndex, pieceStart);
+		const sliceEnd = Math.min(endIndex, pieceEnd);
+		if (sliceStart < sliceEnd) result.push({
+			run: piece.run,
+			text: piece.text.slice(sliceStart - pieceStart, sliceEnd - pieceStart)
+		});
+		offset = pieceEnd;
+	});
+	return result;
+};
+var segmentRunPiecesByWord = (runs, onSegment, onHardBreak) => {
+	let paragraphPieces = [];
+	const flushParagraph = () => {
+		if (paragraphPieces.length === 0) return;
+		const paragraphText = paragraphPieces.map((piece) => piece.text).join("");
+		Array.from(richTextWordSegmenter.segment(paragraphText), ({ segment, index }) => {
+			const pieces = sliceRunPieces(paragraphPieces, index, index + segment.length);
+			if (pieces.length > 0) onSegment(pieces);
+		});
+		paragraphPieces = [];
+	};
+	runs.forEach((run) => {
+		run.text.split(/(\r\n|\r|\n)/).forEach((part) => {
+			if (part === "\r\n" || part === "\r" || part === "\n") {
+				flushParagraph();
+				onHardBreak();
+				return;
+			}
+			if (part) paragraphPieces.push({
+				run,
+				text: part
+			});
+		});
+	});
+	flushParagraph();
+};
+var splitIntoGraphemes = (value) => Array.from(richTextGraphemeSegmenter.segment(value), ({ segment }) => segment);
+var countRichTextLineGraphemes = (line) => splitIntoGraphemes(line.runs.map((run) => run.text).join("")).length;
+var layoutRichTextLines = (arg) => {
+	const { runs, fontSize, characterSpacing, boxWidthInPt } = arg;
+	const lines = [];
+	let currentLine = createLine();
+	const pushCurrentLine = (hardBreak) => {
+		currentLine.hardBreak = hardBreak;
+		lines.push(currentLine);
+		currentLine = createLine();
+	};
+	const pushPiecesToLine = (pieces) => {
+		pieces.forEach((piece) => {
+			pushRunToLine(currentLine, piece.run, piece.text, fontSize, characterSpacing);
+		});
+	};
+	const pushOversizedText = (run, text) => {
+		let remainingText = text;
+		while (remainingText.length > 0) {
+			const pendingSpacing = currentLine.runs.length > 0 ? characterSpacing : 0;
+			const remainingWidth = Math.max(boxWidthInPt - currentLine.width - pendingSpacing, 0);
+			const remainingTextWidth = measureRunText(run, remainingText, fontSize, characterSpacing);
+			if (remainingTextWidth <= remainingWidth || currentLine.runs.length === 0 && remainingTextWidth <= boxWidthInPt) {
+				pushRunToLine(currentLine, run, remainingText, fontSize, characterSpacing);
+				return;
+			}
+			if (currentLine.runs.length > 0 && remainingTextWidth <= boxWidthInPt) {
+				pushCurrentLine(false);
+				continue;
+			}
+			const graphemes = splitIntoGraphemes(remainingText);
+			let fittingText = "";
+			let fittingLength = 0;
+			for (const grapheme of graphemes) {
+				const candidate = fittingText + grapheme;
+				const candidateWidth = measureRunText(run, candidate, fontSize, characterSpacing);
+				const maxWidth = currentLine.runs.length === 0 ? boxWidthInPt : remainingWidth;
+				if (candidateWidth > maxWidth) {
+					if (fittingText) break;
+					if (currentLine.runs.length > 0) break;
+				}
+				fittingText = candidate;
+				fittingLength += grapheme.length;
+				if (candidateWidth > maxWidth) break;
+			}
+			if (!fittingText) {
+				pushCurrentLine(false);
+				continue;
+			}
+			pushRunToLine(currentLine, run, fittingText, fontSize, characterSpacing);
+			remainingText = remainingText.slice(fittingLength);
+			if (remainingText.length > 0) pushCurrentLine(false);
+		}
+	};
+	const pushSegment = (pieces) => {
+		const segmentWidth = measurePiecesWidth(pieces, fontSize, characterSpacing);
+		const pendingSpacing = currentLine.runs.length > 0 ? characterSpacing : 0;
+		if (segmentWidth <= Math.max(boxWidthInPt - currentLine.width - pendingSpacing, 0) || currentLine.runs.length === 0 && segmentWidth <= boxWidthInPt) {
+			pushPiecesToLine(pieces);
+			return;
+		}
+		if (currentLine.runs.length > 0) {
+			pushCurrentLine(false);
+			if (segmentWidth <= boxWidthInPt) {
+				pushPiecesToLine(pieces);
+				return;
+			}
+		}
+		pieces.forEach((piece) => pushOversizedText(piece.run, piece.text));
+	};
+	segmentRunPiecesByWord(runs, pushSegment, () => pushCurrentLine(true));
+	if (currentLine.runs.length > 0 || lines.length === 0) pushCurrentLine(false);
+	return lines;
+};
+var measureParagraphWidths = (runs, fontSize, characterSpacing) => {
+	const widths = [];
+	let paragraphPieces = [];
+	const pushWidth = () => {
+		widths.push(measurePiecesWidth(paragraphPieces, fontSize, characterSpacing));
+		paragraphPieces = [];
+	};
+	runs.forEach((run) => {
+		run.text.split(/(\r\n|\r|\n)/).forEach((part) => {
+			if (part === "\r\n" || part === "\r" || part === "\n") {
+				pushWidth();
+				return;
+			}
+			if (part) paragraphPieces.push({
+				run,
+				text: part
+			});
+		});
+	});
+	pushWidth();
+	return widths;
+};
+var getLineHeightAtSize = (line, fontSize) => {
+	if (line.runs.length === 0) return fontSize;
+	return Math.max(...line.runs.map((run) => heightOfFontAtSize(run.fontKitFont, fontSize)));
+};
+var calculateDynamicRichTextFontSize = async (arg) => {
+	const { value, schema, font, _cache, startingFontSize } = arg;
+	const { fontSize: schemaFontSize, dynamicFontSize: dynamicFontSizeSetting, characterSpacing: schemaCharacterSpacing, width: boxWidth, height: boxHeight, lineHeight = 1 } = schema;
+	const fontSize = startingFontSize || schemaFontSize || 13;
+	if (!dynamicFontSizeSetting) return fontSize;
+	if (dynamicFontSizeSetting.max < dynamicFontSizeSetting.min) return fontSize;
+	const resolvedRuns = await resolveRichTextRuns({
+		runs: parseInlineMarkdown(value),
+		schema,
+		font,
+		_cache
+	});
+	const characterSpacing = schemaCharacterSpacing ?? 0;
+	const dynamicFontFit = dynamicFontSizeSetting.fit ?? "vertical";
+	const boxWidthInPt = mm2pt(boxWidth);
+	let dynamicFontSize = fontSize;
+	if (dynamicFontSize < dynamicFontSizeSetting.min) dynamicFontSize = dynamicFontSizeSetting.min;
+	else if (dynamicFontSize > dynamicFontSizeSetting.max) dynamicFontSize = dynamicFontSizeSetting.max;
+	const calculateConstraints = (size) => {
+		let totalWidthInMm = 0;
+		let totalHeightInMm = 0;
+		layoutRichTextLines({
+			runs: resolvedRuns,
+			fontSize: size,
+			characterSpacing,
+			boxWidthInPt
+		}).forEach((line, lineIndex) => {
+			if (dynamicFontFit === "vertical") totalWidthInMm = Math.max(totalWidthInMm, pt2mm(line.width));
+			if (lineIndex === 0) totalHeightInMm += pt2mm(getLineHeightAtSize(line, size) * lineHeight);
+			else totalHeightInMm += pt2mm(size * lineHeight);
+		});
+		if (dynamicFontFit === "horizontal") measureParagraphWidths(resolvedRuns, size, characterSpacing).forEach((paragraphWidth) => {
+			totalWidthInMm = Math.max(totalWidthInMm, pt2mm(paragraphWidth));
+		});
+		return {
+			totalWidthInMm,
+			totalHeightInMm
+		};
+	};
+	const shouldFontGrowToFit = (totalWidthInMm, totalHeightInMm) => {
+		if (dynamicFontSize >= dynamicFontSizeSetting.max) return false;
+		if (dynamicFontFit === "horizontal") return totalWidthInMm < boxWidth;
+		return totalHeightInMm < boxHeight;
+	};
+	const shouldFontShrinkToFit = (totalWidthInMm, totalHeightInMm) => {
+		if (dynamicFontSize <= dynamicFontSizeSetting.min || dynamicFontSize <= 0) return false;
+		return totalWidthInMm > boxWidth || totalHeightInMm > boxHeight;
+	};
+	let { totalWidthInMm, totalHeightInMm } = calculateConstraints(dynamicFontSize);
+	while (shouldFontGrowToFit(totalWidthInMm, totalHeightInMm)) {
+		dynamicFontSize += FONT_SIZE_ADJUSTMENT;
+		const { totalWidthInMm: newWidth, totalHeightInMm: newHeight } = calculateConstraints(dynamicFontSize);
+		if (newHeight < boxHeight) {
+			totalWidthInMm = newWidth;
+			totalHeightInMm = newHeight;
+		} else {
+			dynamicFontSize -= FONT_SIZE_ADJUSTMENT;
+			break;
+		}
+	}
+	while (shouldFontShrinkToFit(totalWidthInMm, totalHeightInMm)) {
+		dynamicFontSize -= FONT_SIZE_ADJUSTMENT;
+		({totalWidthInMm, totalHeightInMm} = calculateConstraints(dynamicFontSize));
+	}
+	return dynamicFontSize;
+};
+//#endregion
+//#region src/text/measure.ts
+var applyTextLineRange = (lines, range) => {
+	if (!range) return lines;
+	return lines.slice(range.start, range.end ?? lines.length);
+};
+var plainTextLinesToValue = (lines) => lines.map((line) => line.replace(/[\r\n]+$/g, "")).join("\n");
+var splitReplacementTextToLines = (value) => {
+	const lines = [];
+	let start = 0;
+	for (let i = 0; i < value.length; i += 1) {
+		const charCode = value.charCodeAt(i);
+		if (charCode !== 10 && charCode !== 13) continue;
+		lines.push(value.slice(start, i));
+		if (charCode === 13 && value.charCodeAt(i + 1) === 10) i += 1;
+		start = i + 1;
+	}
+	lines.push(value.slice(start));
+	return lines;
+};
+var measureTextLines = async ({ value, schema, font = getDefaultFont(), _cache = /* @__PURE__ */ new Map(), ignoreDynamicFontSize = false }) => {
+	const fontSize = schema.fontSize ?? 13;
+	const lineHeight = schema.lineHeight ?? 1;
+	const characterSpacing = schema.characterSpacing ?? 0;
+	const boxWidthInPt = mm2pt(schema.width);
+	if (isInlineMarkdownTextSchema(schema)) {
+		const resolvedRuns = await resolveRichTextRuns({
+			runs: parseInlineMarkdown(value),
+			schema,
+			font,
+			_cache
+		});
+		const resolvedFontSize = schema.dynamicFontSize && schema.height > 0 && !ignoreDynamicFontSize ? await calculateDynamicRichTextFontSize({
+			value,
+			schema,
+			font,
+			_cache
+		}) : fontSize;
+		const lines = layoutRichTextLines({
+			runs: resolvedRuns,
+			fontSize: resolvedFontSize,
+			characterSpacing,
+			boxWidthInPt
+		});
+		return {
+			lines: lines.map((line) => line.runs.map((run) => run.text).join("")),
+			lineHeights: measureRichTextLineHeights(lines, resolvedFontSize, lineHeight)
+		};
+	}
+	const fontKitFont = await getFontKitFont(schema.fontName, font, _cache);
+	const resolvedFontSize = schema.dynamicFontSize && schema.height > 0 && !ignoreDynamicFontSize ? calculateDynamicFontSize({
+		textSchema: schema,
+		fontKitFont,
+		value
+	}) : fontSize;
+	const lines = splitTextToSize({
+		value,
+		characterSpacing,
+		fontSize: resolvedFontSize,
+		fontKitFont,
+		boxWidthInPt
+	});
+	return {
+		lines,
+		lineHeights: measurePlainTextLineHeights(lines, fontKitFont, resolvedFontSize, lineHeight)
+	};
+};
+var mergeTextLineRangeValue = async ({ value, replacement, schema, font = getDefaultFont(), _cache = /* @__PURE__ */ new Map() }) => {
+	const range = getTextLineRange(schema);
+	if (!range) return replacement;
+	const { lines } = await measureTextLines({
+		value,
+		schema,
+		font,
+		_cache,
+		ignoreDynamicFontSize: true
+	});
+	const { start, end = lines.length } = range;
+	const nextLines = [...lines];
+	nextLines.splice(start, end - start, ...splitReplacementTextToLines(replacement));
+	return plainTextLinesToValue(nextLines);
+};
+var measureTextHeight = async (args) => {
+	const { lineHeights } = await measureTextLines(args);
+	return sumLineHeights(lineHeights);
+};
+var sumLineHeights = (lineHeights) => lineHeights.reduce((sum, height) => sum + height, 0);
+var measurePlainTextLineHeights = (lines, fontKitFont, fontSize, lineHeight) => {
+	if (lines.length === 0) return [];
+	const firstLineHeight = heightOfFontAtSize(fontKitFont, fontSize) * lineHeight;
+	const otherLineHeight = fontSize * lineHeight;
+	return lines.map((_, index) => pt2mm(index === 0 ? firstLineHeight : otherLineHeight));
+};
+var measureRichTextLineHeights = (lines, fontSize, lineHeight) => {
+	if (lines.length === 0) return [];
+	return lines.map((line, index) => pt2mm((index === 0 ? getRichTextLineHeight(line, fontSize) : fontSize) * lineHeight));
+};
+var getRichTextLineHeight = (line, fontSize) => {
+	if (line.runs.length === 0) return fontSize;
+	return Math.max(...line.runs.map((run) => heightOfFontAtSize(run.fontKitFont, fontSize)));
+};
+//#endregion
+export { plainTextLinesToValue as a, countRichTextLineGraphemes as c, resolveFontVariant as d, resolveRichTextRuns as f, stripInlineMarkdown as h, mergeTextLineRangeValue as i, isInlineMarkdownTextSchema as l, parseInlineMarkdown as m, measureTextHeight as n, sumLineHeights as o, escapeInlineMarkdown as p, measureTextLines as r, calculateDynamicRichTextFontSize as s, applyTextLineRange as t, layoutRichTextLines as u };
+
+//# sourceMappingURL=measure-Bjmh9Ro3.js.map