@pdfme/schemas 6.0.3 → 6.0.5-dev.1

package/dist/barcodes/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BARCODE_TYPES: readonly ["qrcode", "japanpost", "ean13", "ean8", "code39", "code128", "nw7", "itf14", "upca", "upce", "gs1datamatrix", "pdf417"];
+export declare const DEFAULT_BARCODE_BG_COLOR = "#ffffff";
+export declare const DEFAULT_BARCODE_COLOR = "#000000";
+export declare const DEFAULT_BARCODE_INCLUDETEXT = true;

package/dist/barcodes/helper.d.ts

@@ -0,0 +1,21 @@
+import { Buffer } from 'buffer';
+import { BarcodeTypes } from './types.js';
+export declare const validateBarcodeInput: (type: BarcodeTypes, input: string) => boolean;
+/**
+ * The bwip.js lib has a different name for nw7 type barcodes
+ */
+export declare const barCodeType2Bcid: (type: BarcodeTypes) => "qrcode" | "japanpost" | "ean13" | "ean8" | "code39" | "code128" | "itf14" | "upca" | "upce" | "gs1datamatrix" | "pdf417" | "rationalizedCodabar";
+/**
+ *  Strip hash from the beginning of HTML hex color codes for the bwip.js lib
+ */
+export declare const mapHexColorForBwipJsLib: (color: string | undefined, fallback?: string) => string;
+export declare const createBarCode: (arg: {
+    type: BarcodeTypes;
+    input: string;
+    width: number;
+    height: number;
+    backgroundColor?: string;
+    barColor?: string;
+    textColor?: string;
+    includetext?: boolean;
+}) => Promise<Buffer>;

package/dist/barcodes/index.d.ts

@@ -0,0 +1,4 @@
+import type { BarcodeSchema } from './types.js';
+import { Plugin } from '@pdfme/common';
+declare const barcodes: Record<"qrcode" | "japanpost" | "ean13" | "ean8" | "code39" | "code128" | "nw7" | "itf14" | "upca" | "upce" | "gs1datamatrix" | "pdf417", Plugin<BarcodeSchema>>;
+export default barcodes;

package/dist/barcodes/pdfRender.d.ts

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

package/dist/barcodes/propPanel.d.ts

@@ -0,0 +1,3 @@
+import type { PropPanel } from '@pdfme/common';
+import type { BarcodeSchema } from './types.js';
+export declare const getPropPanelByBarcodeType: (barcodeType: string) => PropPanel<BarcodeSchema>;

package/{src/barcodes/types.ts → dist/barcodes/types.d.ts}

@@ -1,12 +1,10 @@
 import { Schema } from '@pdfme/common';
 import { BARCODE_TYPES } from './constants.js';
-
 export type BarcodeSchema = Schema & {
-  type: (typeof BARCODE_TYPES)[number];
-  backgroundColor: string;
-  barColor: string;
-  textColor?: string;
-  includetext?: boolean;
+    type: (typeof BARCODE_TYPES)[number];
+    backgroundColor: string;
+    barColor: string;
+    textColor?: string;
+    includetext?: boolean;
 };
-
 export type BarcodeTypes = (typeof BARCODE_TYPES)[number];

package/dist/barcodes/uiRender.d.ts

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

package/dist/builtins-CgaZ0UX3.js

@@ -0,0 +1,613 @@
+import { C as DEFAULT_FONT_COLOR, D as VERTICAL_ALIGN_BOTTOM, E as PLACEHOLDER_FONT_COLOR, O as VERTICAL_ALIGN_MIDDLE, S as DEFAULT_DYNAMIC_FIT, T as DYNAMIC_FIT_VERTICAL, _ as widthOfTextAtSize, b as ALIGN_RIGHT, d as getBrowserVerticalFontAdjustments, f as getFontDescentInPt, g as splitTextToSize, h as isFirefox, l as calculateDynamicFontSize, m as heightOfFontAtSize, p as getFontKitFont, s as HEX_COLOR_PATTERN, u as fetchRemoteFontData, v as ALIGN_CENTER, w as DYNAMIC_FIT_HORIZONTAL, x as DEFAULT_ALIGNMENT, y as ALIGN_JUSTIFY } from "./dynamicTemplate-D_DHR3-X.js";
+import { convertForPdfLayoutProps, createSvgStr, hex2PrintingColor, isEditable, rotatePoint } from "./utils.js";
+import { DEFAULT_FONT_NAME, getDefaultFont, getFallbackFontName, mm2pt } from "@pdfme/common";
+import { AlignCenter, AlignJustify, AlignLeft, AlignRight, ArrowDownToLine, ArrowUpToLine, Strikethrough, TextCursorInput, Underline } from "lucide";
+//#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 }) => {
+	const fontSize = 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 { fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing } = getFontProp({
+		value,
+		fontKitFont,
+		schema,
+		colorType
+	});
+	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
+		});
+	}
+	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 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);
+		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")
+				}]
+			}
+		};
+	},
+	widgets: { UseDynamicFontSize },
+	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,
+		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 segment.split("").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 textBlock = buildStyledTextContainer(arg, fontKitFont, usePlaceholder ? placeholder : value);
+	const processedText = replaceUnsupportedChars(value, fontKitFont);
+	if (!isEditable(mode, schema)) {
+		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: 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 buildStyledTextContainer = (arg, fontKitFont, value) => {
+	const { schema, rootElement, mode } = arg;
+	let dynamicFontSize = void 0;
+	if (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, 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-CgaZ0UX3.js.map