@react-email/editor 0.0.0-experimental.1 → 0.0.0-experimental.10

package/dist/index.mjs

@@ -1,12 +1,19 @@
-import { Node, findChildren, mergeAttributes } from "@tiptap/core";
-import { jsx } from "react/jsx-runtime";
+import { Extension, Mark, Node, findChildren, markInputRule, markPasteRule, mergeAttributes } from "@tiptap/core";
+import { StarterKit } from "@tiptap/starter-kit";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import * as ReactEmailComponents from "@react-email/components";
 import { Button as Button$1, CodeBlock, Column, Row, Section as Section$1 } from "@react-email/components";
 import CodeBlock$1 from "@tiptap/extension-code-block";
-import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import { fromHtml } from "hast-util-from-html";
 import Prism from "prismjs";
+import TipTapPlaceholder from "@tiptap/extension-placeholder";
+import { useCurrentEditor, useEditorState } from "@tiptap/react";
+import { AlignCenterIcon, AlignLeftIcon, AlignRightIcon, BoldIcon, CaseUpperIcon, Check, ChevronDown, Code, CodeIcon, ExternalLinkIcon, Heading1, Heading2, Heading3, ItalicIcon, LinkIcon, List, ListOrdered, PencilIcon, StrikethroughIcon, TextIcon, TextQuote, UnderlineIcon, UnlinkIcon } from "lucide-react";
+import * as React from "react";
+import * as Popover from "@radix-ui/react-popover";
+import { BubbleMenu as BubbleMenu$1 } from "@tiptap/react/menus";
 
 //#region src/core/email-node.ts
 var EmailNode = class EmailNode extends Node {
@@ -38,6 +45,103 @@ var EmailNode = class EmailNode extends Node {
 	}
 };
 
+//#endregion
+//#region src/core/event-bus.ts
+const EVENT_PREFIX = "@react-email/editor:";
+var EditorEventBus = class {
+	prefixEventName(eventName) {
+		return `${EVENT_PREFIX}${String(eventName)}`;
+	}
+	dispatch(eventName, payload, options) {
+		const target = options?.target ?? window;
+		const prefixedEventName = this.prefixEventName(eventName);
+		const event = new CustomEvent(prefixedEventName, {
+			detail: payload,
+			bubbles: false,
+			cancelable: false
+		});
+		target.dispatchEvent(event);
+	}
+	on(eventName, handler, options) {
+		const target = options?.target ?? window;
+		const prefixedEventName = this.prefixEventName(eventName);
+		const abortController = new AbortController();
+		const wrappedHandler = (event) => {
+			const customEvent = event;
+			const result = handler(customEvent.detail);
+			if (result instanceof Promise) result.catch((error) => {
+				console.error(`Error in async event handler for ${prefixedEventName}:`, {
+					event: customEvent.detail,
+					error
+				});
+			});
+		};
+		target.addEventListener(prefixedEventName, wrappedHandler, {
+			...options,
+			signal: abortController.signal
+		});
+		return { unsubscribe: () => {
+			abortController.abort();
+		} };
+	}
+};
+const editorEventBus = new EditorEventBus();
+
+//#endregion
+//#region src/extensions/alignment-attribute.tsx
+const AlignmentAttribute = Extension.create({
+	name: "alignmentAttribute",
+	addOptions() {
+		return {
+			types: [],
+			alignments: [
+				"left",
+				"center",
+				"right",
+				"justify"
+			]
+		};
+	},
+	addGlobalAttributes() {
+		return [{
+			types: this.options.types,
+			attributes: { alignment: {
+				parseHTML: (element) => {
+					const explicitAlign = element.getAttribute("align") || element.getAttribute("alignment") || element.style.textAlign;
+					if (explicitAlign && this.options.alignments.includes(explicitAlign)) return explicitAlign;
+					return null;
+				},
+				renderHTML: (attributes) => {
+					if (attributes.alignment === "left") return {};
+					return { alignment: attributes.alignment };
+				}
+			} }
+		}];
+	},
+	addCommands() {
+		return { setAlignment: (alignment) => ({ commands }) => {
+			if (!this.options.alignments.includes(alignment)) return false;
+			return this.options.types.every((type) => commands.updateAttributes(type, { alignment }));
+		} };
+	},
+	addKeyboardShortcuts() {
+		return {
+			Enter: () => {
+				const { from } = this.editor.state.selection;
+				const currentAlignment = this.editor.state.doc.nodeAt(from)?.attrs?.alignment;
+				if (currentAlignment) requestAnimationFrame(() => {
+					this.editor.commands.setAlignment(currentAlignment);
+				});
+				return false;
+			},
+			"Mod-Shift-l": () => this.editor.commands.setAlignment("left"),
+			"Mod-Shift-e": () => this.editor.commands.setAlignment("center"),
+			"Mod-Shift-r": () => this.editor.commands.setAlignment("right"),
+			"Mod-Shift-j": () => this.editor.commands.setAlignment("justify")
+		};
+	}
+});
+
 //#endregion
 //#region src/utils/attribute-helpers.ts
 /**
@@ -94,6 +198,14 @@ const LAYOUT_ATTRIBUTES = [
 	"height"
 ];
 /**
+* Table-specific HTML attributes used for table layout and styling.
+*/
+const TABLE_ATTRIBUTES = [
+	"border",
+	"cellpadding",
+	"cellspacing"
+];
+/**
 * Table cell-specific HTML attributes.
 */
 const TABLE_CELL_ATTRIBUTES = [
@@ -110,6 +222,7 @@ const TABLE_HEADER_ATTRIBUTES = [...TABLE_CELL_ATTRIBUTES, "scope"];
 
 //#endregion
 //#region src/utils/styles.ts
+const WHITE_SPACE_REGEX = /\s+/;
 const inlineCssToJs = (inlineStyle, options = {}) => {
 	const styleObject = {};
 	if (!inlineStyle || inlineStyle === "" || typeof inlineStyle === "object") return styleObject;
@@ -124,6 +237,157 @@ const inlineCssToJs = (inlineStyle, options = {}) => {
 	});
 	return styleObject;
 };
+/**
+* Expands CSS shorthand properties (margin, padding) into their longhand equivalents.
+* This prevents shorthand properties from overriding specific longhand properties in email clients.
+*
+* @param styles - Style object that may contain shorthand properties
+* @returns New style object with shorthand properties expanded to longhand
+*
+* @example
+* expandShorthandProperties({ margin: '0', paddingTop: '10px' })
+* // Returns: { marginTop: '0', marginRight: '0', marginBottom: '0', marginLeft: '0', paddingTop: '10px' }
+*/
+function expandShorthandProperties(styles) {
+	if (!styles || typeof styles !== "object") return {};
+	const expanded = {};
+	for (const key in styles) {
+		const value = styles[key];
+		if (value === void 0 || value === null || value === "") continue;
+		switch (key) {
+			case "margin": {
+				const values = parseShorthandValue(value);
+				expanded.marginTop = values.top;
+				expanded.marginRight = values.right;
+				expanded.marginBottom = values.bottom;
+				expanded.marginLeft = values.left;
+				break;
+			}
+			case "padding": {
+				const values = parseShorthandValue(value);
+				expanded.paddingTop = values.top;
+				expanded.paddingRight = values.right;
+				expanded.paddingBottom = values.bottom;
+				expanded.paddingLeft = values.left;
+				break;
+			}
+			case "border": {
+				const values = convertBorderValue(value);
+				expanded.borderStyle = values.style;
+				expanded.borderWidth = values.width;
+				expanded.borderColor = values.color;
+				break;
+			}
+			case "borderTopLeftRadius":
+			case "borderTopRightRadius":
+			case "borderBottomLeftRadius":
+			case "borderBottomRightRadius":
+				expanded[key] = value;
+				if (styles.borderTopLeftRadius && styles.borderTopRightRadius && styles.borderBottomLeftRadius && styles.borderBottomRightRadius) {
+					const values = [
+						styles.borderTopLeftRadius,
+						styles.borderTopRightRadius,
+						styles.borderBottomLeftRadius,
+						styles.borderBottomRightRadius
+					];
+					if (new Set(values).size === 1) expanded.borderRadius = values[0];
+				}
+				break;
+			default: expanded[key] = value;
+		}
+	}
+	return expanded;
+}
+/**
+* Parses CSS shorthand value (1-4 values) into individual side values.
+* Follows CSS specification for shorthand property value parsing.
+*
+* @param value - Shorthand value string (e.g., '0', '10px 20px', '5px 10px 15px 20px')
+* @returns Object with top, right, bottom, left values
+*/
+function parseShorthandValue(value) {
+	const stringValue = String(value).trim();
+	const parts = stringValue.split(WHITE_SPACE_REGEX);
+	const len = parts.length;
+	if (len === 1) return {
+		top: parts[0],
+		right: parts[0],
+		bottom: parts[0],
+		left: parts[0]
+	};
+	if (len === 2) return {
+		top: parts[0],
+		right: parts[1],
+		bottom: parts[0],
+		left: parts[1]
+	};
+	if (len === 3) return {
+		top: parts[0],
+		right: parts[1],
+		bottom: parts[2],
+		left: parts[1]
+	};
+	if (len === 4) return {
+		top: parts[0],
+		right: parts[1],
+		bottom: parts[2],
+		left: parts[3]
+	};
+	return {
+		top: stringValue,
+		right: stringValue,
+		bottom: stringValue,
+		left: stringValue
+	};
+}
+function convertBorderValue(value) {
+	const stringValue = String(value).trim();
+	const parts = stringValue.split(WHITE_SPACE_REGEX);
+	switch (parts.length) {
+		case 1: return {
+			style: "solid",
+			width: parts[0],
+			color: "black"
+		};
+		case 2: return {
+			style: parts[1],
+			width: parts[0],
+			color: "black"
+		};
+		case 3: return {
+			style: parts[1],
+			width: parts[0],
+			color: parts[2]
+		};
+		case 4: return {
+			style: parts[1],
+			width: parts[0],
+			color: parts[2]
+		};
+		default: return {
+			style: "solid",
+			width: stringValue,
+			color: "black"
+		};
+	}
+}
+/**
+* Resolves conflicts between reset styles and inline styles by expanding
+* shorthand properties (margin, padding) to longhand before merging.
+* This prevents shorthand properties from overriding specific longhand properties.
+*
+* @param resetStyles - Base reset styles that may contain shorthand properties
+* @param inlineStyles - Inline styles that should override reset styles
+* @returns Merged styles with inline styles taking precedence
+*/
+function resolveConflictingStyles(resetStyles, inlineStyles) {
+	const expandedResetStyles = expandShorthandProperties(resetStyles);
+	const expandedInlineStyles = expandShorthandProperties(inlineStyles);
+	return {
+		...expandedResetStyles,
+		...expandedInlineStyles
+	};
+}
 
 //#endregion
 //#region src/extensions/body.tsx
@@ -157,12 +421,12 @@ const Body = EmailNode.create({
 			0
 		];
 	},
-	renderToReactEmail({ children, node, styles }) {
+	renderToReactEmail({ children, node, style }) {
 		const inlineStyles = inlineCssToJs(node.attrs?.style);
 		return /* @__PURE__ */ jsx("div", {
 			className: node.attrs?.class || void 0,
 			style: {
-				...styles.reset,
+				...style,
 				...inlineStyles
 			},
 			children
@@ -170,6 +434,92 @@ const Body = EmailNode.create({
 	}
 });
 
+//#endregion
+//#region src/extensions/bold.ts
+/**
+* Matches bold text via `**` as input.
+*/
+const starInputRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
+/**
+* Matches bold text via `**` while pasting.
+*/
+const starPasteRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
+/**
+* Matches bold text via `__` as input.
+*/
+const underscoreInputRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
+/**
+* Matches bold text via `__` while pasting.
+*/
+const underscorePasteRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
+/**
+* This extension allows you to mark text as bold.
+* @see https://tiptap.dev/api/marks/bold
+*/
+const Bold = Mark.create({
+	name: "bold",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [
+			{ tag: "strong" },
+			{
+				tag: "b",
+				getAttrs: (node) => node.style.fontWeight !== "normal" && null
+			},
+			{
+				style: "font-weight=400",
+				clearMark: (mark) => mark.type.name === this.name
+			}
+		];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"strong",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+			0
+		];
+	},
+	addCommands() {
+		return {
+			setBold: () => ({ commands }) => {
+				return commands.setMark(this.name);
+			},
+			toggleBold: () => ({ commands }) => {
+				return commands.toggleMark(this.name);
+			},
+			unsetBold: () => ({ commands }) => {
+				return commands.unsetMark(this.name);
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-b": () => this.editor.commands.toggleBold(),
+			"Mod-B": () => this.editor.commands.toggleBold()
+		};
+	},
+	addInputRules() {
+		return [markInputRule({
+			find: starInputRegex,
+			type: this.type
+		}), markInputRule({
+			find: underscoreInputRegex,
+			type: this.type
+		})];
+	},
+	addPasteRules() {
+		return [markPasteRule({
+			find: starPasteRegex,
+			type: this.type
+		}), markPasteRule({
+			find: underscorePasteRegex,
+			type: this.type
+		})];
+	}
+});
+
 //#endregion
 //#region src/extensions/button.tsx
 const Button = EmailNode.create({
@@ -232,7 +582,7 @@ const Button = EmailNode.create({
 			}
 		};
 	},
-	renderToReactEmail({ children, node, styles }) {
+	renderToReactEmail({ children, node, style }) {
 		const inlineStyles = inlineCssToJs(node.attrs?.style);
 		return /* @__PURE__ */ jsx(Row, { children: /* @__PURE__ */ jsx(Column, {
 			align: node.attrs?.align || node.attrs?.alignment,
@@ -240,8 +590,7 @@ const Button = EmailNode.create({
 				className: node.attrs?.class || void 0,
 				href: node.attrs?.href,
 				style: {
-					...styles.reset,
-					...styles.button,
+					...style,
 					...inlineStyles
 				},
 				children
@@ -250,6 +599,48 @@ const Button = EmailNode.create({
 	}
 });
 
+//#endregion
+//#region src/extensions/class-attribute.tsx
+const ClassAttribute = Extension.create({
+	name: "classAttribute",
+	addOptions() {
+		return {
+			types: [],
+			class: []
+		};
+	},
+	addGlobalAttributes() {
+		return [{
+			types: this.options.types,
+			attributes: { class: {
+				default: "",
+				parseHTML: (element) => element.className || "",
+				renderHTML: (attributes) => {
+					return attributes.class ? { class: attributes.class } : {};
+				}
+			} }
+		}];
+	},
+	addCommands() {
+		return {
+			unsetClass: () => ({ commands }) => {
+				return this.options.types.every((type) => commands.resetAttributes(type, "class"));
+			},
+			setClass: (classList) => ({ commands }) => {
+				return this.options.types.every((type) => commands.updateAttributes(type, { class: classList }));
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return { Enter: ({ editor }) => {
+			requestAnimationFrame(() => {
+				editor.commands.resetAttributes("paragraph", "class");
+			});
+			return false;
+		} };
+	}
+});
+
 //#endregion
 //#region src/utils/prism-utils.ts
 const publicURL = "/styles/prism";
@@ -428,6 +819,25 @@ const CodeBlockPrism = EmailNode.from(CodeBlock$1.extend({
 			]
 		];
 	},
+	addKeyboardShortcuts() {
+		return {
+			...this.parent?.(),
+			"Mod-a": ({ editor }) => {
+				const { state } = editor;
+				const { selection } = state;
+				const { $from } = selection;
+				for (let depth = $from.depth; depth >= 1; depth--) if ($from.node(depth).type.name === this.name) {
+					const blockStart = $from.start(depth);
+					const blockEnd = $from.end(depth);
+					if (selection.from === blockStart && selection.to === blockEnd) return false;
+					const tr = state.tr.setSelection(TextSelection.create(state.doc, blockStart, blockEnd));
+					editor.view.dispatch(tr);
+					return true;
+				}
+				return false;
+			}
+		};
+	},
 	addProseMirrorPlugins() {
 		return [...this.parent?.() || [], PrismPlugin({
 			name: this.name,
@@ -435,7 +845,7 @@ const CodeBlockPrism = EmailNode.from(CodeBlock$1.extend({
 			defaultTheme: this.options.defaultTheme
 		})];
 	}
-}), ({ node, styles }) => {
+}), ({ node, style }) => {
 	const language = node.attrs?.language ? `${node.attrs.language}` : "javascript";
 	const userTheme = ReactEmailComponents[node.attrs?.theme];
 	const theme = userTheme ? {
@@ -459,7 +869,7 @@ const CodeBlockPrism = EmailNode.from(CodeBlock$1.extend({
 		theme,
 		style: {
 			width: "auto",
-			...styles.codeBlock
+			...style
 		}
 	});
 });
@@ -496,12 +906,12 @@ const Div = EmailNode.create({
 	addAttributes() {
 		return { ...createStandardAttributes([...COMMON_HTML_ATTRIBUTES, ...LAYOUT_ATTRIBUTES]) };
 	},
-	renderToReactEmail({ children, node, styles }) {
+	renderToReactEmail({ children, node, style }) {
 		const inlineStyles = inlineCssToJs(node.attrs?.style);
 		return /* @__PURE__ */ jsx("div", {
 			className: node.attrs?.class || void 0,
 			style: {
-				...styles.reset,
+				...style,
 				...inlineStyles
 			},
 			children
@@ -509,6 +919,206 @@ const Div = EmailNode.create({
 	}
 });
 
+//#endregion
+//#region src/extensions/max-nesting.ts
+const MaxNesting = Extension.create({
+	name: "maxNesting",
+	addOptions() {
+		return {
+			maxDepth: 3,
+			nodeTypes: void 0
+		};
+	},
+	addProseMirrorPlugins() {
+		const { maxDepth, nodeTypes } = this.options;
+		if (typeof maxDepth !== "number" || maxDepth < 1) throw new Error("maxDepth must be a positive number");
+		return [new Plugin({
+			key: new PluginKey("maxNesting"),
+			appendTransaction(transactions, _oldState, newState) {
+				if (!transactions.some((tr$1) => tr$1.docChanged)) return null;
+				const rangesToLift = [];
+				newState.doc.descendants((node, pos) => {
+					let depth = 0;
+					let currentPos = pos;
+					let currentNode = node;
+					while (currentNode && depth <= maxDepth) {
+						if (!nodeTypes || nodeTypes.includes(currentNode.type.name)) depth++;
+						const $pos = newState.doc.resolve(currentPos);
+						if ($pos.depth === 0) break;
+						currentPos = $pos.before($pos.depth);
+						currentNode = newState.doc.nodeAt(currentPos);
+					}
+					if (depth > maxDepth) {
+						const $pos = newState.doc.resolve(pos);
+						if ($pos.depth > 0) {
+							const range = $pos.blockRange();
+							if (range && "canReplace" in newState.schema.nodes.doc && typeof newState.schema.nodes.doc.canReplace === "function" && newState.schema.nodes.doc.canReplace(range.start - 1, range.end + 1, newState.doc.slice(range.start, range.end).content)) rangesToLift.push({
+								range,
+								target: range.start - 1
+							});
+						}
+					}
+				});
+				if (rangesToLift.length === 0) return null;
+				const tr = newState.tr;
+				for (let i = rangesToLift.length - 1; i >= 0; i--) {
+					const { range, target } = rangesToLift[i];
+					tr.lift(range, target);
+				}
+				return tr;
+			},
+			filterTransaction(tr) {
+				if (!tr.docChanged) return true;
+				let wouldCreateDeepNesting = false;
+				const newDoc = tr.doc;
+				newDoc.descendants((node, pos) => {
+					if (wouldCreateDeepNesting) return false;
+					let depth = 0;
+					let currentPos = pos;
+					let currentNode = node;
+					while (currentNode && depth <= maxDepth) {
+						if (!nodeTypes || nodeTypes.includes(currentNode.type.name)) depth++;
+						const $pos = newDoc.resolve(currentPos);
+						if ($pos.depth === 0) break;
+						currentPos = $pos.before($pos.depth);
+						currentNode = newDoc.nodeAt(currentPos);
+					}
+					if (depth > maxDepth) {
+						wouldCreateDeepNesting = true;
+						return false;
+					}
+				});
+				return !wouldCreateDeepNesting;
+			}
+		})];
+	}
+});
+
+//#endregion
+//#region src/extensions/placeholder.ts
+const Placeholder = TipTapPlaceholder.configure({
+	placeholder: ({ node }) => {
+		if (node.type.name === "heading") return `Heading ${node.attrs.level}`;
+		return "Press '/' for commands";
+	},
+	includeChildren: true
+});
+
+//#endregion
+//#region src/extensions/preserved-style.ts
+const PreservedStyle = Mark.create({
+	name: "preservedStyle",
+	addAttributes() {
+		return { style: {
+			default: null,
+			parseHTML: (element) => element.getAttribute("style"),
+			renderHTML: (attributes) => {
+				if (!attributes.style) return {};
+				return { style: attributes.style };
+			}
+		} };
+	},
+	parseHTML() {
+		return [{
+			tag: "span[style]",
+			getAttrs: (element) => {
+				if (typeof element === "string") return false;
+				const style = element.getAttribute("style");
+				if (style && hasPreservableStyles(style)) return { style };
+				return false;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"span",
+			mergeAttributes(HTMLAttributes),
+			0
+		];
+	}
+});
+const LINK_INDICATOR_STYLES = [
+	"color",
+	"text-decoration",
+	"text-decoration-line",
+	"text-decoration-color",
+	"text-decoration-style"
+];
+function parseStyleString(styleString) {
+	const temp = document.createElement("div");
+	temp.style.cssText = styleString;
+	return temp.style;
+}
+function hasBackground(style) {
+	const bgColor = style.backgroundColor;
+	const bg = style.background;
+	if (bgColor && bgColor !== "transparent" && bgColor !== "rgba(0, 0, 0, 0)") return true;
+	if (bg && bg !== "transparent" && bg !== "none" && bg !== "rgba(0, 0, 0, 0)") return true;
+	return false;
+}
+function hasPreservableStyles(styleString) {
+	return processStylesForUnlink(styleString) !== null;
+}
+/**
+* Processes styles when unlinking:
+* - Has background (button-like): preserve all styles
+* - No background: strip link-indicator styles (color, text-decoration), keep the rest
+*/
+function processStylesForUnlink(styleString) {
+	if (!styleString) return null;
+	const style = parseStyleString(styleString);
+	if (hasBackground(style)) return styleString;
+	const filtered = [];
+	for (let i = 0; i < style.length; i++) {
+		const prop = style[i];
+		if (LINK_INDICATOR_STYLES.includes(prop)) continue;
+		const value = style.getPropertyValue(prop);
+		if (value) filtered.push(`${prop}: ${value}`);
+	}
+	return filtered.length > 0 ? filtered.join("; ") : null;
+}
+
+//#endregion
+//#region src/extensions/preview-text.ts
+const PreviewText = Node.create({
+	name: "previewText",
+	group: "block",
+	selectable: false,
+	draggable: false,
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addStorage() {
+		return { previewText: null };
+	},
+	renderHTML() {
+		return ["div", { style: "display: none" }];
+	},
+	parseHTML() {
+		return [{
+			tag: "div[data-skip-in-text=\"true\"]",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const element = node;
+				let directText = "";
+				for (const child of element.childNodes) if (child.nodeType === 3) directText += child.textContent || "";
+				const cleanText = directText.trim();
+				if (cleanText) this.storage.previewText = cleanText;
+				return false;
+			}
+		}, {
+			tag: "span.preheader",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const preheaderText = node.textContent?.trim();
+				if (preheaderText) this.storage.previewText = preheaderText;
+				return false;
+			}
+		}];
+	}
+});
+
 //#endregion
 //#region src/utils/get-text-alignment.ts
 function getTextAlignment(alignment) {
@@ -552,14 +1162,14 @@ const Section = EmailNode.create({
 			});
 		} };
 	},
-	renderToReactEmail({ children, node, styles }) {
+	renderToReactEmail({ children, node, style }) {
 		const inlineStyles = inlineCssToJs(node.attrs?.style);
 		const textAlign = node.attrs?.align || node.attrs?.alignment;
 		return /* @__PURE__ */ jsx(Section$1, {
 			className: node.attrs?.class || void 0,
 			align: textAlign,
 			style: {
-				...styles.section,
+				...style,
 				...inlineStyles,
 				...getTextAlignment(textAlign)
 			},
@@ -569,5 +1179,1489 @@ const Section = EmailNode.create({
 });
 
 //#endregion
-export { Body, Button, CodeBlockPrism, Div, EmailNode, Section };
+//#region src/extensions/style-attribute.tsx
+const StyleAttribute = Extension.create({
+	name: "styleAttribute",
+	priority: 101,
+	addOptions() {
+		return {
+			types: [],
+			style: []
+		};
+	},
+	addGlobalAttributes() {
+		return [{
+			types: this.options.types,
+			attributes: { style: {
+				default: "",
+				parseHTML: (element) => element.getAttribute("style") || "",
+				renderHTML: (attributes) => {
+					return { style: attributes.style ?? "" };
+				}
+			} }
+		}];
+	},
+	addCommands() {
+		return {
+			unsetStyle: () => ({ commands }) => {
+				return this.options.types.every((type) => commands.resetAttributes(type, "style"));
+			},
+			setStyle: (style) => ({ commands }) => {
+				return this.options.types.every((type) => commands.updateAttributes(type, { style }));
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return { Enter: ({ editor }) => {
+			const { state } = editor.view;
+			const { selection } = state;
+			const { $from } = selection;
+			const textBefore = $from.nodeBefore?.text || "";
+			if (textBefore.includes("{{") || textBefore.includes("{{{")) return false;
+			requestAnimationFrame(() => {
+				editor.commands.resetAttributes("paragraph", "style");
+			});
+			return false;
+		} };
+	}
+});
+
+//#endregion
+//#region src/extensions/sup.ts
+/**
+* This extension allows you to mark text as superscript.
+* @see https://tiptap.dev/api/marks/superscript
+*/
+const Sup = Mark.create({
+	name: "sup",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [{ tag: "sup" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"sup",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+			0
+		];
+	},
+	addCommands() {
+		return {
+			setSup: () => ({ commands }) => {
+				return commands.setMark(this.name);
+			},
+			toggleSup: () => ({ commands }) => {
+				return commands.toggleMark(this.name);
+			},
+			unsetSup: () => ({ commands }) => {
+				return commands.unsetMark(this.name);
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/extensions/table.tsx
+const Table = EmailNode.create({
+	name: "table",
+	group: "block",
+	content: "tableRow+",
+	isolating: true,
+	tableRole: "table",
+	addAttributes() {
+		return { ...createStandardAttributes([
+			...TABLE_ATTRIBUTES,
+			...LAYOUT_ATTRIBUTES,
+			...COMMON_HTML_ATTRIBUTES
+		]) };
+	},
+	parseHTML() {
+		return [{
+			tag: "table",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const element = node;
+				const attrs = {};
+				Array.from(element.attributes).forEach((attr) => {
+					attrs[attr.name] = attr.value;
+				});
+				return attrs;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"table",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+			[
+				"tbody",
+				{},
+				0
+			]
+		];
+	},
+	renderToReactEmail({ children, node, style }) {
+		const inlineStyles = inlineCssToJs(node.attrs?.style);
+		const alignment = node.attrs?.align || node.attrs?.alignment;
+		const width = node.attrs?.width;
+		const centeringStyles = alignment === "center" ? {
+			marginLeft: "auto",
+			marginRight: "auto"
+		} : {};
+		return /* @__PURE__ */ jsx(Section$1, {
+			className: node.attrs?.class || void 0,
+			align: alignment,
+			style: resolveConflictingStyles(style, {
+				...inlineStyles,
+				...centeringStyles
+			}),
+			...width !== void 0 ? { width } : {},
+			children
+		});
+	}
+});
+const TableRow = EmailNode.create({
+	name: "tableRow",
+	group: "tableRow",
+	content: "(tableCell | tableHeader)+",
+	addAttributes() {
+		return { ...createStandardAttributes([
+			...TABLE_CELL_ATTRIBUTES,
+			...LAYOUT_ATTRIBUTES,
+			...COMMON_HTML_ATTRIBUTES
+		]) };
+	},
+	parseHTML() {
+		return [{
+			tag: "tr",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const element = node;
+				const attrs = {};
+				Array.from(element.attributes).forEach((attr) => {
+					attrs[attr.name] = attr.value;
+				});
+				return attrs;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"tr",
+			HTMLAttributes,
+			0
+		];
+	},
+	renderToReactEmail({ children, node, style }) {
+		const inlineStyles = inlineCssToJs(node.attrs?.style);
+		return /* @__PURE__ */ jsx("tr", {
+			className: node.attrs?.class || void 0,
+			style: {
+				...style,
+				...inlineStyles
+			},
+			children
+		});
+	}
+});
+const TableCell = EmailNode.create({
+	name: "tableCell",
+	group: "tableCell",
+	content: "block+",
+	isolating: true,
+	addAttributes() {
+		return { ...createStandardAttributes([
+			...TABLE_CELL_ATTRIBUTES,
+			...LAYOUT_ATTRIBUTES,
+			...COMMON_HTML_ATTRIBUTES
+		]) };
+	},
+	parseHTML() {
+		return [{
+			tag: "td",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const element = node;
+				const attrs = {};
+				Array.from(element.attributes).forEach((attr) => {
+					attrs[attr.name] = attr.value;
+				});
+				return attrs;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"td",
+			HTMLAttributes,
+			0
+		];
+	},
+	renderToReactEmail({ children, node, style }) {
+		const inlineStyles = inlineCssToJs(node.attrs?.style);
+		return /* @__PURE__ */ jsx(Column, {
+			className: node.attrs?.class || void 0,
+			align: node.attrs?.align || node.attrs?.alignment,
+			style: {
+				...style,
+				...inlineStyles
+			},
+			children
+		});
+	}
+});
+const TableHeader = Node.create({
+	name: "tableHeader",
+	group: "tableCell",
+	content: "block+",
+	isolating: true,
+	addAttributes() {
+		return { ...createStandardAttributes([
+			...TABLE_HEADER_ATTRIBUTES,
+			...TABLE_CELL_ATTRIBUTES,
+			...LAYOUT_ATTRIBUTES,
+			...COMMON_HTML_ATTRIBUTES
+		]) };
+	},
+	parseHTML() {
+		return [{
+			tag: "th",
+			getAttrs: (node) => {
+				if (typeof node === "string") return false;
+				const element = node;
+				const attrs = {};
+				Array.from(element.attributes).forEach((attr) => {
+					attrs[attr.name] = attr.value;
+				});
+				return attrs;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"th",
+			HTMLAttributes,
+			0
+		];
+	}
+});
+
+//#endregion
+//#region src/extensions/uppercase.ts
+const Uppercase = Mark.create({
+	name: "uppercase",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [{
+			tag: "span",
+			getAttrs: (node) => {
+				if (node.style.textTransform === "uppercase") return {};
+				return false;
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"span",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { style: "text-transform: uppercase" }),
+			0
+		];
+	},
+	addCommands() {
+		return {
+			setUppercase: () => ({ commands }) => {
+				return commands.setMark(this.name);
+			},
+			toggleUppercase: () => ({ commands }) => {
+				return commands.toggleMark(this.name);
+			},
+			unsetUppercase: () => ({ commands }) => {
+				return commands.unsetMark(this.name);
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/extensions/columns.tsx
+const COLUMN_PARENT_TYPES = [
+	"twoColumns",
+	"threeColumns",
+	"fourColumns"
+];
+const COLUMN_PARENT_SET = new Set(COLUMN_PARENT_TYPES);
+const MAX_COLUMNS_DEPTH = 3;
+function getColumnsDepth(doc, from) {
+	const $from = doc.resolve(from);
+	let depth = 0;
+	for (let d = $from.depth; d > 0; d--) if (COLUMN_PARENT_SET.has($from.node(d).type.name)) depth++;
+	return depth;
+}
+const VARIANTS = [
+	{
+		name: "twoColumns",
+		columnCount: 2,
+		content: "columnsColumn columnsColumn",
+		dataType: "two-columns"
+	},
+	{
+		name: "threeColumns",
+		columnCount: 3,
+		content: "columnsColumn columnsColumn columnsColumn",
+		dataType: "three-columns"
+	},
+	{
+		name: "fourColumns",
+		columnCount: 4,
+		content: "columnsColumn{4}",
+		dataType: "four-columns"
+	}
+];
+const NODE_TYPE_MAP = {
+	2: "twoColumns",
+	3: "threeColumns",
+	4: "fourColumns"
+};
+function createColumnsNode(config, includeCommands) {
+	return EmailNode.create({
+		name: config.name,
+		group: "block",
+		content: config.content,
+		isolating: true,
+		defining: true,
+		addAttributes() {
+			return createStandardAttributes([...LAYOUT_ATTRIBUTES, ...COMMON_HTML_ATTRIBUTES]);
+		},
+		parseHTML() {
+			return [{ tag: `div[data-type="${config.dataType}"]` }];
+		},
+		renderHTML({ HTMLAttributes }) {
+			return [
+				"div",
+				mergeAttributes({
+					"data-type": config.dataType,
+					class: "node-columns"
+				}, HTMLAttributes),
+				0
+			];
+		},
+		...includeCommands && { addCommands() {
+			return { insertColumns: (count) => ({ commands, state }) => {
+				if (getColumnsDepth(state.doc, state.selection.from) >= MAX_COLUMNS_DEPTH) return false;
+				const nodeType = NODE_TYPE_MAP[count];
+				const children = Array.from({ length: count }, () => ({
+					type: "columnsColumn",
+					content: [{
+						type: "paragraph",
+						content: []
+					}]
+				}));
+				return commands.insertContent({
+					type: nodeType,
+					content: children
+				});
+			} };
+		} },
+		renderToReactEmail({ children, node, style }) {
+			const inlineStyles = inlineCssToJs(node.attrs?.style);
+			return /* @__PURE__ */ jsx(Row, {
+				className: node.attrs?.class || void 0,
+				style: {
+					...style,
+					...inlineStyles
+				},
+				children
+			});
+		}
+	});
+}
+const TwoColumns = createColumnsNode(VARIANTS[0], true);
+const ThreeColumns = createColumnsNode(VARIANTS[1], false);
+const FourColumns = createColumnsNode(VARIANTS[2], false);
+const ColumnsColumn = EmailNode.create({
+	name: "columnsColumn",
+	group: "columnsColumn",
+	content: "block+",
+	isolating: true,
+	addAttributes() {
+		return { ...createStandardAttributes([...LAYOUT_ATTRIBUTES, ...COMMON_HTML_ATTRIBUTES]) };
+	},
+	parseHTML() {
+		return [{ tag: "div[data-type=\"column\"]" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"div",
+			mergeAttributes({
+				"data-type": "column",
+				class: "node-column"
+			}, HTMLAttributes),
+			0
+		];
+	},
+	addKeyboardShortcuts() {
+		return {
+			Backspace: ({ editor }) => {
+				const { state } = editor;
+				const { selection } = state;
+				const { empty, $from } = selection;
+				if (!empty) return false;
+				for (let depth = $from.depth; depth >= 1; depth--) {
+					if ($from.pos !== $from.start(depth)) break;
+					const indexInParent = $from.index(depth - 1);
+					if (indexInParent === 0) continue;
+					const prevNode = $from.node(depth - 1).child(indexInParent - 1);
+					if (COLUMN_PARENT_SET.has(prevNode.type.name)) {
+						const deleteFrom = $from.before(depth) - prevNode.nodeSize;
+						const deleteTo = $from.before(depth);
+						editor.view.dispatch(state.tr.delete(deleteFrom, deleteTo));
+						return true;
+					}
+					break;
+				}
+				return false;
+			},
+			"Mod-a": ({ editor }) => {
+				const { state } = editor;
+				const { $from } = state.selection;
+				for (let d = $from.depth; d > 0; d--) {
+					if ($from.node(d).type.name !== "columnsColumn") continue;
+					const columnStart = $from.start(d);
+					const columnEnd = $from.end(d);
+					const { from, to } = state.selection;
+					if (from === columnStart && to === columnEnd) return false;
+					editor.view.dispatch(state.tr.setSelection(TextSelection.create(state.doc, columnStart, columnEnd)));
+					return true;
+				}
+				return false;
+			}
+		};
+	},
+	renderToReactEmail({ children, node, style }) {
+		const inlineStyles = inlineCssToJs(node.attrs?.style);
+		const width = node.attrs?.width;
+		return /* @__PURE__ */ jsx(Column, {
+			className: node.attrs?.class || void 0,
+			style: {
+				...style,
+				...inlineStyles,
+				...width ? { width } : {}
+			},
+			children
+		});
+	}
+});
+
+//#endregion
+//#region src/extensions/index.ts
+const coreExtensions = [
+	StarterKit.configure({
+		undoRedo: false,
+		heading: false,
+		link: false,
+		underline: false,
+		trailingNode: false,
+		bold: false,
+		gapcursor: false,
+		listItem: {},
+		bulletList: { HTMLAttributes: { class: "node-bulletList" } },
+		paragraph: { HTMLAttributes: { class: "node-paragraph" } },
+		orderedList: { HTMLAttributes: { class: "node-orderedList" } },
+		blockquote: { HTMLAttributes: { class: "node-blockquote" } },
+		codeBlock: false,
+		code: { HTMLAttributes: {
+			class: "node-inlineCode",
+			spellcheck: "false"
+		} },
+		horizontalRule: false,
+		dropcursor: {
+			color: "#61a8f8",
+			class: "rounded-full animate-[fade-in_300ms_ease-in-out] !z-40",
+			width: 4
+		}
+	}),
+	CodeBlockPrism.configure({
+		defaultLanguage: "javascript",
+		HTMLAttributes: { class: "prism node-codeBlock" }
+	}),
+	Placeholder,
+	PreviewText,
+	Bold,
+	Sup,
+	Uppercase,
+	PreservedStyle,
+	Table,
+	TableRow,
+	TableCell,
+	TableHeader,
+	Body,
+	Div,
+	Button,
+	Section,
+	AlignmentAttribute.configure({ types: [
+		"heading",
+		"paragraph",
+		"image",
+		"blockquote",
+		"codeBlock",
+		"bulletList",
+		"orderedList",
+		"listItem",
+		"button",
+		"youtube",
+		"twitter",
+		"table",
+		"tableRow",
+		"tableCell",
+		"tableHeader",
+		"columnsColumn"
+	] }),
+	StyleAttribute.configure({ types: [
+		"heading",
+		"paragraph",
+		"image",
+		"blockquote",
+		"codeBlock",
+		"bulletList",
+		"orderedList",
+		"listItem",
+		"button",
+		"youtube",
+		"twitter",
+		"horizontalRule",
+		"footer",
+		"section",
+		"div",
+		"body",
+		"table",
+		"tableRow",
+		"tableCell",
+		"tableHeader",
+		"columnsColumn",
+		"link"
+	] }),
+	ClassAttribute.configure({ types: [
+		"heading",
+		"paragraph",
+		"image",
+		"blockquote",
+		"bulletList",
+		"orderedList",
+		"listItem",
+		"button",
+		"youtube",
+		"twitter",
+		"horizontalRule",
+		"footer",
+		"section",
+		"div",
+		"body",
+		"table",
+		"tableRow",
+		"tableCell",
+		"tableHeader",
+		"columnsColumn",
+		"link"
+	] }),
+	MaxNesting.configure({
+		maxDepth: 50,
+		nodeTypes: [
+			"section",
+			"bulletList",
+			"orderedList"
+		]
+	})
+];
+
+//#endregion
+//#region src/utils/set-text-alignment.ts
+function setTextAlignment(editor, alignment) {
+	const { from, to } = editor.state.selection;
+	const tr = editor.state.tr;
+	editor.state.doc.nodesBetween(from, to, (node, pos) => {
+		if (node.isTextblock) {
+			const prop = "align" in node.attrs ? "align" : "alignment";
+			tr.setNodeMarkup(pos, null, {
+				...node.attrs,
+				[prop]: alignment
+			});
+		}
+	});
+	editor.view.dispatch(tr);
+}
+
+//#endregion
+//#region src/ui/bubble-menu/context.tsx
+const BubbleMenuContext = React.createContext(null);
+function useBubbleMenuContext() {
+	const context = React.useContext(BubbleMenuContext);
+	if (!context) throw new Error("BubbleMenu compound components must be used within <BubbleMenu.Root>");
+	return context;
+}
+
+//#endregion
+//#region src/ui/bubble-menu/item.tsx
+function BubbleMenuItem({ name, isActive, onCommand, className, children,...rest }) {
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		"aria-label": name,
+		"aria-pressed": isActive,
+		className,
+		"data-re-bubble-menu-item": "",
+		"data-item": name,
+		...isActive ? { "data-active": "" } : {},
+		onMouseDown: (e) => e.preventDefault(),
+		onClick: onCommand,
+		...rest,
+		children
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/align-center.tsx
+function BubbleMenuAlignCenter({ className, children }) {
+	const { editor } = useBubbleMenuContext();
+	return /* @__PURE__ */ jsx(BubbleMenuItem, {
+		name: "align-center",
+		isActive: useEditorState({
+			editor,
+			selector: ({ editor: editor$1 }) => editor$1?.isActive({ alignment: "center" }) ?? false
+		}),
+		onCommand: () => setTextAlignment(editor, "center"),
+		className,
+		children: children ?? /* @__PURE__ */ jsx(AlignCenterIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/align-left.tsx
+function BubbleMenuAlignLeft({ className, children }) {
+	const { editor } = useBubbleMenuContext();
+	return /* @__PURE__ */ jsx(BubbleMenuItem, {
+		name: "align-left",
+		isActive: useEditorState({
+			editor,
+			selector: ({ editor: editor$1 }) => editor$1?.isActive({ alignment: "left" }) ?? false
+		}),
+		onCommand: () => setTextAlignment(editor, "left"),
+		className,
+		children: children ?? /* @__PURE__ */ jsx(AlignLeftIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/align-right.tsx
+function BubbleMenuAlignRight({ className, children }) {
+	const { editor } = useBubbleMenuContext();
+	return /* @__PURE__ */ jsx(BubbleMenuItem, {
+		name: "align-right",
+		isActive: useEditorState({
+			editor,
+			selector: ({ editor: editor$1 }) => editor$1?.isActive({ alignment: "right" }) ?? false
+		}),
+		onCommand: () => setTextAlignment(editor, "right"),
+		className,
+		children: children ?? /* @__PURE__ */ jsx(AlignRightIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/create-mark-bubble-item.tsx
+function createMarkBubbleItem(config) {
+	function MarkBubbleItem({ className, children }) {
+		const { editor } = useBubbleMenuContext();
+		const isActive = useEditorState({
+			editor,
+			selector: ({ editor: editor$1 }) => {
+				if (config.activeParams) return editor$1?.isActive(config.activeName, config.activeParams) ?? false;
+				return editor$1?.isActive(config.activeName) ?? false;
+			}
+		});
+		const handleCommand = () => {
+			const chain = editor.chain().focus();
+			const method = chain[config.command];
+			if (method) method.call(chain).run();
+		};
+		return /* @__PURE__ */ jsx(BubbleMenuItem, {
+			name: config.name,
+			isActive,
+			onCommand: handleCommand,
+			className,
+			children: children ?? config.icon
+		});
+	}
+	MarkBubbleItem.displayName = `BubbleMenu${config.name.charAt(0).toUpperCase() + config.name.slice(1)}`;
+	return MarkBubbleItem;
+}
+
+//#endregion
+//#region src/ui/bubble-menu/bold.tsx
+const BubbleMenuBold = createMarkBubbleItem({
+	name: "bold",
+	activeName: "bold",
+	command: "toggleBold",
+	icon: /* @__PURE__ */ jsx(BoldIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/code.tsx
+const BubbleMenuCode = createMarkBubbleItem({
+	name: "code",
+	activeName: "code",
+	command: "toggleCode",
+	icon: /* @__PURE__ */ jsx(CodeIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/group.tsx
+function BubbleMenuItemGroup({ className, children }) {
+	return /* @__PURE__ */ jsx("fieldset", {
+		className,
+		"data-re-bubble-menu-group": "",
+		children
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/italic.tsx
+const BubbleMenuItalic = createMarkBubbleItem({
+	name: "italic",
+	activeName: "italic",
+	command: "toggleItalic",
+	icon: /* @__PURE__ */ jsx(ItalicIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/utils.ts
+const SAFE_PROTOCOLS = new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+]);
+/**
+* Basic URL validation and auto-prefixing.
+* Rejects dangerous schemes (javascript:, data:, vbscript:, etc.).
+* Returns the valid URL string or null.
+*/
+function getUrlFromString(str) {
+	if (str === "#") return str;
+	try {
+		const url = new URL(str);
+		if (SAFE_PROTOCOLS.has(url.protocol)) return str;
+		return null;
+	} catch {}
+	try {
+		if (str.includes(".") && !str.includes(" ")) return new URL(`https://${str}`).toString();
+	} catch {}
+	return null;
+}
+function setLinkHref(editor, href) {
+	if (href.length === 0) {
+		editor.chain().unsetLink().run();
+		return;
+	}
+	const { from, to } = editor.state.selection;
+	if (from === to) {
+		editor.chain().extendMarkRange("link").setLink({ href }).setTextSelection({
+			from,
+			to
+		}).run();
+		return;
+	}
+	editor.chain().setLink({ href }).run();
+}
+function focusEditor(editor) {
+	setTimeout(() => {
+		editor.commands.focus();
+	}, 0);
+}
+
+//#endregion
+//#region src/ui/bubble-menu/link-selector.tsx
+function BubbleMenuLinkSelector({ className, showToggle = true, validateUrl, onLinkApply, onLinkRemove, children, open: controlledOpen, onOpenChange }) {
+	const { editor } = useBubbleMenuContext();
+	const [uncontrolledOpen, setUncontrolledOpen] = React.useState(false);
+	const isControlled = controlledOpen !== void 0;
+	const isOpen = isControlled ? controlledOpen : uncontrolledOpen;
+	const setIsOpen = React.useCallback((value) => {
+		if (!isControlled) setUncontrolledOpen(value);
+		onOpenChange?.(value);
+	}, [isControlled, onOpenChange]);
+	const editorState = useEditorState({
+		editor,
+		selector: ({ editor: editor$1 }) => ({
+			isLinkActive: editor$1?.isActive("link") ?? false,
+			hasLink: Boolean(editor$1?.getAttributes("link").href),
+			currentHref: editor$1?.getAttributes("link").href || ""
+		})
+	});
+	const setIsOpenRef = React.useRef(setIsOpen);
+	setIsOpenRef.current = setIsOpen;
+	React.useEffect(() => {
+		const subscription = editorEventBus.on("bubble-menu:add-link", () => {
+			setIsOpenRef.current(true);
+		});
+		return () => {
+			setIsOpenRef.current(false);
+			subscription.unsubscribe();
+		};
+	}, []);
+	if (!editorState) return null;
+	const handleOpenLink = () => {
+		setIsOpen(!isOpen);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-re-link-selector": "",
+		...isOpen ? { "data-open": "" } : {},
+		...editorState.hasLink ? { "data-has-link": "" } : {},
+		className,
+		children: [showToggle && /* @__PURE__ */ jsx("button", {
+			type: "button",
+			"aria-expanded": isOpen,
+			"aria-haspopup": "true",
+			"aria-label": "Add link",
+			"aria-pressed": editorState.isLinkActive && editorState.hasLink,
+			"data-re-link-selector-trigger": "",
+			onClick: handleOpenLink,
+			children: /* @__PURE__ */ jsx(LinkIcon, {})
+		}), isOpen && /* @__PURE__ */ jsx(LinkForm, {
+			editor,
+			currentHref: editorState.currentHref,
+			validateUrl,
+			onLinkApply,
+			onLinkRemove,
+			setIsOpen,
+			children
+		})]
+	});
+}
+function LinkForm({ editor, currentHref, validateUrl, onLinkApply, onLinkRemove, setIsOpen, children }) {
+	const inputRef = React.useRef(null);
+	const formRef = React.useRef(null);
+	const displayHref = currentHref === "#" ? "" : currentHref;
+	const [inputValue, setInputValue] = React.useState(displayHref);
+	React.useEffect(() => {
+		const timeoutId = setTimeout(() => {
+			inputRef.current?.focus();
+		}, 0);
+		return () => clearTimeout(timeoutId);
+	}, []);
+	React.useEffect(() => {
+		const handleKeyDown = (event) => {
+			if (event.key === "Escape") {
+				if (editor.getAttributes("link").href === "#") editor.chain().unsetLink().run();
+				setIsOpen(false);
+			}
+		};
+		const handleClickOutside = (event) => {
+			if (formRef.current && !formRef.current.contains(event.target)) {
+				const form = formRef.current;
+				const submitEvent = new Event("submit", {
+					bubbles: true,
+					cancelable: true
+				});
+				form.dispatchEvent(submitEvent);
+				setIsOpen(false);
+			}
+		};
+		document.addEventListener("mousedown", handleClickOutside);
+		window.addEventListener("keydown", handleKeyDown);
+		return () => {
+			window.removeEventListener("keydown", handleKeyDown);
+			document.removeEventListener("mousedown", handleClickOutside);
+		};
+	}, [editor, setIsOpen]);
+	function handleSubmit(e) {
+		e.preventDefault();
+		const value = inputValue.trim();
+		if (value === "") {
+			setLinkHref(editor, "");
+			setIsOpen(false);
+			focusEditor(editor);
+			onLinkRemove?.();
+			return;
+		}
+		const finalValue = (validateUrl ?? getUrlFromString)(value);
+		if (!finalValue) {
+			setLinkHref(editor, "");
+			setIsOpen(false);
+			focusEditor(editor);
+			onLinkRemove?.();
+			return;
+		}
+		setLinkHref(editor, finalValue);
+		setIsOpen(false);
+		focusEditor(editor);
+		onLinkApply?.(finalValue);
+	}
+	function handleUnlink(e) {
+		e.stopPropagation();
+		setLinkHref(editor, "");
+		setIsOpen(false);
+		focusEditor(editor);
+		onLinkRemove?.();
+	}
+	return /* @__PURE__ */ jsxs("form", {
+		ref: formRef,
+		"data-re-link-selector-form": "",
+		onMouseDown: (e) => e.stopPropagation(),
+		onClick: (e) => e.stopPropagation(),
+		onKeyDown: (e) => e.stopPropagation(),
+		onSubmit: handleSubmit,
+		children: [
+			/* @__PURE__ */ jsx("input", {
+				ref: inputRef,
+				"data-re-link-selector-input": "",
+				value: inputValue,
+				onFocus: (e) => e.stopPropagation(),
+				onChange: (e) => setInputValue(e.target.value),
+				placeholder: "Paste a link",
+				type: "text"
+			}),
+			children,
+			displayHref ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": "Remove link",
+				"data-re-link-selector-unlink": "",
+				onClick: handleUnlink,
+				children: /* @__PURE__ */ jsx(UnlinkIcon, {})
+			}) : /* @__PURE__ */ jsx("button", {
+				type: "submit",
+				"aria-label": "Apply link",
+				"data-re-link-selector-apply": "",
+				onMouseDown: (e) => e.stopPropagation(),
+				children: /* @__PURE__ */ jsx(Check, {})
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/node-selector.tsx
+const NodeSelectorContext = React.createContext(null);
+function useNodeSelectorContext() {
+	const context = React.useContext(NodeSelectorContext);
+	if (!context) throw new Error("NodeSelector compound components must be used within <NodeSelector.Root>");
+	return context;
+}
+function NodeSelectorRoot({ omit = [], open: controlledOpen, onOpenChange, className, children }) {
+	const { editor } = useBubbleMenuContext();
+	const [uncontrolledOpen, setUncontrolledOpen] = React.useState(false);
+	const isControlled = controlledOpen !== void 0;
+	const isOpen = isControlled ? controlledOpen : uncontrolledOpen;
+	const setIsOpen = React.useCallback((value) => {
+		if (!isControlled) setUncontrolledOpen(value);
+		onOpenChange?.(value);
+	}, [isControlled, onOpenChange]);
+	const editorState = useEditorState({
+		editor,
+		selector: ({ editor: editor$1 }) => ({
+			isParagraphActive: (editor$1?.isActive("paragraph") ?? false) && !editor$1?.isActive("bulletList") && !editor$1?.isActive("orderedList"),
+			isHeading1Active: editor$1?.isActive("heading", { level: 1 }) ?? false,
+			isHeading2Active: editor$1?.isActive("heading", { level: 2 }) ?? false,
+			isHeading3Active: editor$1?.isActive("heading", { level: 3 }) ?? false,
+			isBulletListActive: editor$1?.isActive("bulletList") ?? false,
+			isOrderedListActive: editor$1?.isActive("orderedList") ?? false,
+			isBlockquoteActive: editor$1?.isActive("blockquote") ?? false,
+			isCodeBlockActive: editor$1?.isActive("codeBlock") ?? false
+		})
+	});
+	const allItems = React.useMemo(() => [
+		{
+			name: "Text",
+			icon: TextIcon,
+			command: () => editor.chain().focus().clearNodes().toggleNode("paragraph", "paragraph").run(),
+			isActive: editorState?.isParagraphActive ?? false
+		},
+		{
+			name: "Title",
+			icon: Heading1,
+			command: () => editor.chain().focus().clearNodes().toggleHeading({ level: 1 }).run(),
+			isActive: editorState?.isHeading1Active ?? false
+		},
+		{
+			name: "Subtitle",
+			icon: Heading2,
+			command: () => editor.chain().focus().clearNodes().toggleHeading({ level: 2 }).run(),
+			isActive: editorState?.isHeading2Active ?? false
+		},
+		{
+			name: "Heading",
+			icon: Heading3,
+			command: () => editor.chain().focus().clearNodes().toggleHeading({ level: 3 }).run(),
+			isActive: editorState?.isHeading3Active ?? false
+		},
+		{
+			name: "Bullet List",
+			icon: List,
+			command: () => editor.chain().focus().clearNodes().toggleBulletList().run(),
+			isActive: editorState?.isBulletListActive ?? false
+		},
+		{
+			name: "Numbered List",
+			icon: ListOrdered,
+			command: () => editor.chain().focus().clearNodes().toggleOrderedList().run(),
+			isActive: editorState?.isOrderedListActive ?? false
+		},
+		{
+			name: "Quote",
+			icon: TextQuote,
+			command: () => editor.chain().focus().clearNodes().toggleNode("paragraph", "paragraph").toggleBlockquote().run(),
+			isActive: editorState?.isBlockquoteActive ?? false
+		},
+		{
+			name: "Code",
+			icon: Code,
+			command: () => editor.chain().focus().clearNodes().toggleCodeBlock().run(),
+			isActive: editorState?.isCodeBlockActive ?? false
+		}
+	], [editor, editorState]);
+	const items = React.useMemo(() => allItems.filter((item) => !omit.includes(item.name)), [allItems, omit]);
+	const activeItem = React.useMemo(() => items.find((item) => item.isActive) ?? { name: "Multiple" }, [items]);
+	const contextValue = React.useMemo(() => ({
+		items,
+		activeItem,
+		isOpen,
+		setIsOpen
+	}), [
+		items,
+		activeItem,
+		isOpen,
+		setIsOpen
+	]);
+	if (!editorState || items.length === 0) return null;
+	return /* @__PURE__ */ jsx(NodeSelectorContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx(Popover.Root, {
+			open: isOpen,
+			onOpenChange: setIsOpen,
+			children: /* @__PURE__ */ jsx("div", {
+				"data-re-node-selector": "",
+				...isOpen ? { "data-open": "" } : {},
+				className,
+				children
+			})
+		})
+	});
+}
+function NodeSelectorTrigger({ className, children }) {
+	const { activeItem, isOpen, setIsOpen } = useNodeSelectorContext();
+	return /* @__PURE__ */ jsx(Popover.Trigger, {
+		"data-re-node-selector-trigger": "",
+		className,
+		onClick: () => setIsOpen(!isOpen),
+		children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", { children: activeItem.name }), /* @__PURE__ */ jsx(ChevronDown, {})] })
+	});
+}
+function NodeSelectorContent({ className, align = "start", children }) {
+	const { items, setIsOpen } = useNodeSelectorContext();
+	return /* @__PURE__ */ jsx(Popover.Content, {
+		align,
+		"data-re-node-selector-content": "",
+		className,
+		children: children ? children(items, () => setIsOpen(false)) : items.map((item) => {
+			const Icon = item.icon;
+			return /* @__PURE__ */ jsxs("button", {
+				type: "button",
+				"data-re-node-selector-item": "",
+				...item.isActive ? { "data-active": "" } : {},
+				onClick: () => {
+					item.command();
+					setIsOpen(false);
+				},
+				children: [
+					/* @__PURE__ */ jsx(Icon, {}),
+					/* @__PURE__ */ jsx("span", { children: item.name }),
+					item.isActive && /* @__PURE__ */ jsx(Check, {})
+				]
+			}, item.name);
+		})
+	});
+}
+function BubbleMenuNodeSelector({ omit = [], className, triggerContent, open, onOpenChange }) {
+	return /* @__PURE__ */ jsxs(NodeSelectorRoot, {
+		omit,
+		open,
+		onOpenChange,
+		className,
+		children: [/* @__PURE__ */ jsx(NodeSelectorTrigger, { children: triggerContent }), /* @__PURE__ */ jsx(NodeSelectorContent, {})]
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/root.tsx
+function BubbleMenuRoot({ excludeNodes = [], placement = "bottom", offset = 8, onHide, className, children }) {
+	const { editor } = useCurrentEditor();
+	if (!editor) return null;
+	return /* @__PURE__ */ jsx(BubbleMenu$1, {
+		editor,
+		"data-re-bubble-menu": "",
+		shouldShow: ({ editor: editor$1, view }) => {
+			for (const node of excludeNodes) if (editor$1.isActive(node)) return false;
+			if (view.dom.classList.contains("dragging")) return false;
+			return editor$1.view.state.selection.content().size > 0;
+		},
+		options: {
+			placement,
+			offset,
+			onHide
+		},
+		className,
+		children: /* @__PURE__ */ jsx(BubbleMenuContext.Provider, {
+			value: { editor },
+			children
+		})
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/strike.tsx
+const BubbleMenuStrike = createMarkBubbleItem({
+	name: "strike",
+	activeName: "strike",
+	command: "toggleStrike",
+	icon: /* @__PURE__ */ jsx(StrikethroughIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/underline.tsx
+const BubbleMenuUnderline = createMarkBubbleItem({
+	name: "underline",
+	activeName: "underline",
+	command: "toggleUnderline",
+	icon: /* @__PURE__ */ jsx(UnderlineIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/uppercase.tsx
+const BubbleMenuUppercase = createMarkBubbleItem({
+	name: "uppercase",
+	activeName: "uppercase",
+	command: "toggleUppercase",
+	icon: /* @__PURE__ */ jsx(CaseUpperIcon, {})
+});
+
+//#endregion
+//#region src/ui/bubble-menu/default.tsx
+function BubbleMenuDefault({ excludeItems = [], excludeNodes, placement, offset, onHide, className }) {
+	const [isNodeSelectorOpen, setIsNodeSelectorOpen] = React.useState(false);
+	const [isLinkSelectorOpen, setIsLinkSelectorOpen] = React.useState(false);
+	const has = (item) => !excludeItems.includes(item);
+	const handleNodeSelectorOpenChange = React.useCallback((open) => {
+		setIsNodeSelectorOpen(open);
+		if (open) setIsLinkSelectorOpen(false);
+	}, []);
+	const handleLinkSelectorOpenChange = React.useCallback((open) => {
+		setIsLinkSelectorOpen(open);
+		if (open) setIsNodeSelectorOpen(false);
+	}, []);
+	const handleHide = React.useCallback(() => {
+		setIsNodeSelectorOpen(false);
+		setIsLinkSelectorOpen(false);
+		onHide?.();
+	}, [onHide]);
+	const hasFormattingItems = has("bold") || has("italic") || has("underline") || has("strike") || has("code") || has("uppercase");
+	const hasAlignmentItems = has("align-left") || has("align-center") || has("align-right");
+	return /* @__PURE__ */ jsxs(BubbleMenuRoot, {
+		excludeNodes,
+		placement,
+		offset,
+		onHide: handleHide,
+		className,
+		children: [
+			has("node-selector") && /* @__PURE__ */ jsx(BubbleMenuNodeSelector, {
+				open: isNodeSelectorOpen,
+				onOpenChange: handleNodeSelectorOpenChange
+			}),
+			has("link-selector") && /* @__PURE__ */ jsx(BubbleMenuLinkSelector, {
+				open: isLinkSelectorOpen,
+				onOpenChange: handleLinkSelectorOpenChange
+			}),
+			hasFormattingItems && /* @__PURE__ */ jsxs(BubbleMenuItemGroup, { children: [
+				has("bold") && /* @__PURE__ */ jsx(BubbleMenuBold, {}),
+				has("italic") && /* @__PURE__ */ jsx(BubbleMenuItalic, {}),
+				has("underline") && /* @__PURE__ */ jsx(BubbleMenuUnderline, {}),
+				has("strike") && /* @__PURE__ */ jsx(BubbleMenuStrike, {}),
+				has("code") && /* @__PURE__ */ jsx(BubbleMenuCode, {}),
+				has("uppercase") && /* @__PURE__ */ jsx(BubbleMenuUppercase, {})
+			] }),
+			hasAlignmentItems && /* @__PURE__ */ jsxs(BubbleMenuItemGroup, { children: [
+				has("align-left") && /* @__PURE__ */ jsx(BubbleMenuAlignLeft, {}),
+				has("align-center") && /* @__PURE__ */ jsx(BubbleMenuAlignCenter, {}),
+				has("align-right") && /* @__PURE__ */ jsx(BubbleMenuAlignRight, {})
+			] })
+		]
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/separator.tsx
+function BubbleMenuSeparator({ className }) {
+	return /* @__PURE__ */ jsx("hr", {
+		className,
+		"data-re-bubble-menu-separator": ""
+	});
+}
+
+//#endregion
+//#region src/ui/bubble-menu/index.ts
+const BubbleMenu = {
+	Root: BubbleMenuRoot,
+	ItemGroup: BubbleMenuItemGroup,
+	Separator: BubbleMenuSeparator,
+	Item: BubbleMenuItem,
+	Bold: BubbleMenuBold,
+	Italic: BubbleMenuItalic,
+	Underline: BubbleMenuUnderline,
+	Strike: BubbleMenuStrike,
+	Code: BubbleMenuCode,
+	Uppercase: BubbleMenuUppercase,
+	AlignLeft: BubbleMenuAlignLeft,
+	AlignCenter: BubbleMenuAlignCenter,
+	AlignRight: BubbleMenuAlignRight,
+	NodeSelector: Object.assign(BubbleMenuNodeSelector, {
+		Root: NodeSelectorRoot,
+		Trigger: NodeSelectorTrigger,
+		Content: NodeSelectorContent
+	}),
+	LinkSelector: BubbleMenuLinkSelector,
+	Default: BubbleMenuDefault
+};
+
+//#endregion
+//#region src/ui/link-bubble-menu/context.tsx
+const LinkBubbleMenuContext = React.createContext(null);
+function useLinkBubbleMenuContext() {
+	const context = React.useContext(LinkBubbleMenuContext);
+	if (!context) throw new Error("LinkBubbleMenu compound components must be used within <LinkBubbleMenu.Root>");
+	return context;
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/edit-link.tsx
+function LinkBubbleMenuEditLink({ className, children, onClick,...rest }) {
+	const { setIsEditing } = useLinkBubbleMenuContext();
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		"aria-label": "Edit link",
+		"data-re-link-bm-item": "",
+		"data-item": "edit-link",
+		className,
+		onMouseDown: (e) => e.preventDefault(),
+		onClick: (e) => {
+			onClick?.(e);
+			setIsEditing(true);
+		},
+		...rest,
+		children: children ?? /* @__PURE__ */ jsx(PencilIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/form.tsx
+function LinkBubbleMenuForm({ className, validateUrl, onLinkApply, onLinkRemove, children }) {
+	const { editor, linkHref, isEditing, setIsEditing } = useLinkBubbleMenuContext();
+	const inputRef = React.useRef(null);
+	const formRef = React.useRef(null);
+	const displayHref = linkHref === "#" ? "" : linkHref;
+	const [inputValue, setInputValue] = React.useState(displayHref);
+	React.useEffect(() => {
+		if (!isEditing) return;
+		const timeoutId = setTimeout(() => {
+			inputRef.current?.focus();
+		}, 0);
+		return () => clearTimeout(timeoutId);
+	}, [isEditing]);
+	React.useEffect(() => {
+		if (!isEditing) return;
+		const handleKeyDown = (event) => {
+			if (event.key === "Escape") setIsEditing(false);
+		};
+		const handleClickOutside = (event) => {
+			if (formRef.current && !formRef.current.contains(event.target)) {
+				const form = formRef.current;
+				const submitEvent = new Event("submit", {
+					bubbles: true,
+					cancelable: true
+				});
+				form.dispatchEvent(submitEvent);
+				setIsEditing(false);
+			}
+		};
+		document.addEventListener("mousedown", handleClickOutside);
+		window.addEventListener("keydown", handleKeyDown);
+		return () => {
+			window.removeEventListener("keydown", handleKeyDown);
+			document.removeEventListener("mousedown", handleClickOutside);
+		};
+	}, [isEditing, setIsEditing]);
+	if (!isEditing) return null;
+	function handleSubmit(e) {
+		e.preventDefault();
+		const value = inputValue.trim();
+		if (value === "") {
+			setLinkHref(editor, "");
+			setIsEditing(false);
+			focusEditor(editor);
+			onLinkRemove?.();
+			return;
+		}
+		const finalValue = (validateUrl ?? getUrlFromString)(value);
+		if (!finalValue) {
+			setLinkHref(editor, "");
+			setIsEditing(false);
+			focusEditor(editor);
+			onLinkRemove?.();
+			return;
+		}
+		setLinkHref(editor, finalValue);
+		setIsEditing(false);
+		focusEditor(editor);
+		onLinkApply?.(finalValue);
+	}
+	function handleUnlink(e) {
+		e.stopPropagation();
+		setLinkHref(editor, "");
+		setIsEditing(false);
+		focusEditor(editor);
+		onLinkRemove?.();
+	}
+	return /* @__PURE__ */ jsxs("form", {
+		ref: formRef,
+		"data-re-link-bm-form": "",
+		className,
+		onMouseDown: (e) => e.stopPropagation(),
+		onClick: (e) => e.stopPropagation(),
+		onKeyDown: (e) => e.stopPropagation(),
+		onSubmit: handleSubmit,
+		children: [
+			/* @__PURE__ */ jsx("input", {
+				ref: inputRef,
+				"data-re-link-bm-input": "",
+				value: inputValue,
+				onFocus: (e) => e.stopPropagation(),
+				onChange: (e) => setInputValue(e.target.value),
+				placeholder: "Paste a link",
+				type: "text"
+			}),
+			children,
+			displayHref ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": "Remove link",
+				"data-re-link-bm-unlink": "",
+				onClick: handleUnlink,
+				children: /* @__PURE__ */ jsx(UnlinkIcon, {})
+			}) : /* @__PURE__ */ jsx("button", {
+				type: "submit",
+				"aria-label": "Apply link",
+				"data-re-link-bm-apply": "",
+				onMouseDown: (e) => e.stopPropagation(),
+				children: /* @__PURE__ */ jsx(Check, {})
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/open-link.tsx
+function LinkBubbleMenuOpenLink({ className, children,...rest }) {
+	const { linkHref } = useLinkBubbleMenuContext();
+	return /* @__PURE__ */ jsx("a", {
+		...rest,
+		href: linkHref,
+		target: "_blank",
+		rel: "noopener noreferrer",
+		"aria-label": "Open link",
+		"data-re-link-bm-item": "",
+		"data-item": "open-link",
+		className,
+		children: children ?? /* @__PURE__ */ jsx(ExternalLinkIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/root.tsx
+function LinkBubbleMenuRoot({ onHide, placement = "bottom", offset = 8, className, children }) {
+	const { editor } = useCurrentEditor();
+	const [isEditing, setIsEditing] = React.useState(false);
+	const linkHref = useEditorState({
+		editor,
+		selector: ({ editor: e }) => e?.getAttributes("link").href ?? ""
+	});
+	if (!editor) return null;
+	return /* @__PURE__ */ jsx(BubbleMenu$1, {
+		editor,
+		"data-re-link-bm": "",
+		shouldShow: ({ editor: e }) => e.isActive("link") && e.view.state.selection.content().size === 0,
+		options: {
+			placement,
+			offset,
+			onHide: () => {
+				setIsEditing(false);
+				onHide?.();
+			}
+		},
+		className,
+		children: /* @__PURE__ */ jsx(LinkBubbleMenuContext.Provider, {
+			value: {
+				editor,
+				linkHref: linkHref ?? "",
+				isEditing,
+				setIsEditing
+			},
+			children
+		})
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/toolbar.tsx
+function LinkBubbleMenuToolbar({ className, children }) {
+	const { isEditing } = useLinkBubbleMenuContext();
+	if (isEditing) return null;
+	return /* @__PURE__ */ jsx("div", {
+		"data-re-link-bm-toolbar": "",
+		className,
+		children
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/unlink.tsx
+function LinkBubbleMenuUnlink({ className, children, onClick,...rest }) {
+	const { editor } = useLinkBubbleMenuContext();
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		"aria-label": "Remove link",
+		"data-re-link-bm-item": "",
+		"data-item": "unlink",
+		className,
+		onMouseDown: (e) => e.preventDefault(),
+		onClick: (e) => {
+			onClick?.(e);
+			editor.chain().focus().unsetLink().run();
+		},
+		...rest,
+		children: children ?? /* @__PURE__ */ jsx(UnlinkIcon, {})
+	});
+}
+
+//#endregion
+//#region src/ui/link-bubble-menu/index.ts
+const LinkBubbleMenu = {
+	Root: LinkBubbleMenuRoot,
+	Toolbar: LinkBubbleMenuToolbar,
+	Form: LinkBubbleMenuForm,
+	EditLink: LinkBubbleMenuEditLink,
+	Unlink: LinkBubbleMenuUnlink,
+	OpenLink: LinkBubbleMenuOpenLink
+};
+
+//#endregion
+export { AlignmentAttribute, Body, Bold, BubbleMenu, BubbleMenuAlignCenter, BubbleMenuAlignLeft, BubbleMenuAlignRight, BubbleMenuBold, BubbleMenuCode, BubbleMenuDefault, BubbleMenuItalic, BubbleMenuItem, BubbleMenuItemGroup, BubbleMenuLinkSelector, BubbleMenuNodeSelector, BubbleMenuRoot, BubbleMenuSeparator, BubbleMenuStrike, BubbleMenuUnderline, BubbleMenuUppercase, Button, COLUMN_PARENT_TYPES, ClassAttribute, CodeBlockPrism, ColumnsColumn, Div, EmailNode, FourColumns, LinkBubbleMenu, LinkBubbleMenuEditLink, LinkBubbleMenuForm, LinkBubbleMenuOpenLink, LinkBubbleMenuRoot, LinkBubbleMenuToolbar, LinkBubbleMenuUnlink, MAX_COLUMNS_DEPTH, MaxNesting, NodeSelectorContent, NodeSelectorRoot, NodeSelectorTrigger, Placeholder, PreservedStyle, PreviewText, Section, StyleAttribute, Sup, Table, TableCell, TableHeader, TableRow, ThreeColumns, TwoColumns, Uppercase, coreExtensions, editorEventBus, getColumnsDepth, processStylesForUnlink, setTextAlignment, useLinkBubbleMenuContext };
 //# sourceMappingURL=index.mjs.map