@pdfme/schemas 6.1.1-dev.4 → 6.1.1-dev.8

package/dist/{builtins-CFqn6U5J.js → builtins-pN5NVCSV.js}

@@ -1,426 +1,36 @@
-import { A as TEXT_FORMAT_INLINE_MARKDOWN, C as FONT_SIZE_ADJUSTMENT, D as PLACEHOLDER_FONT_COLOR, E as FONT_VARIANT_FALLBACK_SYNTHETIC, M as VERTICAL_ALIGN_BOTTOM, N as VERTICAL_ALIGN_MIDDLE, O as SYNTHETIC_BOLD_CSS_TEXT_SHADOW, S as DYNAMIC_FIT_VERTICAL, T as FONT_VARIANT_FALLBACK_PLAIN, _ as DEFAULT_DYNAMIC_FIT, a as getFontKitFont, b as DEFAULT_TEXT_FORMAT, c as splitTextToSize, d as ALIGN_JUSTIFY, g as DEFAULT_ALIGNMENT, h as CODE_HORIZONTAL_PADDING, i as getFontDescentInPt, j as TEXT_FORMAT_PLAIN, k as SYNTHETIC_BOLD_OFFSET_RATIO, l as widthOfTextAtSize, m as CODE_BACKGROUND_COLOR, n as fetchRemoteFontData, o as heightOfFontAtSize, p as ALIGN_RIGHT, r as getBrowserVerticalFontAdjustments, s as isFirefox, t as calculateDynamicFontSize, u as ALIGN_CENTER, v as DEFAULT_FONT_COLOR, w as FONT_VARIANT_FALLBACK_ERROR, x as DYNAMIC_FIT_HORIZONTAL, y as DEFAULT_FONT_VARIANT_FALLBACK } from "./helper-6FilIoVM.js";
-import { c as HEX_COLOR_PATTERN } from "./dynamicTemplate-DslOH4FZ.js";
+import { A as SYNTHETIC_BOLD_OFFSET_RATIO, C as DYNAMIC_FIT_VERTICAL, D as FONT_VARIANT_FALLBACK_SYNTHETIC, E as FONT_VARIANT_FALLBACK_PLAIN, F as VERTICAL_ALIGN_BOTTOM, I as VERTICAL_ALIGN_MIDDLE, M as TEXT_FORMAT_PLAIN, N as TEXT_OVERFLOW_EXPAND, O as PLACEHOLDER_FONT_COLOR, P as TEXT_OVERFLOW_VISIBLE, S as DYNAMIC_FIT_HORIZONTAL, T as FONT_VARIANT_FALLBACK_ERROR, _ as DEFAULT_DYNAMIC_FIT, a as getFontKitFont, b as DEFAULT_TEXT_FORMAT, c as splitTextToSize, d as ALIGN_JUSTIFY, g as DEFAULT_ALIGNMENT, h as CODE_HORIZONTAL_PADDING, i as getFontDescentInPt, j as TEXT_FORMAT_INLINE_MARKDOWN, k as SYNTHETIC_BOLD_CSS_TEXT_SHADOW, l as widthOfTextAtSize, m as CODE_BACKGROUND_COLOR, n as fetchRemoteFontData, o as heightOfFontAtSize, p as ALIGN_RIGHT, r as getBrowserVerticalFontAdjustments, s as isFirefox, t as calculateDynamicFontSize, u as ALIGN_CENTER, v as DEFAULT_FONT_COLOR, x as DEFAULT_TEXT_OVERFLOW, y as DEFAULT_FONT_VARIANT_FALLBACK } from "./helper-CBd9plP_.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-h-7PUE2B.js";
+import { c as HEX_COLOR_PATTERN } from "./dynamicTemplate-CkrZKlg-.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, 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
@@ -454,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) {
@@ -490,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,
@@ -517,8 +188,8 @@ var drawRun = (arg) => {
 	}
 };
 var renderInlineMarkdownText = async (arg) => {
-	const { value, schema, font, embedPdfFont, 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,
@@ -529,6 +200,8 @@ var renderInlineMarkdownText = async (arg) => {
 		characterSpacing,
 		boxWidthInPt: width
 	});
+	const lines = applyTextLineRange(allLines, schema.__textLineRange);
+	const lineRangeStart = schema.__textLineRange?.start ?? 0;
 	const pdfFontObj = await embedFontsForRuns(lines.flatMap((line) => line.runs), embedPdfFont);
 	const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
 	const descent = getFontDescentInPt(fontKitFont, fontSize);
@@ -544,7 +217,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;
@@ -598,13 +271,42 @@ 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 isTextOverflowExpand = (schema) => schema.overflow === TEXT_OVERFLOW_EXPAND;
+var shouldUseDynamicFontSize = (schema) => Boolean(schema.dynamicFontSize) && !isTextOverflowExpand(schema);
+//#endregion
 //#region src/text/pdfRender.ts
 var PDF_FONT_CACHE_KEY = "text-pdf-font-cache";
 var getPdfFontCache = (_cache) => {
@@ -631,7 +333,7 @@ var embedAndGetFont = (arg) => {
 	return pdfFontPromise;
 };
 var getFontProp = ({ value, fontKitFont, schema, colorType, fontSize: resolvedFontSize }) => {
-	const fontSize = resolvedFontSize ?? (schema.dynamicFontSize ? calculateDynamicFontSize({
+	const fontSize = resolvedFontSize ?? (shouldUseDynamicFontSize(schema) ? calculateDynamicFontSize({
 		textSchema: schema,
 		fontKitFont,
 		value
@@ -669,7 +371,7 @@ var pdfRender = async (arg) => {
 		fontKitFont,
 		schema,
 		colorType,
-		fontSize: enableInlineMarkdown && schema.dynamicFontSize ? await calculateDynamicRichTextFontSize({
+		fontSize: enableInlineMarkdown && shouldUseDynamicFontSize(schema) ? await calculateDynamicRichTextFontSize({
 			value,
 			schema,
 			font,
@@ -722,6 +424,7 @@ var pdfRender = async (arg) => {
 				_cache
 			}),
 			fontKitFont,
+			pdfDoc,
 			page,
 			pdfLib,
 			_cache,
@@ -747,13 +450,13 @@ var pdfRender = async (arg) => {
 	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
-	});
+	}), schema.__textLineRange);
 	const needsTextWidth = alignment !== "left" || Boolean(schema.strikethrough || schema.underline);
 	const needsTextHeight = Boolean(schema.strikethrough || schema.underline);
 	let yOffset = 0;
@@ -920,9 +623,11 @@ function getExtraFormatterSchema(i18n) {
 //#region src/text/propPanel.ts
 var UseDynamicFontSize = (props) => {
 	const { rootElement, changeSchemas, activeSchema, i18n } = props;
+	const isExpand = isTextOverflowExpand(activeSchema);
 	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",
@@ -939,6 +644,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);
@@ -972,8 +678,8 @@ var propPanel = {
 		} };
 		const fontNames = Object.keys(font);
 		const fallbackFontName = getFallbackFontName(font);
-		const enableDynamicFont = Boolean(activeSchema?.dynamicFontSize);
 		const activeTextSchema = activeSchema;
+		const enableDynamicFont = !isTextOverflowExpand(activeTextSchema) && 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;
@@ -1023,6 +729,20 @@ var propPanel = {
 				},
 				span: 8
 			},
+			overflow: {
+				title: i18n("schemas.text.overflow"),
+				type: "string",
+				widget: "select",
+				default: DEFAULT_TEXT_OVERFLOW,
+				props: { options: [{
+					label: i18n("schemas.text.overflowVisible"),
+					value: TEXT_OVERFLOW_VISIBLE
+				}, {
+					label: i18n("schemas.text.overflowExpand"),
+					value: TEXT_OVERFLOW_EXPAND
+				}] },
+				span: 8
+			},
 			useDynamicFontSize: {
 				type: "boolean",
 				widget: "UseDynamicFontSize",
@@ -1166,6 +886,7 @@ var propPanel = {
 		verticalAlignment: "top",
 		fontSize: 13,
 		textFormat: DEFAULT_TEXT_FORMAT,
+		overflow: DEFAULT_TEXT_OVERFLOW,
 		fontVariantFallback: DEFAULT_FONT_VARIANT_FALLBACK,
 		lineHeight: 1,
 		characterSpacing: 0,
@@ -1198,7 +919,12 @@ var replaceUnsupportedChars = (text, fontKitFont) => {
 };
 var uiRender = async (arg) => {
 	const { value, schema, mode, onChange, stopEditing, tabIndex, placeholder, options, _cache } = arg;
-	const usePlaceholder = isEditable(mode, schema) && placeholder && !value;
+	const hasInlineMarkdownFormat = schema.textFormat === TEXT_FORMAT_INLINE_MARKDOWN;
+	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const isReadOnlySplitInlineMarkdownFormChunk = mode === "form" && Boolean(schema.__textLineRange) && 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);
@@ -1206,18 +932,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);
 	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,
@@ -1243,7 +977,7 @@ var uiRender = async (arg) => {
 		});
 		if (stopEditing) stopEditing();
 	});
-	if (schema.dynamicFontSize) {
+	if (enableDynamicFontSize) {
 		let dynamicFontSize = void 0;
 		textBlock.addEventListener("keyup", () => {
 			setTimeout(() => {
@@ -1292,30 +1026,84 @@ var renderInlineMarkdownReadOnly = async (arg) => {
 		font,
 		_cache
 	});
+	if (schema.__textLineRange) {
+		const lines = applyTextLineRange(layoutRichTextLines({
+			runs,
+			fontSize: schema.fontSize ?? 13,
+			characterSpacing: schema.characterSpacing ?? 0,
+			boxWidthInPt: mm2pt(schema.width)
+		}), schema.__textLineRange);
+		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;
+	if (!schema.__textLineRange) return value;
+	return plainTextLinesToValue(applyTextLineRange(splitTextToSize({
+		value,
+		characterSpacing: schema.characterSpacing ?? 0,
+		fontSize,
+		fontKitFont,
+		boxWidthInPt: mm2pt(schema.width)
+	}), schema.__textLineRange));
+};
 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) && value) dynamicFontSize = calculateDynamicFontSize({
 		textSchema: schema,
 		fontKitFont,
 		value,
@@ -1416,6 +1204,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-CFqn6U5J.js.map
+//# sourceMappingURL=builtins-pN5NVCSV.js.map