@pdfme/schemas 6.1.0 → 6.1.1-dev.11

package/dist/{builtins-C0BvXHWr.js → builtins-Clh58o_b.js}

@@ -1,436 +1,52 @@
-import { A as FONT_SIZE_ADJUSTMENT, B as VERTICAL_ALIGN_MIDDLE, C as DEFAULT_ALIGNMENT, D as DEFAULT_TEXT_FORMAT, E as DEFAULT_FONT_VARIANT_FALLBACK, F as SYNTHETIC_BOLD_CSS_TEXT_SHADOW, I as SYNTHETIC_BOLD_OFFSET_RATIO, L as TEXT_FORMAT_INLINE_MARKDOWN, M as FONT_VARIANT_FALLBACK_PLAIN, N as FONT_VARIANT_FALLBACK_SYNTHETIC, O as DYNAMIC_FIT_HORIZONTAL, P as PLACEHOLDER_FONT_COLOR, R as TEXT_FORMAT_PLAIN, S as CODE_HORIZONTAL_PADDING, T as DEFAULT_FONT_COLOR, _ as widthOfTextAtSize, b as ALIGN_RIGHT, d as getBrowserVerticalFontAdjustments, f as getFontDescentInPt, g as splitTextToSize, h as isFirefox, j as FONT_VARIANT_FALLBACK_ERROR, k as DYNAMIC_FIT_VERTICAL, l as calculateDynamicFontSize, m as heightOfFontAtSize, p as getFontKitFont, s as HEX_COLOR_PATTERN, u as fetchRemoteFontData, v as ALIGN_CENTER, w as DEFAULT_DYNAMIC_FIT, x as CODE_BACKGROUND_COLOR, y as ALIGN_JUSTIFY, z as VERTICAL_ALIGN_BOTTOM } from "./dynamicTemplate-Dsrw11aL.js";
+import { A as DEFAULT_TEXT_FORMAT, B as SYNTHETIC_BOLD_OFFSET_RATIO, C as ALIGN_RIGHT, D as DEFAULT_DYNAMIC_FIT, E as DEFAULT_ALIGNMENT, F as FONT_VARIANT_FALLBACK_ERROR, G as VERTICAL_ALIGN_BOTTOM, H as TEXT_FORMAT_PLAIN, I as FONT_VARIANT_FALLBACK_PLAIN, K as VERTICAL_ALIGN_MIDDLE, L as FONT_VARIANT_FALLBACK_SYNTHETIC, M as DYNAMIC_FIT_HORIZONTAL, N as DYNAMIC_FIT_VERTICAL, O as DEFAULT_FONT_COLOR, R as PLACEHOLDER_FONT_COLOR, T as CODE_HORIZONTAL_PADDING, U as TEXT_OVERFLOW_EXPAND, V as TEXT_FORMAT_INLINE_MARKDOWN, W as TEXT_OVERFLOW_VISIBLE, _ as isFirefox, b as ALIGN_CENTER, d as calculateDynamicFontSize, f as fetchRemoteFontData, g as heightOfFontAtSize, h as getFontKitFont, j as DEFAULT_TEXT_OVERFLOW, k as DEFAULT_FONT_VARIANT_FALLBACK, m as getFontDescentInPt, p as getBrowserVerticalFontAdjustments, u as getTextLineRange, v as splitTextToSize, w as CODE_BACKGROUND_COLOR, x as ALIGN_JUSTIFY, y as widthOfTextAtSize, z as SYNTHETIC_BOLD_CSS_TEXT_SHADOW } from "./splitRange-CpXivbmJ.js";
+import { a as plainTextLinesToValue, c as countRichTextLineGraphemes, f as resolveRichTextRuns, h as stripInlineMarkdown, l as isInlineMarkdownTextSchema, m as parseInlineMarkdown, s as calculateDynamicRichTextFontSize, t as applyTextLineRange, u as layoutRichTextLines } from "./measure-Bjmh9Ro3.js";
+import { c as HEX_COLOR_PATTERN } from "./dynamicTemplate-CjbGepw4.js";
 import { convertForPdfLayoutProps, createSvgStr, hex2PrintingColor, isEditable, rotatePoint } from "./utils.js";
-import { DEFAULT_FONT_NAME, getDefaultFont, getFallbackFontName, mm2pt, pt2mm } from "@pdfme/common";
+import { DEFAULT_FONT_NAME, getDefaultFont, getFallbackFontName, getInternalLinkTarget, isBlankPdf, mm2pt, normalizeLinkHref, normalizeSafeLinkUri, registerInternalLinkAnnotation } from "@pdfme/common";
+import { PDFName, PDFString } from "@pdfme/pdf-lib";
 import { AlignCenter, AlignJustify, AlignLeft, AlignRight, ArrowDownToLine, ArrowUpToLine, Strikethrough, TextCursorInput, Underline } from "lucide";
-//#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);
-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 } : {}
-	});
-};
-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 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 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;
+//#region src/text/linkAnnotation.ts
+var addUriLinkAnnotation = (arg) => {
+	const { pdfDoc, page, uri, rect, borderWidth = 0 } = arg;
+	const safeUri = normalizeSafeLinkUri(uri);
+	if (!safeUri || 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("URI"),
+			URI: PDFString.of(safeUri)
 		}
-	}
-	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;
+	page.node.addAnnot(annotationRef);
 };
 //#endregion
 //#region src/text/richTextPdfRender.ts
 var getSyntheticBoldWidth = (run, fontSize) => run.syntheticBold ? fontSize * SYNTHETIC_BOLD_OFFSET_RATIO * 2 : 0;
 var getSyntheticItalicWidth = (run, fontSize) => run.syntheticItalic ? heightOfFontAtSize(run.fontKitFont, fontSize) * Math.tan(12 * Math.PI / 180) : 0;
 var getRunWidth = (run, fontSize, characterSpacing) => widthOfTextAtSize(run.text, run.fontKitFont, fontSize, characterSpacing) + getSyntheticBoldWidth(run, fontSize) + getSyntheticItalicWidth(run, fontSize);
-var getPdfFont = (run, pdfFontObj) => {
+var getPdfFontFromObj = (run, pdfFontObj) => {
 	const pdfFont = pdfFontObj[run.fontName];
 	if (!pdfFont) throw new Error(`[@pdfme/schemas] Missing embedded font "${run.fontName}".`);
 	return pdfFont;
 };
+var embedFontsForRuns = async (runs, embedPdfFont) => {
+	const fontNames = Array.from(new Set(runs.map((run) => run.fontName)));
+	const pdfFonts = await Promise.all(fontNames.map(async (fontName) => [fontName, await embedPdfFont(fontName)]));
+	return Object.fromEntries(pdfFonts);
+};
 var drawDecorationLine = (arg) => {
 	const { page, x, y, width, rotate, pivotPoint, fontSize, color, opacity } = arg;
 	if (width <= 0) return;
@@ -448,8 +64,58 @@ var drawDecorationLine = (arg) => {
 		opacity
 	});
 };
+var getAxisAlignedRect = (arg) => {
+	const { x, y, width, height, rotate, pivotPoint } = arg;
+	if (rotate.angle === 0) return {
+		x,
+		y,
+		width,
+		height
+	};
+	const points = [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	].map((point) => rotatePoint(point, pivotPoint, rotate.angle));
+	const xs = points.map((point) => point.x);
+	const ys = points.map((point) => point.y);
+	const minX = Math.min(...xs);
+	const minY = Math.min(...ys);
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(...xs) - minX,
+		height: Math.max(...ys) - minY
+	};
+};
+var getLinkAnnotationRect = (arg) => {
+	const { run, x, y, width, rotate, pivotPoint, fontSize } = arg;
+	const textHeight = heightOfFontAtSize(run.fontKitFont, fontSize);
+	const descent = getFontDescentInPt(run.fontKitFont, fontSize);
+	return getAxisAlignedRect({
+		x,
+		y: y + descent,
+		width,
+		height: textHeight - descent,
+		rotate,
+		pivotPoint
+	});
+};
 var drawRun = (arg) => {
-	const { page, pdfLib, run, pdfFont, x, y, rotate, pivotPoint, fontSize, lineHeight, color, opacity, colorType, characterSpacing, strikethrough } = arg;
+	const { page, pdfLib, run, pdfFont, x, y, rotate, pivotPoint, fontSize, lineHeight, color, opacity, colorType, characterSpacing, strikethrough, underline } = arg;
 	const runWidth = getRunWidth(run, fontSize, characterSpacing);
 	const textHeight = heightOfFontAtSize(run.fontKitFont, fontSize);
 	if (run.code) {
@@ -484,6 +150,17 @@ var drawRun = (arg) => {
 		color,
 		opacity
 	});
+	if (underline && runWidth > 0) drawDecorationLine({
+		page,
+		x,
+		y: y - textHeight / 12,
+		width: runWidth,
+		rotate,
+		pivotPoint,
+		fontSize,
+		color,
+		opacity
+	});
 	const drawAt = (drawX) => {
 		const point = rotate.angle === 0 ? {
 			x: drawX,
@@ -511,8 +188,8 @@ var drawRun = (arg) => {
 	}
 };
 var renderInlineMarkdownText = async (arg) => {
-	const { value, schema, font, pdfFontObj, fontKitFont, page, pdfLib, _cache, colorType, fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing, x, width, height, pageHeight, pivotPoint, rotate, opacity } = arg;
-	const lines = layoutRichTextLines({
+	const { value, schema, font, embedPdfFont, fontKitFont, pdfDoc, page, pdfLib, _cache, colorType, fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing, x, width, height, pageHeight, pivotPoint, rotate, opacity } = arg;
+	const allLines = layoutRichTextLines({
 		runs: await resolveRichTextRuns({
 			runs: parseInlineMarkdown(value),
 			schema,
@@ -523,6 +200,10 @@ var renderInlineMarkdownText = async (arg) => {
 		characterSpacing,
 		boxWidthInPt: width
 	});
+	const lineRange = getTextLineRange(schema);
+	const lines = applyTextLineRange(allLines, lineRange);
+	const lineRangeStart = lineRange?.start ?? 0;
+	const pdfFontObj = await embedFontsForRuns(lines.flatMap((line) => line.runs), embedPdfFont);
 	const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
 	const descent = getFontDescentInPt(fontKitFont, fontSize);
 	const halfLineHeightAdjustment = lineHeight === 0 ? 0 : (lineHeight - 1) * fontSize / 2;
@@ -537,7 +218,7 @@ var renderInlineMarkdownText = async (arg) => {
 		if (line.runs.length === 0) return;
 		let textWidth = line.width;
 		let spacing = characterSpacing;
-		if (alignment === "justify" && !line.hardBreak && rowIndex < lines.length - 1) {
+		if (alignment === "justify" && !line.hardBreak && lineRangeStart + rowIndex < allLines.length - 1) {
 			const graphemeCount = countRichTextLineGraphemes(line);
 			if (graphemeCount > 0) {
 				spacing += (width - textWidth) / graphemeCount;
@@ -580,7 +261,7 @@ var renderInlineMarkdownText = async (arg) => {
 				page,
 				pdfLib,
 				run,
-				pdfFont: getPdfFont(run, pdfFontObj),
+				pdfFont: getPdfFontFromObj(run, pdfFontObj),
 				x: currentX,
 				y: yLine,
 				rotate,
@@ -591,28 +272,72 @@ var renderInlineMarkdownText = async (arg) => {
 				opacity,
 				colorType,
 				characterSpacing: spacing,
-				strikethrough: Boolean(run.strikethrough)
+				strikethrough: Boolean(run.strikethrough),
+				underline: Boolean(run.href) && !schema.underline
 			});
+			if (run.href) {
+				const rect = getLinkAnnotationRect({
+					run,
+					x: currentX,
+					y: yLine,
+					width: runWidth,
+					rotate,
+					pivotPoint,
+					fontSize
+				});
+				const targetName = getInternalLinkTarget(run.href);
+				if (targetName) registerInternalLinkAnnotation({
+					_cache,
+					page,
+					targetName,
+					rect
+				});
+				else addUriLinkAnnotation({
+					pdfDoc,
+					page,
+					uri: run.href,
+					rect
+				});
+			}
 			return currentX + runWidth + (runIndex === line.runs.length - 1 ? 0 : spacing);
 		}, xLine);
 	});
 };
 //#endregion
+//#region src/text/overflow.ts
+var TEXT_OVERFLOW_EXPAND_SCHEMA_TYPES = new Set(["text", "multiVariableText"]);
+var isTextOverflowExpandSchema = (schema) => schema.type === void 0 || TEXT_OVERFLOW_EXPAND_SCHEMA_TYPES.has(schema.type);
+var canUseTextOverflowExpand = (schema, basePdf) => !isTextOverflowExpandSchema(schema) || basePdf === void 0 || isBlankPdf(basePdf);
+var isTextOverflowExpand = (schema, basePdf) => canUseTextOverflowExpand(schema, basePdf) && schema.overflow === "expand";
+var shouldUseDynamicFontSize = (schema, basePdf) => Boolean(schema.dynamicFontSize) && !isTextOverflowExpand(schema, basePdf);
+//#endregion
 //#region src/text/pdfRender.ts
-var embedAndGetFontObj = async (arg) => {
-	const { pdfDoc, font, _cache } = arg;
-	if (_cache.has(pdfDoc)) return _cache.get(pdfDoc);
-	const fontValues = await Promise.all(Object.values(font).map(async (v) => {
-		let fontData = v.data;
+var PDF_FONT_CACHE_KEY = "text-pdf-font-cache";
+var getPdfFontCache = (_cache) => {
+	let pdfFontCache = _cache.get(PDF_FONT_CACHE_KEY);
+	if (!pdfFontCache) {
+		pdfFontCache = {};
+		_cache.set(PDF_FONT_CACHE_KEY, pdfFontCache);
+	}
+	return pdfFontCache;
+};
+var embedAndGetFont = (arg) => {
+	const { pdfDoc, font, fontName, _cache } = arg;
+	const pdfFontCache = getPdfFontCache(_cache);
+	const cachedFont = pdfFontCache[fontName];
+	if (cachedFont) return cachedFont;
+	const fontValue = font[fontName];
+	if (!fontValue) return Promise.reject(/* @__PURE__ */ new Error(`[@pdfme/schemas] Font "${fontName}" is not found.`));
+	const pdfFontPromise = (async () => {
+		let fontData = fontValue.data;
 		if (typeof fontData === "string" && fontData.startsWith("http")) fontData = await fetchRemoteFontData(fontData);
-		return pdfDoc.embedFont(fontData, { subset: typeof v.subset === "undefined" ? true : v.subset });
-	}));
-	const fontObj = Object.keys(font).reduce((acc, cur, i) => Object.assign(acc, { [cur]: fontValues[i] }), {});
-	_cache.set(pdfDoc, fontObj);
-	return fontObj;
+		return pdfDoc.embedFont(fontData, { subset: typeof fontValue.subset === "undefined" ? true : fontValue.subset });
+	})();
+	pdfFontCache[fontName] = pdfFontPromise;
+	return pdfFontPromise;
 };
-var getFontProp = ({ value, fontKitFont, schema, colorType, fontSize: resolvedFontSize }) => {
-	const fontSize = resolvedFontSize ?? (schema.dynamicFontSize ? calculateDynamicFontSize({
+var getFontProp = ({ value, fontKitFont, schema, basePdf, colorType, fontSize: resolvedFontSize }) => {
+	const fontSize = resolvedFontSize ?? (shouldUseDynamicFontSize(schema, basePdf) ? calculateDynamicFontSize({
 		textSchema: schema,
 		fontKitFont,
 		value
@@ -627,30 +352,37 @@ var getFontProp = ({ value, fontKitFont, schema, colorType, fontSize: resolvedFo
 		color
 	};
 };
+var graphemeSegmenter;
+var getGraphemeSegmenter = () => {
+	graphemeSegmenter ?? (graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" }));
+	return graphemeSegmenter;
+};
 var pdfRender = async (arg) => {
-	const { value, pdfDoc, pdfLib, page, options, schema, _cache } = arg;
+	const { value, pdfDoc, pdfLib, page, options, schema, basePdf, _cache } = arg;
 	if (!value) return;
 	const { font = getDefaultFont(), colorType } = options;
-	const [pdfFontObj, fontKitFont] = await Promise.all([embedAndGetFontObj({
+	const fontName = schema.fontName ? schema.fontName : getFallbackFontName(font);
+	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const pdfFontValuePromise = enableInlineMarkdown ? void 0 : embedAndGetFont({
 		pdfDoc,
 		font,
+		fontName,
 		_cache
-	}), getFontKitFont(schema.fontName, font, _cache)]);
-	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	});
+	const fontKitFont = await getFontKitFont(schema.fontName, font, _cache);
 	const { fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing } = getFontProp({
 		value: enableInlineMarkdown ? stripInlineMarkdown(value) : value,
 		fontKitFont,
 		schema,
+		basePdf,
 		colorType,
-		fontSize: enableInlineMarkdown && schema.dynamicFontSize ? await calculateDynamicRichTextFontSize({
+		fontSize: enableInlineMarkdown && shouldUseDynamicFontSize(schema, basePdf) ? await calculateDynamicRichTextFontSize({
 			value,
 			schema,
 			font,
 			_cache
 		}) : void 0
 	});
-	const fontName = schema.fontName ? schema.fontName : getFallbackFontName(font);
-	const pdfFontValue = pdfFontObj && pdfFontObj[fontName];
 	const pageHeight = page.getHeight();
 	const { width, height, rotate, position: { x, y }, opacity } = convertForPdfLayoutProps({
 		schema,
@@ -690,8 +422,14 @@ var pdfRender = async (arg) => {
 			value,
 			schema,
 			font,
-			pdfFontObj,
+			embedPdfFont: (fontName) => embedAndGetFont({
+				pdfDoc,
+				font,
+				fontName,
+				_cache
+			}),
 			fontKitFont,
+			pdfDoc,
 			page,
 			pdfLib,
 			_cache,
@@ -712,16 +450,20 @@ var pdfRender = async (arg) => {
 		});
 		return;
 	}
+	if (!pdfFontValuePromise) throw new Error("[@pdfme/schemas] Failed to prepare PDF font for text rendering.");
+	const pdfFontValue = await pdfFontValuePromise;
 	const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
 	const descent = getFontDescentInPt(fontKitFont, fontSize);
 	const halfLineHeightAdjustment = lineHeight === 0 ? 0 : (lineHeight - 1) * fontSize / 2;
-	const lines = splitTextToSize({
+	const lines = applyTextLineRange(splitTextToSize({
 		value,
 		characterSpacing,
 		fontSize,
 		fontKitFont,
 		boxWidthInPt: width
-	});
+	}), getTextLineRange(schema));
+	const needsTextWidth = alignment !== "left" || Boolean(schema.strikethrough || schema.underline);
+	const needsTextHeight = Boolean(schema.strikethrough || schema.underline);
 	let yOffset = 0;
 	if (verticalAlignment === "top") yOffset = firstLineTextHeight + halfLineHeightAdjustment;
 	else {
@@ -729,11 +471,10 @@ var pdfRender = async (arg) => {
 		if (verticalAlignment === "bottom") yOffset = height - otherLinesHeight + descent - halfLineHeightAdjustment;
 		else if (verticalAlignment === "middle") yOffset = (height - otherLinesHeight - firstLineTextHeight + descent) / 2 + firstLineTextHeight;
 	}
-	const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 	lines.forEach((line, rowIndex) => {
 		const trimmed = line.replace("\n", "");
-		const textWidth = widthOfTextAtSize(trimmed, fontKitFont, fontSize, characterSpacing);
-		const textHeight = heightOfFontAtSize(fontKitFont, fontSize);
+		const textWidth = needsTextWidth ? widthOfTextAtSize(trimmed, fontKitFont, fontSize, characterSpacing) : 0;
+		const textHeight = needsTextHeight ? heightOfFontAtSize(fontKitFont, fontSize) : 0;
 		const rowYOffset = lineHeight * fontSize * rowIndex;
 		if (line === "") line = "\r\n";
 		let xLine = x;
@@ -784,7 +525,7 @@ var pdfRender = async (arg) => {
 		}
 		let spacing = characterSpacing;
 		if (alignment === "justify" && line.slice(-1) !== "\n") {
-			const iterator = segmenter.segment(trimmed)[Symbol.iterator]();
+			const iterator = getGraphemeSegmenter().segment(trimmed)[Symbol.iterator]();
 			const len = Array.from(iterator).length;
 			spacing += (width - textWidth) / len;
 		}
@@ -886,10 +627,12 @@ function getExtraFormatterSchema(i18n) {
 //#endregion
 //#region src/text/propPanel.ts
 var UseDynamicFontSize = (props) => {
-	const { rootElement, changeSchemas, activeSchema, i18n } = props;
+	const { rootElement, changeSchemas, activeSchema, i18n, basePdf } = props;
+	const isExpand = isTextOverflowExpand(activeSchema, basePdf);
 	const checkbox = document.createElement("input");
 	checkbox.type = "checkbox";
-	checkbox.checked = Boolean(activeSchema?.dynamicFontSize);
+	checkbox.checked = !isExpand && Boolean(activeSchema?.dynamicFontSize);
+	checkbox.disabled = isExpand;
 	checkbox.onchange = (e) => {
 		changeSchemas([{
 			key: "dynamicFontSize",
@@ -906,6 +649,7 @@ var UseDynamicFontSize = (props) => {
 	span.innerText = i18n("schemas.text.dynamicFontSize") || "";
 	span.style.cssText = "margin-left: 0.5rem";
 	label.style.cssText = "display: flex; width: 100%;";
+	label.style.opacity = isExpand ? "0.5" : "1";
 	label.appendChild(checkbox);
 	label.appendChild(span);
 	rootElement.appendChild(label);
@@ -932,15 +676,16 @@ var UseInlineMarkdown = (props) => {
 	rootElement.appendChild(label);
 };
 var propPanel = {
-	schema: ({ options, activeSchema, i18n }) => {
+	schema: ({ options, activeSchema, i18n, basePdf }) => {
 		const font = options.font || { [DEFAULT_FONT_NAME]: {
 			data: "",
 			fallback: true
 		} };
 		const fontNames = Object.keys(font);
 		const fallbackFontName = getFallbackFontName(font);
-		const enableDynamicFont = Boolean(activeSchema?.dynamicFontSize);
 		const activeTextSchema = activeSchema;
+		const canExpandOverflow = canUseTextOverflowExpand(activeTextSchema, basePdf);
+		const enableDynamicFont = !isTextOverflowExpand(activeTextSchema, basePdf) && Boolean(activeSchema?.dynamicFontSize);
 		const hideTextFormat = activeTextSchema.type === "text" && activeTextSchema.readOnly !== true;
 		const enableInlineMarkdown = activeTextSchema.textFormat === "inline-markdown" && !hideTextFormat;
 		const baseFontName = activeTextSchema.fontName && font[activeTextSchema.fontName] ? activeTextSchema.fontName : fallbackFontName;
@@ -951,6 +696,13 @@ var propPanel = {
 			label: name,
 			value: name
 		}))];
+		const overflowOptions = [{
+			label: i18n("schemas.text.overflowVisible"),
+			value: TEXT_OVERFLOW_VISIBLE
+		}, ...canExpandOverflow ? [{
+			label: i18n("schemas.text.overflowExpand"),
+			value: TEXT_OVERFLOW_EXPAND
+		}] : []];
 		return {
 			fontName: {
 				title: i18n("schemas.text.fontName"),
@@ -990,6 +742,14 @@ var propPanel = {
 				},
 				span: 8
 			},
+			overflow: {
+				title: i18n("schemas.text.overflow"),
+				type: "string",
+				widget: "select",
+				default: DEFAULT_TEXT_OVERFLOW,
+				props: { options: overflowOptions },
+				span: 8
+			},
 			useDynamicFontSize: {
 				type: "boolean",
 				widget: "UseDynamicFontSize",
@@ -1133,6 +893,7 @@ var propPanel = {
 		verticalAlignment: "top",
 		fontSize: 13,
 		textFormat: DEFAULT_TEXT_FORMAT,
+		overflow: DEFAULT_TEXT_OVERFLOW,
 		fontVariantFallback: DEFAULT_FONT_VARIANT_FALLBACK,
 		lineHeight: 1,
 		characterSpacing: 0,
@@ -1164,8 +925,13 @@ var replaceUnsupportedChars = (text, fontKitFont) => {
 	}).join("");
 };
 var uiRender = async (arg) => {
-	const { value, schema, mode, onChange, stopEditing, tabIndex, placeholder, options, _cache } = arg;
-	const usePlaceholder = isEditable(mode, schema) && placeholder && !value;
+	const { value, schema, basePdf, mode, onChange, stopEditing, tabIndex, placeholder, options, _cache } = arg;
+	const hasInlineMarkdownFormat = schema.textFormat === TEXT_FORMAT_INLINE_MARKDOWN;
+	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const isReadOnlySplitInlineMarkdownFormChunk = mode === "form" && Boolean(getTextLineRange(schema)) && hasInlineMarkdownFormat;
+	const renderInlineMarkdownReadOnlyChunk = enableInlineMarkdown || isReadOnlySplitInlineMarkdownFormChunk;
+	const editable = isEditable(mode, schema) && !isReadOnlySplitInlineMarkdownFormChunk;
+	const usePlaceholder = editable && placeholder && !value;
 	const getText = (element) => {
 		let text = element.innerText;
 		if (text.endsWith("\n")) text = text.slice(0, -1);
@@ -1173,18 +939,26 @@ var uiRender = async (arg) => {
 	};
 	const font = options?.font || getDefaultFont();
 	const fontKitFont = await getFontKitFont(schema.fontName, font, _cache);
-	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const enableDynamicFontSize = shouldUseDynamicFontSize(schema, basePdf);
 	const displayValue = enableInlineMarkdown ? stripInlineMarkdown(value) : value;
-	const dynamicRichTextFontSize = enableInlineMarkdown && schema.dynamicFontSize ? await calculateDynamicRichTextFontSize({
+	const dynamicRichTextFontSize = enableInlineMarkdown && enableDynamicFontSize ? await calculateDynamicRichTextFontSize({
 		value: usePlaceholder ? placeholder : value,
 		schema,
 		font,
 		_cache
 	}) : void 0;
-	const textBlock = buildStyledTextContainer(arg, fontKitFont, usePlaceholder ? placeholder : displayValue, dynamicRichTextFontSize);
-	const processedText = replaceUnsupportedChars(value, fontKitFont);
-	if (!isEditable(mode, schema)) {
-		if (enableInlineMarkdown) {
+	const textBlock = buildStyledTextContainer(isReadOnlySplitInlineMarkdownFormChunk ? {
+		...arg,
+		mode: "viewer"
+	} : arg, fontKitFont, usePlaceholder ? placeholder : displayValue, dynamicRichTextFontSize);
+	const processedText = replaceUnsupportedChars(getRangedPlainTextValue({
+		value,
+		schema,
+		fontKitFont,
+		fontSize: schema.fontSize ?? 13
+	}), fontKitFont);
+	if (!editable) {
+		if (renderInlineMarkdownReadOnlyChunk) {
 			await renderInlineMarkdownReadOnly({
 				textBlock,
 				value,
@@ -1210,7 +984,7 @@ var uiRender = async (arg) => {
 		});
 		if (stopEditing) stopEditing();
 	});
-	if (schema.dynamicFontSize) {
+	if (enableDynamicFontSize) {
 		let dynamicFontSize = void 0;
 		textBlock.addEventListener("keyup", () => {
 			setTimeout(() => {
@@ -1259,30 +1033,86 @@ var renderInlineMarkdownReadOnly = async (arg) => {
 		font,
 		_cache
 	});
+	const lineRange = getTextLineRange(schema);
+	if (lineRange) {
+		const lines = applyTextLineRange(layoutRichTextLines({
+			runs,
+			fontSize: schema.fontSize ?? 13,
+			characterSpacing: schema.characterSpacing ?? 0,
+			boxWidthInPt: mm2pt(schema.width)
+		}), lineRange);
+		textBlock.innerHTML = "";
+		lines.forEach((line, lineIndex) => {
+			line.runs.forEach((run) => {
+				appendInlineMarkdownRun({
+					textBlock,
+					run,
+					schema,
+					font
+				});
+			});
+			if (lineIndex < lines.length - 1) textBlock.appendChild(document.createElement("br"));
+		});
+		return;
+	}
 	textBlock.innerHTML = "";
 	runs.forEach((run) => {
-		const span = document.createElement("span");
-		span.textContent = replaceUnsupportedChars(run.text, run.fontKitFont);
-		if (run.fontName) span.style.fontFamily = `'${run.fontName}'`;
-		if (run.syntheticBold) {
-			span.style.fontWeight = "800";
-			span.style.textShadow = SYNTHETIC_BOLD_CSS_TEXT_SHADOW;
-		}
-		if (run.syntheticItalic) span.style.fontStyle = "italic";
-		if (run.strikethrough) span.style.textDecoration = "line-through";
-		if (run.code) {
-			span.style.backgroundColor = CODE_BACKGROUND_COLOR;
-			span.style.borderRadius = "2px";
-			span.style.padding = "0 0.15em";
-			if (!schema.fontVariants?.code || !font[schema.fontVariants.code]) span.style.fontFamily = run.fontName ? `'${run.fontName}', monospace` : "monospace";
-		}
-		textBlock.appendChild(span);
+		appendInlineMarkdownRun({
+			textBlock,
+			run,
+			schema,
+			font
+		});
 	});
 };
+var appendInlineMarkdownRun = (arg) => {
+	const { textBlock, run, schema, font } = arg;
+	const href = run.href ? normalizeLinkHref(run.href) : void 0;
+	const span = href ? document.createElement("a") : document.createElement("span");
+	const processedText = replaceUnsupportedChars(run.text, run.fontKitFont);
+	const textDecorations = [];
+	span.textContent = processedText;
+	if (href) {
+		const anchor = span;
+		anchor.href = href;
+		if (!getInternalLinkTarget(href)) {
+			anchor.target = "_blank";
+			anchor.rel = "noopener noreferrer";
+		}
+		textDecorations.push("underline");
+	}
+	if (run.fontName) span.style.fontFamily = `'${run.fontName}'`;
+	if (run.syntheticBold) {
+		span.style.fontWeight = "800";
+		span.style.textShadow = SYNTHETIC_BOLD_CSS_TEXT_SHADOW;
+	}
+	if (run.syntheticItalic) span.style.fontStyle = "italic";
+	if (run.strikethrough) textDecorations.push("line-through");
+	if (textDecorations.length > 0) span.style.textDecoration = textDecorations.join(" ");
+	if (run.code) {
+		span.style.backgroundColor = CODE_BACKGROUND_COLOR;
+		span.style.borderRadius = "2px";
+		span.style.padding = "0 0.15em";
+		if (!schema.fontVariants?.code || !font[schema.fontVariants.code]) span.style.fontFamily = run.fontName ? `'${run.fontName}', monospace` : "monospace";
+	}
+	textBlock.appendChild(span);
+};
+var getRangedPlainTextValue = (arg) => {
+	const { value, schema, fontKitFont, fontSize } = arg;
+	const lineRange = getTextLineRange(schema);
+	if (!lineRange) return value;
+	return plainTextLinesToValue(applyTextLineRange(splitTextToSize({
+		value,
+		characterSpacing: schema.characterSpacing ?? 0,
+		fontSize,
+		fontKitFont,
+		boxWidthInPt: mm2pt(schema.width)
+	}), lineRange));
+};
 var buildStyledTextContainer = (arg, fontKitFont, value, resolvedDynamicFontSize) => {
 	const { schema, rootElement, mode } = arg;
 	let dynamicFontSize = resolvedDynamicFontSize;
-	if (dynamicFontSize === void 0 && schema.dynamicFontSize && value) dynamicFontSize = calculateDynamicFontSize({
+	if (dynamicFontSize === void 0 && shouldUseDynamicFontSize(schema, arg.basePdf) && value) dynamicFontSize = calculateDynamicFontSize({
 		textSchema: schema,
 		fontKitFont,
 		value,
@@ -1383,6 +1213,6 @@ var textSchema = {
 //#region src/builtins.ts
 var builtInPlugins = { Text: textSchema };
 //#endregion
-export { mapVerticalAlignToFlex as a, Formatter as c, isInlineMarkdownTextSchema as d, resolveFontVariant as f, makeElementPlainTextContentEditable as i, getExtraFormatterSchema as l, parseInlineMarkdown as m, textSchema as n, uiRender as o, escapeInlineMarkdown as p, buildStyledTextContainer as r, propPanel as s, builtInPlugins as t, pdfRender as u };
+export { mapVerticalAlignToFlex as a, Formatter as c, makeElementPlainTextContentEditable as i, getExtraFormatterSchema as l, textSchema as n, uiRender as o, buildStyledTextContainer as r, propPanel as s, builtInPlugins as t, pdfRender as u };
 
-//# sourceMappingURL=builtins-C0BvXHWr.js.map
+//# sourceMappingURL=builtins-Clh58o_b.js.map