@pdfme/schemas 6.0.6 → 6.1.0

package/dist/builtins-C0BvXHWr.js

@@ -0,0 +1,1388 @@
+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 { convertForPdfLayoutProps, createSvgStr, hex2PrintingColor, isEditable, rotatePoint } from "./utils.js";
+import { DEFAULT_FONT_NAME, getDefaultFont, getFallbackFontName, mm2pt, pt2mm } from "@pdfme/common";
+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;
+		}
+	}
+	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/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) => {
+	const pdfFont = pdfFontObj[run.fontName];
+	if (!pdfFont) throw new Error(`[@pdfme/schemas] Missing embedded font "${run.fontName}".`);
+	return pdfFont;
+};
+var drawDecorationLine = (arg) => {
+	const { page, x, y, width, rotate, pivotPoint, fontSize, color, opacity } = arg;
+	if (width <= 0) return;
+	page.drawLine({
+		start: rotatePoint({
+			x,
+			y
+		}, pivotPoint, rotate.angle),
+		end: rotatePoint({
+			x: x + width,
+			y
+		}, pivotPoint, rotate.angle),
+		thickness: 1 / 12 * fontSize,
+		color,
+		opacity
+	});
+};
+var drawRun = (arg) => {
+	const { page, pdfLib, run, pdfFont, x, y, rotate, pivotPoint, fontSize, lineHeight, color, opacity, colorType, characterSpacing, strikethrough } = arg;
+	const runWidth = getRunWidth(run, fontSize, characterSpacing);
+	const textHeight = heightOfFontAtSize(run.fontKitFont, fontSize);
+	if (run.code) {
+		const padding = CODE_HORIZONTAL_PADDING;
+		const bgX = x - padding;
+		const bgY = y - textHeight * .2;
+		const bgPoint = rotate.angle === 0 ? {
+			x: bgX,
+			y: bgY
+		} : rotatePoint({
+			x: bgX,
+			y: bgY
+		}, pivotPoint, rotate.angle);
+		page.drawRectangle({
+			x: bgPoint.x,
+			y: bgPoint.y,
+			width: runWidth + padding * 2,
+			height: textHeight * 1.2,
+			rotate,
+			color: hex2PrintingColor(CODE_BACKGROUND_COLOR, colorType),
+			opacity
+		});
+	}
+	if (strikethrough && runWidth > 0) drawDecorationLine({
+		page,
+		x,
+		y: y + textHeight / 3,
+		width: runWidth,
+		rotate,
+		pivotPoint,
+		fontSize,
+		color,
+		opacity
+	});
+	const drawAt = (drawX) => {
+		const point = rotate.angle === 0 ? {
+			x: drawX,
+			y
+		} : rotatePoint({
+			x: drawX,
+			y
+		}, pivotPoint, rotate.angle);
+		page.drawText(run.text, {
+			x: point.x,
+			y: point.y,
+			rotate,
+			size: fontSize,
+			color,
+			lineHeight: lineHeight * fontSize,
+			font: pdfFont,
+			opacity,
+			...run.syntheticItalic ? { ySkew: pdfLib.degrees(12) } : {}
+		});
+	};
+	drawAt(x);
+	if (run.syntheticBold) {
+		const offset = fontSize * SYNTHETIC_BOLD_OFFSET_RATIO;
+		for (let i = 1; i <= 2; i++) drawAt(x + offset * i);
+	}
+};
+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({
+		runs: await resolveRichTextRuns({
+			runs: parseInlineMarkdown(value),
+			schema,
+			font,
+			_cache
+		}),
+		fontSize,
+		characterSpacing,
+		boxWidthInPt: width
+	});
+	const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
+	const descent = getFontDescentInPt(fontKitFont, fontSize);
+	const halfLineHeightAdjustment = lineHeight === 0 ? 0 : (lineHeight - 1) * fontSize / 2;
+	let yOffset = 0;
+	if (verticalAlignment === "top") yOffset = firstLineTextHeight + halfLineHeightAdjustment;
+	else {
+		const otherLinesHeight = lineHeight * fontSize * (lines.length - 1);
+		if (verticalAlignment === "bottom") yOffset = height - otherLinesHeight + descent - halfLineHeightAdjustment;
+		else if (verticalAlignment === "middle") yOffset = (height - otherLinesHeight - firstLineTextHeight + descent) / 2 + firstLineTextHeight;
+	}
+	lines.forEach((line, rowIndex) => {
+		if (line.runs.length === 0) return;
+		let textWidth = line.width;
+		let spacing = characterSpacing;
+		if (alignment === "justify" && !line.hardBreak && rowIndex < lines.length - 1) {
+			const graphemeCount = countRichTextLineGraphemes(line);
+			if (graphemeCount > 0) {
+				spacing += (width - textWidth) / graphemeCount;
+				textWidth = width;
+			}
+		}
+		let xLine = x;
+		if (alignment === "center") xLine += (width - textWidth) / 2;
+		else if (alignment === "right") xLine += width - textWidth;
+		const yLine = pageHeight - mm2pt(schema.position.y) - yOffset - lineHeight * fontSize * rowIndex;
+		page.pushOperators(pdfLib.setCharacterSpacing(spacing));
+		if (schema.strikethrough || schema.underline) {
+			const textHeight = Math.max(...line.runs.map((run) => heightOfFontAtSize(run.fontKitFont, fontSize)));
+			if (schema.strikethrough) drawDecorationLine({
+				page,
+				x: xLine,
+				y: yLine + textHeight / 3,
+				width: textWidth,
+				rotate,
+				pivotPoint,
+				fontSize,
+				color,
+				opacity
+			});
+			if (schema.underline) drawDecorationLine({
+				page,
+				x: xLine,
+				y: yLine - textHeight / 12,
+				width: textWidth,
+				rotate,
+				pivotPoint,
+				fontSize,
+				color,
+				opacity
+			});
+		}
+		line.runs.reduce((currentX, run, runIndex) => {
+			const runWidth = getRunWidth(run, fontSize, spacing);
+			drawRun({
+				page,
+				pdfLib,
+				run,
+				pdfFont: getPdfFont(run, pdfFontObj),
+				x: currentX,
+				y: yLine,
+				rotate,
+				pivotPoint,
+				fontSize,
+				lineHeight,
+				color,
+				opacity,
+				colorType,
+				characterSpacing: spacing,
+				strikethrough: Boolean(run.strikethrough)
+			});
+			return currentX + runWidth + (runIndex === line.runs.length - 1 ? 0 : spacing);
+		}, xLine);
+	});
+};
+//#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;
+		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;
+};
+var getFontProp = ({ value, fontKitFont, schema, colorType, fontSize: resolvedFontSize }) => {
+	const fontSize = resolvedFontSize ?? (schema.dynamicFontSize ? calculateDynamicFontSize({
+		textSchema: schema,
+		fontKitFont,
+		value
+	}) : schema.fontSize ?? 13);
+	const color = hex2PrintingColor(schema.fontColor || "#000000", colorType);
+	return {
+		alignment: schema.alignment ?? "left",
+		verticalAlignment: schema.verticalAlignment ?? "top",
+		lineHeight: schema.lineHeight ?? 1,
+		characterSpacing: schema.characterSpacing ?? 0,
+		fontSize,
+		color
+	};
+};
+var pdfRender = async (arg) => {
+	const { value, pdfDoc, pdfLib, page, options, schema, _cache } = arg;
+	if (!value) return;
+	const { font = getDefaultFont(), colorType } = options;
+	const [pdfFontObj, fontKitFont] = await Promise.all([embedAndGetFontObj({
+		pdfDoc,
+		font,
+		_cache
+	}), getFontKitFont(schema.fontName, font, _cache)]);
+	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const { fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing } = getFontProp({
+		value: enableInlineMarkdown ? stripInlineMarkdown(value) : value,
+		fontKitFont,
+		schema,
+		colorType,
+		fontSize: enableInlineMarkdown && schema.dynamicFontSize ? 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,
+		pageHeight,
+		applyRotateTranslate: false
+	});
+	const pivotPoint = {
+		x: x + width / 2,
+		y: pageHeight - mm2pt(schema.position.y) - height / 2
+	};
+	if (schema.backgroundColor) {
+		const color = hex2PrintingColor(schema.backgroundColor, colorType);
+		if (rotate.angle !== 0) {
+			const rotatedPoint = rotatePoint({
+				x,
+				y
+			}, pivotPoint, rotate.angle);
+			page.drawRectangle({
+				x: rotatedPoint.x,
+				y: rotatedPoint.y,
+				width,
+				height,
+				rotate,
+				color
+			});
+		} else page.drawRectangle({
+			x,
+			y,
+			width,
+			height,
+			rotate,
+			color
+		});
+	}
+	if (enableInlineMarkdown) {
+		await renderInlineMarkdownText({
+			value,
+			schema,
+			font,
+			pdfFontObj,
+			fontKitFont,
+			page,
+			pdfLib,
+			_cache,
+			colorType,
+			fontSize,
+			color,
+			alignment,
+			verticalAlignment,
+			lineHeight,
+			characterSpacing,
+			x,
+			width,
+			height,
+			pageHeight,
+			pivotPoint,
+			rotate,
+			opacity
+		});
+		return;
+	}
+	const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
+	const descent = getFontDescentInPt(fontKitFont, fontSize);
+	const halfLineHeightAdjustment = lineHeight === 0 ? 0 : (lineHeight - 1) * fontSize / 2;
+	const lines = splitTextToSize({
+		value,
+		characterSpacing,
+		fontSize,
+		fontKitFont,
+		boxWidthInPt: width
+	});
+	let yOffset = 0;
+	if (verticalAlignment === "top") yOffset = firstLineTextHeight + halfLineHeightAdjustment;
+	else {
+		const otherLinesHeight = lineHeight * fontSize * (lines.length - 1);
+		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 rowYOffset = lineHeight * fontSize * rowIndex;
+		if (line === "") line = "\r\n";
+		let xLine = x;
+		if (alignment === "center") xLine += (width - textWidth) / 2;
+		else if (alignment === "right") xLine += width - textWidth;
+		let yLine = pageHeight - mm2pt(schema.position.y) - yOffset - rowYOffset;
+		if (schema.strikethrough && textWidth > 0) {
+			const _x = xLine + textWidth + 1;
+			const _y = yLine + textHeight / 3;
+			page.drawLine({
+				start: rotatePoint({
+					x: xLine,
+					y: _y
+				}, pivotPoint, rotate.angle),
+				end: rotatePoint({
+					x: _x,
+					y: _y
+				}, pivotPoint, rotate.angle),
+				thickness: 1 / 12 * fontSize,
+				color,
+				opacity
+			});
+		}
+		if (schema.underline && textWidth > 0) {
+			const _x = xLine + textWidth + 1;
+			const _y = yLine - textHeight / 12;
+			page.drawLine({
+				start: rotatePoint({
+					x: xLine,
+					y: _y
+				}, pivotPoint, rotate.angle),
+				end: rotatePoint({
+					x: _x,
+					y: _y
+				}, pivotPoint, rotate.angle),
+				thickness: 1 / 12 * fontSize,
+				color,
+				opacity
+			});
+		}
+		if (rotate.angle !== 0) {
+			const rotatedPoint = rotatePoint({
+				x: xLine,
+				y: yLine
+			}, pivotPoint, rotate.angle);
+			xLine = rotatedPoint.x;
+			yLine = rotatedPoint.y;
+		}
+		let spacing = characterSpacing;
+		if (alignment === "justify" && line.slice(-1) !== "\n") {
+			const iterator = segmenter.segment(trimmed)[Symbol.iterator]();
+			const len = Array.from(iterator).length;
+			spacing += (width - textWidth) / len;
+		}
+		page.pushOperators(pdfLib.setCharacterSpacing(spacing));
+		page.drawText(trimmed, {
+			x: xLine,
+			y: yLine,
+			rotate,
+			size: fontSize,
+			color,
+			lineHeight: lineHeight * fontSize,
+			font: pdfFontValue,
+			opacity
+		});
+	});
+};
+//#endregion
+//#region src/text/icons/index.ts
+var TextStrikethroughIcon = createSvgStr(Strikethrough);
+var TextUnderlineIcon = createSvgStr(Underline);
+var TextAlignLeftIcon = createSvgStr(AlignLeft);
+var TextAlignCenterIcon = createSvgStr(AlignCenter);
+var TextAlignRightIcon = createSvgStr(AlignRight);
+var TextAlignJustifyIcon = createSvgStr(AlignJustify);
+var TextVerticalAlignTopIcon = createSvgStr(ArrowUpToLine);
+var TextVerticalAlignMiddleIcon = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 24 24"><path d="M8 19h3v4h2v-4h3l-4-4l-4 4zm8-14h-3V1h-2v4H8l4 4l4-4zM4 11v2h16v-2H4z" fill="currentColor"></path></svg>`;
+var TextVerticalAlignBottomIcon = createSvgStr(ArrowDownToLine);
+//#endregion
+//#region src/text/extraFormatter.ts
+var Formatter = /* @__PURE__ */ function(Formatter) {
+	Formatter["STRIKETHROUGH"] = "strikethrough";
+	Formatter["UNDERLINE"] = "underline";
+	Formatter["ALIGNMENT"] = "alignment";
+	Formatter["VERTICAL_ALIGNMENT"] = "verticalAlignment";
+	return Formatter;
+}({});
+function getExtraFormatterSchema(i18n) {
+	const buttons = [
+		{
+			key: Formatter.STRIKETHROUGH,
+			icon: TextStrikethroughIcon,
+			type: "boolean"
+		},
+		{
+			key: Formatter.UNDERLINE,
+			icon: TextUnderlineIcon,
+			type: "boolean"
+		},
+		{
+			key: Formatter.ALIGNMENT,
+			icon: TextAlignLeftIcon,
+			type: "select",
+			value: DEFAULT_ALIGNMENT
+		},
+		{
+			key: Formatter.ALIGNMENT,
+			icon: TextAlignCenterIcon,
+			type: "select",
+			value: ALIGN_CENTER
+		},
+		{
+			key: Formatter.ALIGNMENT,
+			icon: TextAlignRightIcon,
+			type: "select",
+			value: ALIGN_RIGHT
+		},
+		{
+			key: Formatter.ALIGNMENT,
+			icon: TextAlignJustifyIcon,
+			type: "select",
+			value: ALIGN_JUSTIFY
+		},
+		{
+			key: Formatter.VERTICAL_ALIGNMENT,
+			icon: TextVerticalAlignTopIcon,
+			type: "select",
+			value: "top"
+		},
+		{
+			key: Formatter.VERTICAL_ALIGNMENT,
+			icon: TextVerticalAlignMiddleIcon,
+			type: "select",
+			value: VERTICAL_ALIGN_MIDDLE
+		},
+		{
+			key: Formatter.VERTICAL_ALIGNMENT,
+			icon: TextVerticalAlignBottomIcon,
+			type: "select",
+			value: VERTICAL_ALIGN_BOTTOM
+		}
+	];
+	return {
+		title: i18n("schemas.text.format"),
+		widget: "ButtonGroup",
+		buttons,
+		span: 24
+	};
+}
+//#endregion
+//#region src/text/propPanel.ts
+var UseDynamicFontSize = (props) => {
+	const { rootElement, changeSchemas, activeSchema, i18n } = props;
+	const checkbox = document.createElement("input");
+	checkbox.type = "checkbox";
+	checkbox.checked = Boolean(activeSchema?.dynamicFontSize);
+	checkbox.onchange = (e) => {
+		changeSchemas([{
+			key: "dynamicFontSize",
+			value: e.target.checked ? {
+				min: 4,
+				max: 72,
+				fit: DEFAULT_DYNAMIC_FIT
+			} : void 0,
+			schemaId: activeSchema.id
+		}]);
+	};
+	const label = document.createElement("label");
+	const span = document.createElement("span");
+	span.innerText = i18n("schemas.text.dynamicFontSize") || "";
+	span.style.cssText = "margin-left: 0.5rem";
+	label.style.cssText = "display: flex; width: 100%;";
+	label.appendChild(checkbox);
+	label.appendChild(span);
+	rootElement.appendChild(label);
+};
+var UseInlineMarkdown = (props) => {
+	const { rootElement, changeSchemas, activeSchema, i18n } = props;
+	const checkbox = document.createElement("input");
+	checkbox.type = "checkbox";
+	checkbox.checked = activeSchema?.textFormat === TEXT_FORMAT_INLINE_MARKDOWN;
+	checkbox.onchange = (e) => {
+		changeSchemas([{
+			key: "textFormat",
+			value: e.target.checked ? TEXT_FORMAT_INLINE_MARKDOWN : TEXT_FORMAT_PLAIN,
+			schemaId: activeSchema.id
+		}]);
+	};
+	const label = document.createElement("label");
+	const span = document.createElement("span");
+	span.innerText = i18n("schemas.text.inlineMarkdown") || "";
+	span.style.cssText = "margin-left: 0.5rem";
+	label.style.cssText = "display: flex; width: 100%;";
+	label.appendChild(checkbox);
+	label.appendChild(span);
+	rootElement.appendChild(label);
+};
+var propPanel = {
+	schema: ({ options, activeSchema, i18n }) => {
+		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 hideTextFormat = activeTextSchema.type === "text" && activeTextSchema.readOnly !== true;
+		const enableInlineMarkdown = activeTextSchema.textFormat === "inline-markdown" && !hideTextFormat;
+		const baseFontName = activeTextSchema.fontName && font[activeTextSchema.fontName] ? activeTextSchema.fontName : fallbackFontName;
+		const optionalFontNames = [{
+			label: baseFontName,
+			value: ""
+		}, ...fontNames.filter((name) => name !== baseFontName).map((name) => ({
+			label: name,
+			value: name
+		}))];
+		return {
+			fontName: {
+				title: i18n("schemas.text.fontName"),
+				type: "string",
+				widget: "select",
+				default: fallbackFontName,
+				placeholder: fallbackFontName,
+				props: { options: fontNames.map((name) => ({
+					label: name,
+					value: name
+				})) },
+				span: 12
+			},
+			fontSize: {
+				title: i18n("schemas.text.size"),
+				type: "number",
+				widget: "inputNumber",
+				span: 6,
+				disabled: enableDynamicFont,
+				props: { min: 0 }
+			},
+			characterSpacing: {
+				title: i18n("schemas.text.spacing"),
+				type: "number",
+				widget: "inputNumber",
+				span: 6,
+				props: { min: 0 }
+			},
+			formatter: getExtraFormatterSchema(i18n),
+			lineHeight: {
+				title: i18n("schemas.text.lineHeight"),
+				type: "number",
+				widget: "inputNumber",
+				props: {
+					step: .1,
+					min: 0
+				},
+				span: 8
+			},
+			useDynamicFontSize: {
+				type: "boolean",
+				widget: "UseDynamicFontSize",
+				bind: false,
+				span: 16
+			},
+			dynamicFontSize: {
+				type: "object",
+				widget: "card",
+				column: 3,
+				properties: {
+					min: {
+						title: i18n("schemas.text.min"),
+						type: "number",
+						widget: "inputNumber",
+						hidden: !enableDynamicFont,
+						props: { min: 0 }
+					},
+					max: {
+						title: i18n("schemas.text.max"),
+						type: "number",
+						widget: "inputNumber",
+						hidden: !enableDynamicFont,
+						props: { min: 0 }
+					},
+					fit: {
+						title: i18n("schemas.text.fit"),
+						type: "string",
+						widget: "select",
+						hidden: !enableDynamicFont,
+						props: { options: [{
+							label: i18n("schemas.horizontal"),
+							value: DYNAMIC_FIT_HORIZONTAL
+						}, {
+							label: i18n("schemas.vertical"),
+							value: DYNAMIC_FIT_VERTICAL
+						}] }
+					}
+				}
+			},
+			fontColor: {
+				title: i18n("schemas.textColor"),
+				type: "string",
+				widget: "color",
+				props: { disabledAlpha: true },
+				rules: [{
+					pattern: HEX_COLOR_PATTERN,
+					message: i18n("validation.hexColor")
+				}]
+			},
+			backgroundColor: {
+				title: i18n("schemas.bgColor"),
+				type: "string",
+				widget: "color",
+				props: { disabledAlpha: true },
+				rules: [{
+					pattern: HEX_COLOR_PATTERN,
+					message: i18n("validation.hexColor")
+				}]
+			},
+			useInlineMarkdown: {
+				type: "boolean",
+				widget: "UseInlineMarkdown",
+				bind: false,
+				hidden: hideTextFormat,
+				span: enableInlineMarkdown ? 12 : 24
+			},
+			fontVariantFallback: {
+				title: i18n("schemas.text.variantFallback"),
+				type: "string",
+				widget: "select",
+				default: DEFAULT_FONT_VARIANT_FALLBACK,
+				hidden: !enableInlineMarkdown,
+				props: { options: [
+					{
+						label: i18n("schemas.text.synthetic"),
+						value: FONT_VARIANT_FALLBACK_SYNTHETIC
+					},
+					{
+						label: i18n("schemas.text.plain"),
+						value: FONT_VARIANT_FALLBACK_PLAIN
+					},
+					{
+						label: i18n("schemas.text.error"),
+						value: FONT_VARIANT_FALLBACK_ERROR
+					}
+				] },
+				span: 12
+			},
+			fontVariants: {
+				title: i18n("schemas.text.markdownFonts"),
+				type: "object",
+				widget: "card",
+				column: 2,
+				hidden: !enableInlineMarkdown,
+				properties: {
+					bold: {
+						title: i18n("schemas.text.boldFont"),
+						type: "string",
+						widget: "select",
+						props: { options: optionalFontNames }
+					},
+					italic: {
+						title: i18n("schemas.text.italicFont"),
+						type: "string",
+						widget: "select",
+						props: { options: optionalFontNames }
+					},
+					boldItalic: {
+						title: i18n("schemas.text.boldItalicFont"),
+						type: "string",
+						widget: "select",
+						props: { options: optionalFontNames }
+					},
+					code: {
+						title: i18n("schemas.text.codeFont"),
+						type: "string",
+						widget: "select",
+						props: { options: optionalFontNames }
+					}
+				}
+			}
+		};
+	},
+	widgets: {
+		UseDynamicFontSize,
+		UseInlineMarkdown
+	},
+	defaultSchema: {
+		name: "",
+		type: "text",
+		content: "Type Something...",
+		position: {
+			x: 0,
+			y: 0
+		},
+		width: 45,
+		height: 10,
+		rotate: 0,
+		alignment: DEFAULT_ALIGNMENT,
+		verticalAlignment: "top",
+		fontSize: 13,
+		textFormat: DEFAULT_TEXT_FORMAT,
+		fontVariantFallback: DEFAULT_FONT_VARIANT_FALLBACK,
+		lineHeight: 1,
+		characterSpacing: 0,
+		dynamicFontSize: void 0,
+		fontColor: DEFAULT_FONT_COLOR,
+		fontName: void 0,
+		backgroundColor: "",
+		opacity: 1,
+		strikethrough: false,
+		underline: false
+	}
+};
+//#endregion
+//#region src/text/uiRender.ts
+var replaceUnsupportedChars = (text, fontKitFont) => {
+	const charSupportCache = {};
+	const isCharSupported = (char) => {
+		if (char in charSupportCache) return charSupportCache[char];
+		const isSupported = fontKitFont.hasGlyphForCodePoint(char.codePointAt(0) || 0);
+		charSupportCache[char] = isSupported;
+		return isSupported;
+	};
+	return text.split(/(\r\n|\n|\r)/).map((segment) => {
+		if (/\r\n|\n|\r/.test(segment)) return segment;
+		return Array.from(segment).map((char) => {
+			if (/\s/.test(char) || char.charCodeAt(0) < 32) return char;
+			return isCharSupported(char) ? char : "〿";
+		}).join("");
+	}).join("");
+};
+var uiRender = async (arg) => {
+	const { value, schema, mode, onChange, stopEditing, tabIndex, placeholder, options, _cache } = arg;
+	const usePlaceholder = isEditable(mode, schema) && placeholder && !value;
+	const getText = (element) => {
+		let text = element.innerText;
+		if (text.endsWith("\n")) text = text.slice(0, -1);
+		return text;
+	};
+	const font = options?.font || getDefaultFont();
+	const fontKitFont = await getFontKitFont(schema.fontName, font, _cache);
+	const enableInlineMarkdown = isInlineMarkdownTextSchema(schema);
+	const displayValue = enableInlineMarkdown ? stripInlineMarkdown(value) : value;
+	const dynamicRichTextFontSize = enableInlineMarkdown && schema.dynamicFontSize ? 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) {
+			await renderInlineMarkdownReadOnly({
+				textBlock,
+				value,
+				schema,
+				font,
+				_cache
+			});
+			return;
+		}
+		textBlock.innerHTML = processedText.split("").map((l, i) => {
+			const escaped = l.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+			return `<span style="letter-spacing:${String(value).length === i + 1 ? 0 : "inherit"};">${escaped}</span>`;
+		}).join("");
+		return;
+	}
+	makeElementPlainTextContentEditable(textBlock);
+	textBlock.tabIndex = tabIndex || 0;
+	textBlock.innerText = mode === "designer" ? value : processedText;
+	textBlock.addEventListener("blur", (e) => {
+		if (onChange) onChange({
+			key: "content",
+			value: getText(e.target)
+		});
+		if (stopEditing) stopEditing();
+	});
+	if (schema.dynamicFontSize) {
+		let dynamicFontSize = void 0;
+		textBlock.addEventListener("keyup", () => {
+			setTimeout(() => {
+				(() => {
+					if (!textBlock.textContent) return;
+					dynamicFontSize = calculateDynamicFontSize({
+						textSchema: schema,
+						fontKitFont,
+						value: isInlineMarkdownTextSchema(schema) ? stripInlineMarkdown(getText(textBlock)) : getText(textBlock),
+						startingFontSize: dynamicFontSize
+					});
+					textBlock.style.fontSize = `${dynamicFontSize}pt`;
+					const { topAdj: newTopAdj, bottomAdj: newBottomAdj } = getBrowserVerticalFontAdjustments(fontKitFont, dynamicFontSize ?? schema.fontSize ?? 13, schema.lineHeight ?? 1, schema.verticalAlignment ?? "top");
+					textBlock.style.paddingTop = `${newTopAdj}px`;
+					textBlock.style.marginBottom = `${newBottomAdj}px`;
+				})();
+			}, 0);
+		});
+	}
+	if (usePlaceholder) {
+		textBlock.style.color = PLACEHOLDER_FONT_COLOR;
+		textBlock.addEventListener("focus", () => {
+			if (textBlock.innerText === placeholder) {
+				textBlock.innerText = "";
+				textBlock.style.color = schema.fontColor ?? "#000000";
+			}
+		});
+	}
+	if (mode === "designer") setTimeout(() => {
+		textBlock.focus();
+		const selection = window.getSelection();
+		const range = document.createRange();
+		if (selection && range) {
+			range.selectNodeContents(textBlock);
+			range.collapse(false);
+			selection?.removeAllRanges();
+			selection?.addRange(range);
+		}
+	});
+};
+var renderInlineMarkdownReadOnly = async (arg) => {
+	const { textBlock, value, schema, font, _cache } = arg;
+	const runs = await resolveRichTextRuns({
+		runs: parseInlineMarkdown(value),
+		schema,
+		font,
+		_cache
+	});
+	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);
+	});
+};
+var buildStyledTextContainer = (arg, fontKitFont, value, resolvedDynamicFontSize) => {
+	const { schema, rootElement, mode } = arg;
+	let dynamicFontSize = resolvedDynamicFontSize;
+	if (dynamicFontSize === void 0 && schema.dynamicFontSize && value) dynamicFontSize = calculateDynamicFontSize({
+		textSchema: schema,
+		fontKitFont,
+		value,
+		startingFontSize: dynamicFontSize
+	});
+	const { topAdj, bottomAdj } = getBrowserVerticalFontAdjustments(fontKitFont, dynamicFontSize ?? schema.fontSize ?? 13, schema.lineHeight ?? 1, schema.verticalAlignment ?? "top");
+	const topAdjustment = topAdj.toString();
+	const bottomAdjustment = bottomAdj.toString();
+	const container = document.createElement("div");
+	const containerStyle = {
+		padding: 0,
+		resize: "none",
+		backgroundColor: getBackgroundColor(value, schema),
+		border: "none",
+		display: "flex",
+		flexDirection: "column",
+		justifyContent: mapVerticalAlignToFlex(schema.verticalAlignment),
+		width: "100%",
+		height: "100%",
+		cursor: isEditable(mode, schema) ? "text" : "default"
+	};
+	Object.assign(container.style, containerStyle);
+	rootElement.innerHTML = "";
+	rootElement.appendChild(container);
+	const textDecorations = [];
+	if (schema.strikethrough) textDecorations.push("line-through");
+	if (schema.underline) textDecorations.push("underline");
+	const textBlockStyle = {
+		fontFamily: schema.fontName ? `'${schema.fontName}'` : "inherit",
+		color: schema.fontColor ? schema.fontColor : DEFAULT_FONT_COLOR,
+		fontSize: `${dynamicFontSize ?? schema.fontSize ?? 13}pt`,
+		letterSpacing: `${schema.characterSpacing ?? 0}pt`,
+		lineHeight: `${schema.lineHeight ?? 1}em`,
+		textAlign: schema.alignment ?? "left",
+		whiteSpace: "pre-wrap",
+		wordBreak: "break-word",
+		resize: "none",
+		border: "none",
+		outline: "none",
+		marginBottom: `${bottomAdjustment}px`,
+		paddingTop: `${topAdjustment}px`,
+		backgroundColor: "transparent",
+		textDecoration: textDecorations.join(" ")
+	};
+	const textBlock = document.createElement("div");
+	textBlock.id = "text-" + String(schema.id);
+	Object.assign(textBlock.style, textBlockStyle);
+	container.appendChild(textBlock);
+	return textBlock;
+};
+/**
+* Firefox doesn't support 'plaintext-only' contentEditable mode, which we want to avoid mark-up.
+* This function adds a workaround for Firefox to make the contentEditable element behave like 'plaintext-only'.
+*/
+var makeElementPlainTextContentEditable = (element) => {
+	if (!isFirefox()) {
+		element.contentEditable = "plaintext-only";
+		return;
+	}
+	element.contentEditable = "true";
+	element.addEventListener("keydown", (e) => {
+		if (e.key === "Enter" && !e.shiftKey) {
+			e.preventDefault();
+			document.execCommand("insertLineBreak", false, void 0);
+		}
+	});
+	element.addEventListener("paste", (e) => {
+		e.preventDefault();
+		const paste = e.clipboardData?.getData("text");
+		const selection = window.getSelection();
+		if (!selection?.rangeCount) return;
+		selection.deleteFromDocument();
+		selection.getRangeAt(0).insertNode(document.createTextNode(paste || ""));
+		selection.collapseToEnd();
+	});
+};
+var mapVerticalAlignToFlex = (verticalAlignmentValue) => {
+	switch (verticalAlignmentValue) {
+		case "top": return "flex-start";
+		case VERTICAL_ALIGN_MIDDLE: return "center";
+		case VERTICAL_ALIGN_BOTTOM: return "flex-end";
+	}
+	return "flex-start";
+};
+var getBackgroundColor = (value, schema) => {
+	if (!value || !schema.backgroundColor) return "transparent";
+	return schema.backgroundColor;
+};
+//#endregion
+//#region src/text/index.ts
+var textSchema = {
+	pdf: pdfRender,
+	ui: uiRender,
+	propPanel,
+	icon: createSvgStr(TextCursorInput)
+};
+//#endregion
+//#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 };
+
+//# sourceMappingURL=builtins-C0BvXHWr.js.map