@pdfme/schemas 6.1.0 → 6.1.1-dev.5

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

@@ -1,17 +1,23 @@
-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 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 { 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, pt2mm, 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 MARKDOWN_ESCAPE_PATTERN = /[\\*~`[\]()]/g;
+var MARKDOWN_UNESCAPE_PATTERN = /\\([\\*~`[\]()])/g;
+var sameStyle = (a, b) => Boolean(a.bold) === Boolean(b.bold) && Boolean(a.italic) === Boolean(b.italic) && Boolean(a.strikethrough) === Boolean(b.strikethrough) && Boolean(a.code) === Boolean(b.code) && a.href === b.href;
 var appendRun = (runs, text, style) => {
 	if (!text) return;
 	const lastRun = runs.at(-1);
@@ -24,7 +30,8 @@ var appendRun = (runs, text, style) => {
 		...style.bold ? { bold: true } : {},
 		...style.italic ? { italic: true } : {},
 		...style.strikethrough ? { strikethrough: true } : {},
-		...style.code ? { code: true } : {}
+		...style.code ? { code: true } : {},
+		...style.href ? { href: style.href } : {}
 	});
 };
 var findClosingDelimiter = (value, delimiter, from) => {
@@ -51,6 +58,50 @@ var getDelimiter = (value, index) => {
 	if (value[index] === "*") return "*";
 	return "";
 };
+var findLinkLabelEnd = (value, from, to) => {
+	for (let index = from; index < to; index += 1) {
+		if (value[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (value[index] === "]") return index;
+	}
+	return -1;
+};
+var findLinkDestinationEnd = (value, from, to) => {
+	let depth = 0;
+	for (let index = from; index < to; index += 1) {
+		if (value[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (value[index] === "(") {
+			depth += 1;
+			continue;
+		}
+		if (value[index] === ")") {
+			if (depth === 0) return index;
+			depth -= 1;
+		}
+	}
+	return -1;
+};
+var parseLinkAt = (value, index, to) => {
+	if (value[index] !== "[") return void 0;
+	const labelEnd = findLinkLabelEnd(value, index + 1, to);
+	if (labelEnd === -1 || value[labelEnd + 1] !== "(") return void 0;
+	const destinationStart = labelEnd + 2;
+	const destinationEnd = findLinkDestinationEnd(value, destinationStart, to);
+	if (destinationEnd === -1) return void 0;
+	const safeHref = normalizeLinkHref(value.slice(destinationStart, destinationEnd).replace(MARKDOWN_UNESCAPE_PATTERN, "$1"));
+	if (!safeHref) return void 0;
+	return {
+		labelStart: index + 1,
+		labelEnd,
+		href: safeHref,
+		end: destinationEnd + 1
+	};
+};
 var mergeStyle = (style, delimiter) => {
 	if (delimiter === "***") return {
 		...style,
@@ -85,6 +136,16 @@ var parseRange = (value, from, to, style) => {
 			index += 1;
 			continue;
 		}
+		const link = style.href ? void 0 : parseLinkAt(value, index, to);
+		if (link) {
+			flush();
+			parseRange(value, link.labelStart, link.labelEnd, {
+				...style,
+				href: link.href
+			}).forEach((run) => appendRun(runs, run.text, run));
+			index = link.end - 1;
+			continue;
+		}
 		const delimiter = getDelimiter(value, index);
 		if (!delimiter) {
 			buffer += char;
@@ -422,15 +483,48 @@ var calculateDynamicRichTextFontSize = async (arg) => {
 	return dynamicFontSize;
 };
 //#endregion
+//#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)
+		}
+	}));
+	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 +542,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 +628,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,7 +666,7 @@ 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 { 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 lines = layoutRichTextLines({
 		runs: await resolveRichTextRuns({
 			runs: parseInlineMarkdown(value),
@@ -523,6 +678,7 @@ var renderInlineMarkdownText = async (arg) => {
 		characterSpacing,
 		boxWidthInPt: width
 	});
+	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;
@@ -580,7 +736,7 @@ var renderInlineMarkdownText = async (arg) => {
 				page,
 				pdfLib,
 				run,
-				pdfFont: getPdfFont(run, pdfFontObj),
+				pdfFont: getPdfFontFromObj(run, pdfFontObj),
 				x: currentX,
 				y: yLine,
 				rotate,
@@ -591,25 +747,62 @@ 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/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({
@@ -627,16 +820,24 @@ 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;
 	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,
@@ -649,8 +850,6 @@ var pdfRender = async (arg) => {
 			_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 +889,14 @@ var pdfRender = async (arg) => {
 			value,
 			schema,
 			font,
-			pdfFontObj,
+			embedPdfFont: (fontName) => embedAndGetFont({
+				pdfDoc,
+				font,
+				fontName,
+				_cache
+			}),
 			fontKitFont,
+			pdfDoc,
 			page,
 			pdfLib,
 			_cache,
@@ -712,6 +917,8 @@ 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;
@@ -722,6 +929,8 @@ var pdfRender = async (arg) => {
 		fontKitFont,
 		boxWidthInPt: width
 	});
+	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 +938,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 +992,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;
 		}
@@ -1261,15 +1469,28 @@ var renderInlineMarkdownReadOnly = async (arg) => {
 	});
 	textBlock.innerHTML = "";
 	runs.forEach((run) => {
-		const span = document.createElement("span");
-		span.textContent = replaceUnsupportedChars(run.text, run.fontKitFont);
+		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) span.style.textDecoration = "line-through";
+		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";
@@ -1385,4 +1606,4 @@ 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
+//# sourceMappingURL=builtins-BpOyUs31.js.map