hazo_ui 2.2.2 → 2.2.6

package/dist/index.js

@@ -1,10 +1,10 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import * as React6 from 'react';
+import * as React14 from 'react';
 import { useState, useEffect } from 'react';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { X, ChevronDown, ChevronUp, Check, Circle, Filter, Plus, ChevronsUpDown, ArrowUpDown, Trash2, GripVertical, Calendar as Calendar$1, ChevronRight, ChevronLeft } from 'lucide-react';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
@@ -19,19 +19,50 @@ import { CSS } from '@dnd-kit/utilities';
 import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
 import * as FaIcons from 'react-icons/fa';
 import * as MdIcons from 'react-icons/md';
+import { MdFormatClear } from 'react-icons/md';
 import * as HiIcons from 'react-icons/hi';
 import * as BiIcons from 'react-icons/bi';
+import { BiBracket } from 'react-icons/bi';
 import * as AiIcons from 'react-icons/ai';
 import * as BsIcons from 'react-icons/bs';
 import * as FiIcons from 'react-icons/fi';
+import { FiMinus, FiPlus, FiChevronDown, FiType, FiList, FiCode, FiBold, FiItalic, FiUnderline, FiAlignLeft, FiAlignCenter, FiAlignRight, FiAlignJustify, FiLink, FiImage, FiPaperclip, FiTable, FiTrash2, FiColumns, FiSearch, FiEye } from 'react-icons/fi';
 import * as IoIcons from 'react-icons/io5';
 import * as RiIcons from 'react-icons/ri';
+import { RiInsertRowBottom, RiInsertColumnRight, RiDeleteRow, RiDeleteColumn } from 'react-icons/ri';
 import * as TbIcons from 'react-icons/tb';
 import * as CiIcons from 'react-icons/ci';
+import { ReactNodeViewRenderer, NodeViewWrapper, useEditor, EditorContent } from '@tiptap/react';
+import StarterKit from '@tiptap/starter-kit';
+import { Underline } from '@tiptap/extension-underline';
+import { TextStyle } from '@tiptap/extension-text-style';
+import { Color } from '@tiptap/extension-color';
+import { Highlight } from '@tiptap/extension-highlight';
+import { FontFamily } from '@tiptap/extension-font-family';
+import { TextAlign } from '@tiptap/extension-text-align';
+import { Link } from '@tiptap/extension-link';
+import { Image } from '@tiptap/extension-image';
+import { Table } from '@tiptap/extension-table';
+import { TableRow } from '@tiptap/extension-table-row';
+import { TableCell } from '@tiptap/extension-table-cell';
+import { TableHeader } from '@tiptap/extension-table-header';
+import { TaskList } from '@tiptap/extension-task-list';
+import { TaskItem } from '@tiptap/extension-task-item';
+import { Subscript } from '@tiptap/extension-subscript';
+import { Superscript } from '@tiptap/extension-superscript';
+import { Placeholder } from '@tiptap/extension-placeholder';
+import { HexColorPicker } from 'react-colorful';
+import { LuUndo2, LuRedo2, LuHeading1, LuHeading2, LuHeading3, LuListOrdered, LuListTodo, LuQuote, LuStrikethrough, LuSubscript, LuSuperscript, LuHighlighter, LuTableProperties, LuColumns2 } from 'react-icons/lu';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import { RemoveMarkStep, Transform, liftTarget, joinPoint, canSplit, ReplaceStep, ReplaceAroundStep, canJoin } from '@tiptap/pm/transform';
+import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinUp as joinUp$1, joinDown as joinDown$1, joinBackward as joinBackward$1, joinForward as joinForward$1, joinTextblockBackward as joinTextblockBackward$1, joinTextblockForward as joinTextblockForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from '@tiptap/pm/commands';
+import { Plugin, PluginKey, Selection, TextSelection, AllSelection, NodeSelection } from '@tiptap/pm/state';
+import { Fragment, Slice, Node, Schema, DOMParser } from '@tiptap/pm/model';
+import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from '@tiptap/pm/schema-list';
+import '@tiptap/pm/view';
+import '@tiptap/pm/keymap';
 
-var ExampleComponent = ({ children, className = "" }) => {
-  return /* @__PURE__ */ jsx("div", { className: `cls_example_component ${className}`, children });
-};
 function cn(...inputs) {
   return twMerge(clsx(inputs));
 }
@@ -60,7 +91,7 @@ var buttonVariants = cva(
     }
   }
 );
-var Button = React6.forwardRef(
+var Button = React14.forwardRef(
   ({ className, variant, size, asChild = false, ...props }, ref) => {
     const Comp = asChild ? Slot : "button";
     return /* @__PURE__ */ jsx(
@@ -77,7 +108,7 @@ Button.displayName = "Button";
 var Dialog = DialogPrimitive.Root;
 var DialogTrigger = DialogPrimitive.Trigger;
 var DialogPortal = DialogPrimitive.Portal;
-var DialogOverlay = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var DialogOverlay = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   DialogPrimitive.Overlay,
   {
     ref,
@@ -89,7 +120,7 @@ var DialogOverlay = React6.forwardRef(({ className, ...props }, ref) => /* @__PU
   }
 ));
 DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
-var DialogContent = React6.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DialogPortal, { children: [
+var DialogContent = React14.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DialogPortal, { children: [
   /* @__PURE__ */ jsx(DialogOverlay, {}),
   /* @__PURE__ */ jsxs(
     DialogPrimitive.Content,
@@ -139,7 +170,7 @@ var DialogFooter = ({
   }
 );
 DialogFooter.displayName = "DialogFooter";
-var DialogTitle = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var DialogTitle = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   DialogPrimitive.Title,
   {
     ref,
@@ -151,7 +182,7 @@ var DialogTitle = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE
   }
 ));
 DialogTitle.displayName = DialogPrimitive.Title.displayName;
-var DialogDescription = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var DialogDescription = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   DialogPrimitive.Description,
   {
     ref,
@@ -160,7 +191,7 @@ var DialogDescription = React6.forwardRef(({ className, ...props }, ref) => /* @
   }
 ));
 DialogDescription.displayName = DialogPrimitive.Description.displayName;
-var Command = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var Command = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   "div",
   {
     ref,
@@ -172,7 +203,7 @@ var Command = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ *
   }
 ));
 Command.displayName = "Command";
-var CommandInput = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var CommandInput = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   "input",
   {
     ref,
@@ -184,7 +215,7 @@ var CommandInput = React6.forwardRef(({ className, ...props }, ref) => /* @__PUR
   }
 ));
 CommandInput.displayName = "CommandInput";
-var CommandList = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var CommandList = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   "div",
   {
     ref,
@@ -193,7 +224,7 @@ var CommandList = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE
   }
 ));
 CommandList.displayName = "CommandList";
-var CommandEmpty = React6.forwardRef((props, ref) => /* @__PURE__ */ jsx(
+var CommandEmpty = React14.forwardRef((props, ref) => /* @__PURE__ */ jsx(
   "div",
   {
     ref,
@@ -202,7 +233,7 @@ var CommandEmpty = React6.forwardRef((props, ref) => /* @__PURE__ */ jsx(
   }
 ));
 CommandEmpty.displayName = "CommandEmpty";
-var CommandGroup = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var CommandGroup = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   "div",
   {
     ref,
@@ -214,7 +245,7 @@ var CommandGroup = React6.forwardRef(({ className, ...props }, ref) => /* @__PUR
   }
 ));
 CommandGroup.displayName = "CommandGroup";
-var CommandItem = React6.forwardRef(({ className, onSelect, value, ...props }, ref) => {
+var CommandItem = React14.forwardRef(({ className, onSelect, value, ...props }, ref) => {
   const handleClick = () => {
     if (onSelect && value) {
       onSelect(value);
@@ -236,7 +267,7 @@ var CommandItem = React6.forwardRef(({ className, onSelect, value, ...props }, r
 CommandItem.displayName = "CommandItem";
 var Popover = PopoverPrimitive.Root;
 var PopoverTrigger = PopoverPrimitive.Trigger;
-var PopoverContent = React6.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsx(
+var PopoverContent = React14.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsx(
   PopoverPrimitive.Content,
   {
     ref,
@@ -250,7 +281,7 @@ var PopoverContent = React6.forwardRef(({ className, align = "center", sideOffse
   }
 ) }));
 PopoverContent.displayName = PopoverPrimitive.Content.displayName;
-var Input = React6.forwardRef(
+var Input = React14.forwardRef(
   ({ className, type, ...props }, ref) => {
     return /* @__PURE__ */ jsx(
       "input",
@@ -269,7 +300,7 @@ var Input = React6.forwardRef(
 Input.displayName = "Input";
 var Select = SelectPrimitive.Root;
 var SelectValue = SelectPrimitive.Value;
-var SelectTrigger = React6.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+var SelectTrigger = React14.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
   SelectPrimitive.Trigger,
   {
     ref,
@@ -285,7 +316,7 @@ var SelectTrigger = React6.forwardRef(({ className, children, ...props }, ref) =
   }
 ));
 SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
-var SelectScrollUpButton = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var SelectScrollUpButton = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   SelectPrimitive.ScrollUpButton,
   {
     ref,
@@ -298,7 +329,7 @@ var SelectScrollUpButton = React6.forwardRef(({ className, ...props }, ref) => /
   }
 ));
 SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
-var SelectScrollDownButton = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var SelectScrollDownButton = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   SelectPrimitive.ScrollDownButton,
   {
     ref,
@@ -311,7 +342,7 @@ var SelectScrollDownButton = React6.forwardRef(({ className, ...props }, ref) =>
   }
 ));
 SelectScrollDownButton.displayName = SelectPrimitive.ScrollDownButton.displayName;
-var SelectContent = React6.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsxs(
+var SelectContent = React14.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsxs(
   SelectPrimitive.Content,
   {
     ref,
@@ -339,7 +370,7 @@ var SelectContent = React6.forwardRef(({ className, children, position = "popper
   }
 ) }));
 SelectContent.displayName = SelectPrimitive.Content.displayName;
-var SelectLabel = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var SelectLabel = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   SelectPrimitive.Label,
   {
     ref,
@@ -348,7 +379,7 @@ var SelectLabel = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE
   }
 ));
 SelectLabel.displayName = SelectPrimitive.Label.displayName;
-var SelectItem = React6.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+var SelectItem = React14.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
   SelectPrimitive.Item,
   {
     ref,
@@ -364,7 +395,7 @@ var SelectItem = React6.forwardRef(({ className, children, ...props }, ref) => /
   }
 ));
 SelectItem.displayName = SelectPrimitive.Item.displayName;
-var SelectSeparator = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var SelectSeparator = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   SelectPrimitive.Separator,
   {
     ref,
@@ -376,7 +407,7 @@ SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
 var TooltipProvider = TooltipPrimitive.Provider;
 var Tooltip = TooltipPrimitive.Root;
 var TooltipTrigger = TooltipPrimitive.Trigger;
-var TooltipContent = React6.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(
+var TooltipContent = React14.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(
   TooltipPrimitive.Content,
   {
     ref,
@@ -847,7 +878,7 @@ function HazoUiMultiFilterDialog({
     ] })
   ] });
 }
-var Switch = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+var Switch = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
   SwitchPrimitives.Root,
   {
     className: cn(
@@ -867,7 +898,7 @@ var Switch = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */
   }
 ));
 Switch.displayName = SwitchPrimitives.Root.displayName;
-var Label2 = React6.forwardRef(
+var Label2 = React14.forwardRef(
   ({ className, ...props }, ref) => {
     return /* @__PURE__ */ jsx(
       "label",
@@ -1161,7 +1192,7 @@ function HazoUiMultiSortDialog({
     ] })
   ] });
 }
-var RadioGroup = React6.forwardRef(({ className, ...props }, ref) => {
+var RadioGroup = React14.forwardRef(({ className, ...props }, ref) => {
   return /* @__PURE__ */ jsx(
     RadioGroupPrimitive.Root,
     {
@@ -1172,7 +1203,7 @@ var RadioGroup = React6.forwardRef(({ className, ...props }, ref) => {
   );
 });
 RadioGroup.displayName = RadioGroupPrimitive.Root.displayName;
-var RadioGroupItem = React6.forwardRef(({ className, ...props }, ref) => {
+var RadioGroupItem = React14.forwardRef(({ className, ...props }, ref) => {
   return /* @__PURE__ */ jsx(
     RadioGroupPrimitive.Item,
     {
@@ -1526,7 +1557,7 @@ function filterInputValue(value, input_type, num_decimals) {
     }
   }
 }
-var HazoUiFlexInput = React6.forwardRef(
+var HazoUiFlexInput = React14.forwardRef(
   ({
     className,
     input_type = "mixed",
@@ -1543,13 +1574,13 @@ var HazoUiFlexInput = React6.forwardRef(
     onBlur,
     ...props
   }, ref) => {
-    const [internalValue, setInternalValue] = React6.useState(
+    const [internalValue, setInternalValue] = React14.useState(
       typeof controlledValue === "string" ? controlledValue : typeof controlledValue === "number" ? String(controlledValue) : ""
     );
-    const [errorMessage, setErrorMessage] = React6.useState();
+    const [errorMessage, setErrorMessage] = React14.useState();
     const isControlled = controlledValue !== void 0;
     const currentValue = isControlled ? typeof controlledValue === "string" ? controlledValue : String(controlledValue || "") : internalValue;
-    React6.useEffect(() => {
+    React14.useEffect(() => {
       if (isControlled) {
         const newValue = typeof controlledValue === "string" ? controlledValue : String(controlledValue || "");
         if (newValue !== internalValue) {
@@ -1630,6 +1661,4691 @@ var HazoUiFlexInput = React6.forwardRef(
 );
 HazoUiFlexInput.displayName = "HazoUiFlexInput";
 
-export { ExampleComponent, HazoUiFlexInput, HazoUiFlexRadio, HazoUiMultiFilterDialog, HazoUiMultiSortDialog };
+// src/components/hazo_ui_richtext_editor/constants.ts
+var FONT_FAMILIES = [
+  { value: "Arial", label: "Arial" },
+  { value: "Verdana", label: "Verdana" },
+  { value: "Times New Roman", label: "Times New Roman" },
+  { value: "Georgia", label: "Georgia" },
+  { value: "Courier New", label: "Courier New" },
+  { value: "Trebuchet MS", label: "Trebuchet MS" }
+];
+var FONT_SIZES = [8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48, 72];
+var DEFAULT_FONT_SIZE = 16;
+var MIN_FONT_SIZE = 8;
+var MAX_FONT_SIZE = 72;
+var PRESET_COLORS = [
+  "#000000",
+  "#ffffff",
+  "#f44336",
+  "#e91e63",
+  "#9c27b0",
+  "#673ab7",
+  "#3f51b5",
+  "#2196f3",
+  "#03a9f4",
+  "#00bcd4",
+  "#009688",
+  "#4caf50",
+  "#8bc34a",
+  "#cddc39",
+  "#ffeb3b",
+  "#ffc107",
+  "#ff9800",
+  "#ff5722",
+  "#795548",
+  "#9e9e9e"
+];
+var DEFAULT_TEXT_COLOR = "#000000";
+var DEFAULT_HIGHLIGHT_COLOR = "#ffff00";
+var DEFAULT_MIN_HEIGHT = "200px";
+var DEFAULT_MAX_HEIGHT = "500px";
+var DEFAULT_PLACEHOLDER = "Start typing...";
+function ColorPickerPopover({
+  color,
+  on_color_change,
+  trigger_icon,
+  trigger_label = "Pick color"
+}) {
+  const [is_open, set_is_open] = React14.useState(false);
+  const [hex_input, set_hex_input] = React14.useState(color);
+  React14.useEffect(() => {
+    set_hex_input(color);
+  }, [color]);
+  const handle_hex_input_change = (e) => {
+    const value = e.target.value;
+    set_hex_input(value);
+    if (/^#[0-9A-Fa-f]{6}$/.test(value)) {
+      on_color_change(value);
+    }
+  };
+  const handle_preset_select = (preset_color) => {
+    on_color_change(preset_color);
+    set_hex_input(preset_color);
+  };
+  return /* @__PURE__ */ jsxs(Popover, { open: is_open, onOpenChange: set_is_open, children: [
+    /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        className: "cls_color_picker_trigger h-8 w-8 p-0",
+        "aria-label": trigger_label,
+        children: /* @__PURE__ */ jsxs("div", { className: "cls_color_picker_icon_wrapper relative", children: [
+          trigger_icon,
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "cls_color_picker_indicator absolute -bottom-0.5 left-1/2 -translate-x-1/2 h-1 w-4 rounded-full",
+              style: { backgroundColor: color }
+            }
+          )
+        ] })
+      }
+    ) }),
+    /* @__PURE__ */ jsx(PopoverContent, { className: "cls_color_picker_popover w-64 p-3", align: "start", children: /* @__PURE__ */ jsxs("div", { className: "cls_color_picker_content space-y-3", children: [
+      /* @__PURE__ */ jsx(
+        HexColorPicker,
+        {
+          color,
+          onChange: (new_color) => {
+            on_color_change(new_color);
+            set_hex_input(new_color);
+          },
+          className: "cls_color_picker_main !w-full"
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "cls_color_picker_hex_input flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: "Hex:" }),
+        /* @__PURE__ */ jsx(
+          Input,
+          {
+            value: hex_input,
+            onChange: handle_hex_input_change,
+            className: "h-8 font-mono text-sm",
+            placeholder: "#000000"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "cls_color_picker_presets", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground mb-2 block", children: "Presets" }),
+        /* @__PURE__ */ jsx("div", { className: "grid grid-cols-10 gap-1", children: PRESET_COLORS.map((preset_color) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => handle_preset_select(preset_color),
+            className: cn(
+              "cls_color_preset h-5 w-5 rounded border border-border transition-transform",
+              "hover:scale-110 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-1",
+              color === preset_color && "ring-2 ring-primary ring-offset-1"
+            ),
+            style: { backgroundColor: preset_color },
+            "aria-label": `Select color ${preset_color}`
+          },
+          preset_color
+        )) })
+      ] })
+    ] }) })
+  ] });
+}
+function TableSizePicker({
+  max_rows = 8,
+  max_cols = 8,
+  on_select
+}) {
+  const [hover_row, set_hover_row] = React14.useState(0);
+  const [hover_col, set_hover_col] = React14.useState(0);
+  return /* @__PURE__ */ jsxs("div", { className: "cls_table_size_picker p-2", children: [
+    /* @__PURE__ */ jsx("div", { className: "cls_table_size_label text-sm text-muted-foreground mb-2 text-center", children: hover_row > 0 && hover_col > 0 ? `${hover_row} x ${hover_col} Table` : "Select table size" }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "cls_table_size_grid grid gap-1",
+        style: {
+          gridTemplateColumns: `repeat(${max_cols}, 1fr)`
+        },
+        onMouseLeave: () => {
+          set_hover_row(0);
+          set_hover_col(0);
+        },
+        children: Array.from({ length: max_rows * max_cols }).map((_, index) => {
+          const row = Math.floor(index / max_cols) + 1;
+          const col = index % max_cols + 1;
+          const is_highlighted = row <= hover_row && col <= hover_col;
+          return /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: cn(
+                "cls_table_size_cell w-4 h-4 border border-border rounded-sm cursor-pointer transition-colors",
+                is_highlighted ? "bg-primary border-primary" : "bg-background hover:bg-muted"
+              ),
+              onMouseEnter: () => {
+                set_hover_row(row);
+                set_hover_col(col);
+              },
+              onClick: () => on_select(row, col)
+            },
+            index
+          );
+        })
+      }
+    )
+  ] });
+}
+function ToolbarButton({ icon, label, on_click, is_active, disabled, className }) {
+  return /* @__PURE__ */ jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        onClick: on_click,
+        disabled,
+        className: cn(
+          "cls_toolbar_button h-8 w-8 p-0",
+          is_active && "bg-accent text-accent-foreground",
+          className
+        ),
+        children: icon
+      }
+    ) }),
+    /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: label }) })
+  ] });
+}
+function ToolbarDivider() {
+  return /* @__PURE__ */ jsx("div", { className: "cls_toolbar_divider mx-1 h-6 w-px bg-border" });
+}
+function get_current_font_size(editor) {
+  if (!editor) return DEFAULT_FONT_SIZE;
+  const attrs = editor.getAttributes("textStyle");
+  if (attrs?.fontSize) {
+    const parsed = parseInt(attrs.fontSize.replace("px", ""), 10);
+    return isNaN(parsed) ? DEFAULT_FONT_SIZE : parsed;
+  }
+  return DEFAULT_FONT_SIZE;
+}
+function Toolbar({ editor, on_open_variables_modal, variables, on_image_embed, on_add_attachment }) {
+  const [link_url, set_link_url] = React14.useState("");
+  const [is_link_popover_open, set_is_link_popover_open] = React14.useState(false);
+  const [is_block_type_open, set_is_block_type_open] = React14.useState(false);
+  const [is_table_popover_open, set_is_table_popover_open] = React14.useState(false);
+  const [is_table_controls_open, set_is_table_controls_open] = React14.useState(false);
+  const [is_columns_popover_open, set_is_columns_popover_open] = React14.useState(false);
+  const [is_uploading_image, set_is_uploading_image] = React14.useState(false);
+  const [is_uploading_attachment, set_is_uploading_attachment] = React14.useState(false);
+  const image_input_ref = React14.useRef(null);
+  const attachment_input_ref = React14.useRef(null);
+  if (!editor) {
+    return null;
+  }
+  const is_in_table = editor.isActive("table");
+  const current_font_family = editor.getAttributes("textStyle").fontFamily || "Arial";
+  const current_text_color = editor.getAttributes("textStyle").color || DEFAULT_TEXT_COLOR;
+  const current_highlight_color = editor.getAttributes("highlight").color || DEFAULT_HIGHLIGHT_COLOR;
+  const current_font_size = get_current_font_size(editor);
+  const handle_insert_link = () => {
+    if (link_url) {
+      editor.chain().focus().setLink({ href: link_url }).run();
+      set_link_url("");
+      set_is_link_popover_open(false);
+    }
+  };
+  const handle_image_change = async (e) => {
+    const file = e.target.files?.[0];
+    if (!file || !on_image_embed) return;
+    set_is_uploading_image(true);
+    try {
+      await on_image_embed(file);
+    } catch (error) {
+      console.error("Image embed failed:", error);
+    } finally {
+      set_is_uploading_image(false);
+      if (image_input_ref.current) {
+        image_input_ref.current.value = "";
+      }
+    }
+  };
+  const handle_attachment_change = async (e) => {
+    const file = e.target.files?.[0];
+    if (!file || !on_add_attachment) return;
+    set_is_uploading_attachment(true);
+    try {
+      await on_add_attachment(file);
+    } catch (error) {
+      console.error("Attachment failed:", error);
+    } finally {
+      set_is_uploading_attachment(false);
+      if (attachment_input_ref.current) {
+        attachment_input_ref.current.value = "";
+      }
+    }
+  };
+  const select_block_type = (command2) => {
+    command2();
+    set_is_block_type_open(false);
+  };
+  const handle_insert_table = (rows, cols) => {
+    editor.chain().focus().insertTable({ rows, cols, withHeaderRow: true }).run();
+    set_is_table_popover_open(false);
+  };
+  return /* @__PURE__ */ jsx(TooltipProvider, { delayDuration: 300, children: /* @__PURE__ */ jsxs("div", { className: "cls_toolbar flex flex-wrap items-center gap-0.5 p-2 border-b border-border bg-muted/30", children: [
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(LuUndo2, { className: "h-4 w-4" }),
+        label: "Undo",
+        on_click: () => editor.chain().focus().undo().run(),
+        disabled: !editor.can().undo()
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(LuRedo2, { className: "h-4 w-4" }),
+        label: "Redo",
+        on_click: () => editor.chain().focus().redo().run(),
+        disabled: !editor.can().redo()
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: current_font_family,
+        onValueChange: (value) => editor.chain().focus().setFontFamily(value).run(),
+        children: [
+          /* @__PURE__ */ jsx(SelectTrigger, { className: "cls_toolbar_font_family h-8 w-32 text-xs", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+          /* @__PURE__ */ jsx(SelectContent, { children: FONT_FAMILIES.map((font) => /* @__PURE__ */ jsx(SelectItem, { value: font.value, style: { fontFamily: font.value }, children: font.label }, font.value)) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiMinus, { className: "h-4 w-4" }),
+        label: "Decrease font size",
+        on_click: () => editor.chain().focus().decreaseFontSize().run()
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: "cls_toolbar_font_size w-8 text-center text-xs tabular-nums", children: current_font_size }),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiPlus, { className: "h-4 w-4" }),
+        label: "Increase font size",
+        on_click: () => editor.chain().focus().increaseFontSize().run()
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsxs(Popover, { open: is_block_type_open, onOpenChange: set_is_block_type_open, children: [
+      /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", size: "sm", className: "cls_toolbar_block_type h-8 gap-1 px-2", children: [
+        /* @__PURE__ */ jsx(LuHeading1, { className: "h-4 w-4" }),
+        /* @__PURE__ */ jsx(FiChevronDown, { className: "h-3 w-3" })
+      ] }) }),
+      /* @__PURE__ */ jsx(PopoverContent, { className: "cls_block_type_popover w-48 p-1", align: "start", children: /* @__PURE__ */ jsxs("div", { className: "cls_block_type_list space-y-0.5", children: [
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("paragraph") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().setParagraph().run()),
+            children: [
+              /* @__PURE__ */ jsx(FiType, { className: "mr-2 h-4 w-4" }),
+              "Paragraph"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("heading", { level: 1 }) ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleHeading({ level: 1 }).run()),
+            children: [
+              /* @__PURE__ */ jsx(LuHeading1, { className: "mr-2 h-4 w-4" }),
+              "Heading 1"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("heading", { level: 2 }) ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleHeading({ level: 2 }).run()),
+            children: [
+              /* @__PURE__ */ jsx(LuHeading2, { className: "mr-2 h-4 w-4" }),
+              "Heading 2"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("heading", { level: 3 }) ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleHeading({ level: 3 }).run()),
+            children: [
+              /* @__PURE__ */ jsx(LuHeading3, { className: "mr-2 h-4 w-4" }),
+              "Heading 3"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("bulletList") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleBulletList().run()),
+            children: [
+              /* @__PURE__ */ jsx(FiList, { className: "mr-2 h-4 w-4" }),
+              "Bullet List"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("orderedList") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleOrderedList().run()),
+            children: [
+              /* @__PURE__ */ jsx(LuListOrdered, { className: "mr-2 h-4 w-4" }),
+              "Numbered List"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("taskList") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleTaskList().run()),
+            children: [
+              /* @__PURE__ */ jsx(LuListTodo, { className: "mr-2 h-4 w-4" }),
+              "Task List"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("blockquote") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleBlockquote().run()),
+            children: [
+              /* @__PURE__ */ jsx(LuQuote, { className: "mr-2 h-4 w-4" }),
+              "Quote"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: editor.isActive("codeBlock") ? "secondary" : "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => select_block_type(() => editor.chain().focus().toggleCodeBlock().run()),
+            children: [
+              /* @__PURE__ */ jsx(FiCode, { className: "mr-2 h-4 w-4" }),
+              "Code Block"
+            ]
+          }
+        )
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiBold, { className: "h-4 w-4" }),
+        label: "Bold",
+        on_click: () => editor.chain().focus().toggleBold().run(),
+        is_active: editor.isActive("bold")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiItalic, { className: "h-4 w-4" }),
+        label: "Italic",
+        on_click: () => editor.chain().focus().toggleItalic().run(),
+        is_active: editor.isActive("italic")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiUnderline, { className: "h-4 w-4" }),
+        label: "Underline",
+        on_click: () => editor.chain().focus().toggleUnderline().run(),
+        is_active: editor.isActive("underline")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(LuStrikethrough, { className: "h-4 w-4" }),
+        label: "Strikethrough",
+        on_click: () => editor.chain().focus().toggleStrike().run(),
+        is_active: editor.isActive("strike")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(LuSubscript, { className: "h-4 w-4" }),
+        label: "Subscript",
+        on_click: () => editor.chain().focus().toggleSubscript().run(),
+        is_active: editor.isActive("subscript")
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(LuSuperscript, { className: "h-4 w-4" }),
+        label: "Superscript",
+        on_click: () => editor.chain().focus().toggleSuperscript().run(),
+        is_active: editor.isActive("superscript")
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsx(
+      ColorPickerPopover,
+      {
+        color: current_text_color,
+        on_color_change: (color) => editor.chain().focus().setColor(color).run(),
+        trigger_icon: /* @__PURE__ */ jsx(FiType, { className: "h-4 w-4" }),
+        trigger_label: "Text color"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ColorPickerPopover,
+      {
+        color: current_highlight_color,
+        on_color_change: (color) => editor.chain().focus().toggleHighlight({ color }).run(),
+        trigger_icon: /* @__PURE__ */ jsx(LuHighlighter, { className: "h-4 w-4" }),
+        trigger_label: "Highlight color"
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiAlignLeft, { className: "h-4 w-4" }),
+        label: "Align left",
+        on_click: () => editor.chain().focus().setTextAlign("left").run(),
+        is_active: editor.isActive({ textAlign: "left" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiAlignCenter, { className: "h-4 w-4" }),
+        label: "Align center",
+        on_click: () => editor.chain().focus().setTextAlign("center").run(),
+        is_active: editor.isActive({ textAlign: "center" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiAlignRight, { className: "h-4 w-4" }),
+        label: "Align right",
+        on_click: () => editor.chain().focus().setTextAlign("right").run(),
+        is_active: editor.isActive({ textAlign: "right" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiAlignJustify, { className: "h-4 w-4" }),
+        label: "Justify",
+        on_click: () => editor.chain().focus().setTextAlign("justify").run(),
+        is_active: editor.isActive({ textAlign: "justify" })
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsxs(Popover, { open: is_link_popover_open, onOpenChange: set_is_link_popover_open, children: [
+      /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          className: cn(
+            "cls_toolbar_link h-8 w-8 p-0",
+            editor.isActive("link") && "bg-accent text-accent-foreground"
+          ),
+          children: /* @__PURE__ */ jsx(FiLink, { className: "h-4 w-4" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(PopoverContent, { className: "cls_link_popover w-72 p-3", align: "start", children: /* @__PURE__ */ jsxs("div", { className: "cls_link_form space-y-2", children: [
+        /* @__PURE__ */ jsx("label", { className: "text-sm font-medium", children: "Insert Link" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "url",
+            placeholder: "https://example.com",
+            value: link_url,
+            onChange: (e) => set_link_url(e.target.value),
+            className: "cls_link_input w-full rounded-md border border-input bg-background px-3 py-2 text-sm",
+            onKeyDown: (e) => e.key === "Enter" && handle_insert_link()
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-2", children: [
+          editor.isActive("link") && /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: () => {
+                editor.chain().focus().unsetLink().run();
+                set_is_link_popover_open(false);
+              },
+              children: "Remove"
+            }
+          ),
+          /* @__PURE__ */ jsx(Button, { size: "sm", onClick: handle_insert_link, children: "Insert" })
+        ] })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs(Tooltip, { children: [
+      /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          className: "cls_toolbar_image h-8 w-8 p-0",
+          onClick: () => image_input_ref.current?.click(),
+          disabled: is_uploading_image,
+          children: /* @__PURE__ */ jsx(FiImage, { className: "h-4 w-4" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: "Insert image" }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: image_input_ref,
+        type: "file",
+        accept: "image/*",
+        className: "hidden",
+        onChange: handle_image_change
+      }
+    ),
+    /* @__PURE__ */ jsxs(Tooltip, { children: [
+      /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          className: "cls_toolbar_attach h-8 w-8 p-0",
+          onClick: () => attachment_input_ref.current?.click(),
+          disabled: is_uploading_attachment,
+          children: /* @__PURE__ */ jsx(FiPaperclip, { className: "h-4 w-4" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: "Add attachment" }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: attachment_input_ref,
+        type: "file",
+        accept: "image/*,.pdf,.doc,.docx,.xls,.xlsx,.txt,.zip,.rar",
+        className: "hidden",
+        onChange: handle_attachment_change
+      }
+    ),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsxs(Popover, { open: is_table_popover_open, onOpenChange: set_is_table_popover_open, children: [
+      /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          className: cn(
+            "cls_toolbar_table h-8 w-8 p-0",
+            editor.isActive("table") && "bg-accent text-accent-foreground"
+          ),
+          children: /* @__PURE__ */ jsx(FiTable, { className: "h-4 w-4" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(PopoverContent, { className: "cls_table_popover w-auto p-0", align: "start", children: /* @__PURE__ */ jsx(
+        TableSizePicker,
+        {
+          max_rows: 6,
+          max_cols: 6,
+          on_select: handle_insert_table
+        }
+      ) })
+    ] }),
+    is_in_table && /* @__PURE__ */ jsxs(Popover, { open: is_table_controls_open, onOpenChange: set_is_table_controls_open, children: [
+      /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", size: "sm", className: "cls_toolbar_table_controls h-8 gap-1 px-2", children: [
+        /* @__PURE__ */ jsx(LuTableProperties, { className: "h-4 w-4" }),
+        /* @__PURE__ */ jsx(FiChevronDown, { className: "h-3 w-3" })
+      ] }) }),
+      /* @__PURE__ */ jsx(PopoverContent, { className: "cls_table_controls_popover w-48 p-1", align: "start", children: /* @__PURE__ */ jsxs("div", { className: "cls_table_controls_list space-y-0.5", children: [
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().addRowAfter().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiInsertRowBottom, { className: "mr-2 h-4 w-4" }),
+              "Add Row Below"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().addRowBefore().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiInsertRowBottom, { className: "mr-2 h-4 w-4 rotate-180" }),
+              "Add Row Above"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().addColumnAfter().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiInsertColumnRight, { className: "mr-2 h-4 w-4" }),
+              "Add Column Right"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().addColumnBefore().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiInsertColumnRight, { className: "mr-2 h-4 w-4 rotate-180" }),
+              "Add Column Left"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { className: "my-1 h-px bg-border" }),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start text-destructive hover:text-destructive",
+            onClick: () => {
+              editor.chain().focus().deleteRow().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiDeleteRow, { className: "mr-2 h-4 w-4" }),
+              "Delete Row"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start text-destructive hover:text-destructive",
+            onClick: () => {
+              editor.chain().focus().deleteColumn().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(RiDeleteColumn, { className: "mr-2 h-4 w-4" }),
+              "Delete Column"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start text-destructive hover:text-destructive",
+            onClick: () => {
+              editor.chain().focus().deleteTable().run();
+              set_is_table_controls_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(FiTrash2, { className: "mr-2 h-4 w-4" }),
+              "Delete Table"
+            ]
+          }
+        )
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(FiMinus, { className: "h-4 w-4" }),
+        label: "Horizontal line",
+        on_click: () => editor.chain().focus().setHorizontalRule().run()
+      }
+    ),
+    /* @__PURE__ */ jsxs(Popover, { open: is_columns_popover_open, onOpenChange: set_is_columns_popover_open, children: [
+      /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "sm", className: "cls_toolbar_columns h-8 w-8 p-0", children: /* @__PURE__ */ jsx(FiColumns, { className: "h-4 w-4" }) }) }),
+      /* @__PURE__ */ jsx(PopoverContent, { className: "cls_columns_popover w-36 p-1", align: "start", children: /* @__PURE__ */ jsxs("div", { className: "cls_columns_list space-y-0.5", children: [
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().insertColumnLayout(2).run();
+              set_is_columns_popover_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(LuColumns2, { className: "mr-2 h-4 w-4" }),
+              "2 Columns"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "w-full justify-start",
+            onClick: () => {
+              editor.chain().focus().insertColumnLayout(3).run();
+              set_is_columns_popover_open(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(FiColumns, { className: "mr-2 h-4 w-4" }),
+              "3 Columns"
+            ]
+          }
+        )
+      ] }) })
+    ] }),
+    variables && variables.length > 0 && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+      /* @__PURE__ */ jsx(ToolbarDivider, {}),
+      /* @__PURE__ */ jsxs(Tooltip, { children: [
+        /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            onClick: on_open_variables_modal,
+            className: "cls_toolbar_variables h-8 gap-1 px-2",
+            children: [
+              /* @__PURE__ */ jsx(BiBracket, { className: "h-4 w-4" }),
+              /* @__PURE__ */ jsx("span", { className: "text-xs", children: "Variables" })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TooltipContent, { children: /* @__PURE__ */ jsx("p", { children: "Insert variable" }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(ToolbarDivider, {}),
+    /* @__PURE__ */ jsx(
+      ToolbarButton,
+      {
+        icon: /* @__PURE__ */ jsx(MdFormatClear, { className: "h-4 w-4" }),
+        label: "Clear formatting",
+        on_click: () => editor.chain().focus().unsetAllMarks().clearNodes().run()
+      }
+    )
+  ] }) });
+}
+var Tabs = TabsPrimitive.Root;
+var TabsList = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  TabsPrimitive.List,
+  {
+    ref,
+    className: cn(
+      "cls_tabs_list inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground",
+      className
+    ),
+    ...props
+  }
+));
+TabsList.displayName = TabsPrimitive.List.displayName;
+var TabsTrigger = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  TabsPrimitive.Trigger,
+  {
+    ref,
+    className: cn(
+      "cls_tabs_trigger inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
+      className
+    ),
+    ...props
+  }
+));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+var TabsContent = React14.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  TabsPrimitive.Content,
+  {
+    ref,
+    className: cn(
+      "cls_tabs_content mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      className
+    ),
+    ...props
+  }
+));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+function HtmlView({
+  html_content,
+  on_html_change,
+  html_view_mode,
+  on_html_view_mode_change,
+  min_height,
+  max_height,
+  read_only
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "cls_html_view", children: [
+    /* @__PURE__ */ jsxs("div", { className: "cls_html_view_toggle flex items-center gap-1 p-2 border-b border-border bg-muted/30", children: [
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: html_view_mode === "preview" ? "secondary" : "ghost",
+          size: "sm",
+          onClick: () => on_html_view_mode_change("preview"),
+          className: "h-7 gap-1 px-2",
+          children: [
+            /* @__PURE__ */ jsx(FiEye, { className: "h-3.5 w-3.5" }),
+            /* @__PURE__ */ jsx("span", { className: "text-xs", children: "Preview" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: html_view_mode === "code" ? "secondary" : "ghost",
+          size: "sm",
+          onClick: () => on_html_view_mode_change("code"),
+          className: "h-7 gap-1 px-2",
+          children: [
+            /* @__PURE__ */ jsx(FiCode, { className: "h-3.5 w-3.5" }),
+            /* @__PURE__ */ jsx("span", { className: "text-xs", children: "Code" })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "cls_html_view_content overflow-auto",
+        style: {
+          minHeight: min_height || DEFAULT_MIN_HEIGHT,
+          maxHeight: max_height || DEFAULT_MAX_HEIGHT
+        },
+        children: html_view_mode === "preview" ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "cls_html_preview prose prose-sm max-w-none p-4",
+            dangerouslySetInnerHTML: { __html: html_content }
+          }
+        ) : /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            value: html_content,
+            onChange: (e) => on_html_change(e.target.value),
+            readOnly: read_only,
+            className: cn(
+              "cls_html_code w-full h-full p-4 font-mono text-sm",
+              "bg-muted/20 resize-none border-none outline-none",
+              "focus:ring-0"
+            ),
+            style: {
+              minHeight: min_height || DEFAULT_MIN_HEIGHT
+            },
+            spellCheck: false
+          }
+        )
+      }
+    )
+  ] });
+}
+function TextView({
+  text_content,
+  on_text_change,
+  min_height,
+  max_height,
+  read_only
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "cls_text_view overflow-auto",
+      style: {
+        minHeight: min_height || DEFAULT_MIN_HEIGHT,
+        maxHeight: max_height || DEFAULT_MAX_HEIGHT
+      },
+      children: /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          value: text_content,
+          onChange: (e) => on_text_change(e.target.value),
+          readOnly: read_only,
+          className: cn(
+            "cls_text_area w-full h-full p-4 text-sm",
+            "bg-background resize-none border-none outline-none",
+            "focus:ring-0"
+          ),
+          style: {
+            minHeight: min_height || DEFAULT_MIN_HEIGHT
+          },
+          spellCheck: true
+        }
+      )
+    }
+  );
+}
+function VisualView({ children, min_height, max_height }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "cls_visual_view overflow-auto",
+      style: {
+        minHeight: min_height || DEFAULT_MIN_HEIGHT,
+        maxHeight: max_height || DEFAULT_MAX_HEIGHT
+      },
+      children
+    }
+  );
+}
+function ViewTabs({
+  active_tab,
+  on_tab_change,
+  // editor is unused but kept in props interface for consistency
+  html_content,
+  text_content,
+  on_html_change,
+  on_text_change,
+  html_view_mode,
+  on_html_view_mode_change,
+  min_height,
+  max_height,
+  read_only,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    Tabs,
+    {
+      value: active_tab,
+      onValueChange: (value) => on_tab_change(value),
+      className: "cls_view_tabs",
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "cls_view_tabs_header flex items-center justify-between border-b border-border", children: /* @__PURE__ */ jsxs(TabsList, { className: "cls_view_tabs_list h-9 bg-transparent p-0 border-none rounded-none", children: [
+          /* @__PURE__ */ jsx(
+            TabsTrigger,
+            {
+              value: "visual",
+              className: cn(
+                "cls_view_tab_trigger rounded-none border-b-2 border-transparent px-4 py-2",
+                "data-[state=active]:border-primary data-[state=active]:bg-transparent"
+              ),
+              children: "Visual"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            TabsTrigger,
+            {
+              value: "html",
+              className: cn(
+                "cls_view_tab_trigger rounded-none border-b-2 border-transparent px-4 py-2",
+                "data-[state=active]:border-primary data-[state=active]:bg-transparent"
+              ),
+              children: "HTML"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            TabsTrigger,
+            {
+              value: "text",
+              className: cn(
+                "cls_view_tab_trigger rounded-none border-b-2 border-transparent px-4 py-2",
+                "data-[state=active]:border-primary data-[state=active]:bg-transparent"
+              ),
+              children: "Text"
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsx(TabsContent, { value: "visual", className: "cls_view_tab_content mt-0", children: /* @__PURE__ */ jsx(VisualView, { min_height, max_height, children }) }),
+        /* @__PURE__ */ jsx(TabsContent, { value: "html", className: "cls_view_tab_content mt-0", children: /* @__PURE__ */ jsx(
+          HtmlView,
+          {
+            html_content,
+            on_html_change,
+            html_view_mode,
+            on_html_view_mode_change,
+            min_height,
+            max_height,
+            read_only
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TabsContent, { value: "text", className: "cls_view_tab_content mt-0", children: /* @__PURE__ */ jsx(
+          TextView,
+          {
+            text_content,
+            on_text_change,
+            min_height,
+            max_height,
+            read_only
+          }
+        ) })
+      ]
+    }
+  );
+}
+var ScrollArea = React14.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  ScrollAreaPrimitive.Root,
+  {
+    ref,
+    className: cn("cls_scroll_area relative overflow-hidden", className),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx(ScrollAreaPrimitive.Viewport, { className: "h-full w-full rounded-[inherit]", children }),
+      /* @__PURE__ */ jsx(ScrollBar, {}),
+      /* @__PURE__ */ jsx(ScrollAreaPrimitive.Corner, {})
+    ]
+  }
+));
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName;
+var ScrollBar = React14.forwardRef(({ className, orientation = "vertical", ...props }, ref) => /* @__PURE__ */ jsx(
+  ScrollAreaPrimitive.ScrollAreaScrollbar,
+  {
+    ref,
+    orientation,
+    className: cn(
+      "cls_scroll_bar flex touch-none select-none transition-colors",
+      orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-[1px]",
+      orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-[1px]",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(ScrollAreaPrimitive.ScrollAreaThumb, { className: "cls_scroll_thumb relative flex-1 rounded-full bg-border" })
+  }
+));
+ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName;
+function group_variables_by_category(variables) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const variable of variables) {
+    const category = variable.category || "General";
+    const existing = grouped.get(category) || [];
+    grouped.set(category, [...existing, variable]);
+  }
+  return grouped;
+}
+function VariablesModal({
+  is_open,
+  on_close,
+  variables,
+  on_select_variable
+}) {
+  const [search_query, set_search_query] = React14.useState("");
+  const filtered_variables = React14.useMemo(() => {
+    if (!search_query.trim()) {
+      return variables;
+    }
+    const query = search_query.toLowerCase();
+    return variables.filter(
+      (v) => v.text.toLowerCase().includes(query) || v.description.toLowerCase().includes(query) || v.category && v.category.toLowerCase().includes(query)
+    );
+  }, [variables, search_query]);
+  const grouped_variables = React14.useMemo(
+    () => group_variables_by_category(filtered_variables),
+    [filtered_variables]
+  );
+  const handle_select = (variable) => {
+    on_select_variable(variable);
+    on_close();
+    set_search_query("");
+  };
+  React14.useEffect(() => {
+    if (!is_open) {
+      set_search_query("");
+    }
+  }, [is_open]);
+  return /* @__PURE__ */ jsx(Dialog, { open: is_open, onOpenChange: (open) => !open && on_close(), children: /* @__PURE__ */ jsxs(DialogContent, { className: "cls_variables_modal sm:max-w-md", children: [
+    /* @__PURE__ */ jsxs(DialogHeader, { children: [
+      /* @__PURE__ */ jsx(DialogTitle, { children: "Insert Variable" }),
+      /* @__PURE__ */ jsx(DialogDescription, { children: "Select a variable to insert into the editor. Variables will be replaced with actual values when the content is processed." })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "cls_variables_modal_search relative", children: [
+      /* @__PURE__ */ jsx(FiSearch, { className: "absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          placeholder: "Search variables...",
+          value: search_query,
+          onChange: (e) => set_search_query(e.target.value),
+          className: "pl-9"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(ScrollArea, { className: "cls_variables_modal_list h-[300px] pr-4", children: filtered_variables.length === 0 ? /* @__PURE__ */ jsx("div", { className: "cls_variables_modal_empty py-8 text-center text-muted-foreground", children: "No variables found" }) : /* @__PURE__ */ jsx("div", { className: "cls_variables_modal_groups space-y-4", children: Array.from(grouped_variables.entries()).map(([category, vars]) => /* @__PURE__ */ jsxs("div", { className: "cls_variables_modal_group", children: [
+      /* @__PURE__ */ jsx("h4", { className: "cls_variables_modal_category mb-2 text-sm font-medium text-muted-foreground", children: category }),
+      /* @__PURE__ */ jsx("div", { className: "space-y-1", children: vars.map((variable) => /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: () => handle_select(variable),
+          className: cn(
+            "cls_variable_item w-full text-left px-3 py-2 rounded-md",
+            "hover:bg-accent transition-colors",
+            "focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2"
+          ),
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "cls_variable_item_name font-mono text-sm text-primary", children: `{{${variable.text}}}` }),
+            /* @__PURE__ */ jsx("div", { className: "cls_variable_item_description text-xs text-muted-foreground mt-0.5", children: variable.description })
+          ]
+        },
+        variable.text
+      )) })
+    ] }, category)) }) })
+  ] }) });
+}
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function createChainableState(config) {
+  const { state, transaction } = config;
+  let { selection } = transaction;
+  let { doc } = transaction;
+  let { storedMarks } = transaction;
+  return {
+    ...state,
+    apply: state.apply.bind(state),
+    applyTransaction: state.applyTransaction.bind(state),
+    plugins: state.plugins,
+    schema: state.schema,
+    reconfigure: state.reconfigure.bind(state),
+    toJSON: state.toJSON.bind(state),
+    get storedMarks() {
+      return storedMarks;
+    },
+    get selection() {
+      return selection;
+    },
+    get doc() {
+      return doc;
+    },
+    get tr() {
+      selection = transaction.selection;
+      doc = transaction.doc;
+      storedMarks = transaction.storedMarks;
+      return transaction;
+    }
+  };
+}
+var CommandManager = class {
+  constructor(props) {
+    this.editor = props.editor;
+    this.rawCommands = this.editor.extensionManager.commands;
+    this.customState = props.state;
+  }
+  get hasCustomState() {
+    return !!this.customState;
+  }
+  get state() {
+    return this.customState || this.editor.state;
+  }
+  get commands() {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    const { tr } = state;
+    const props = this.buildProps(tr);
+    return Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command2]) => {
+        const method = (...args) => {
+          const callback = command2(...args)(props);
+          if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
+            view.dispatch(tr);
+          }
+          return callback;
+        };
+        return [name, method];
+      })
+    );
+  }
+  get chain() {
+    return () => this.createChain();
+  }
+  get can() {
+    return () => this.createCan();
+  }
+  createChain(startTr, shouldDispatch = true) {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    const callbacks = [];
+    const hasStartTransaction = !!startTr;
+    const tr = startTr || state.tr;
+    const run3 = () => {
+      if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
+        view.dispatch(tr);
+      }
+      return callbacks.every((callback) => callback === true);
+    };
+    const chain = {
+      ...Object.fromEntries(
+        Object.entries(rawCommands).map(([name, command2]) => {
+          const chainedCommand = (...args) => {
+            const props = this.buildProps(tr, shouldDispatch);
+            const callback = command2(...args)(props);
+            callbacks.push(callback);
+            return chain;
+          };
+          return [name, chainedCommand];
+        })
+      ),
+      run: run3
+    };
+    return chain;
+  }
+  createCan(startTr) {
+    const { rawCommands, state } = this;
+    const dispatch = false;
+    const tr = startTr || state.tr;
+    const props = this.buildProps(tr, dispatch);
+    const formattedCommands = Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command2]) => {
+        return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
+      })
+    );
+    return {
+      ...formattedCommands,
+      chain: () => this.createChain(tr, dispatch)
+    };
+  }
+  buildProps(tr, shouldDispatch = true) {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    const props = {
+      tr,
+      editor,
+      view,
+      state: createChainableState({
+        state,
+        transaction: tr
+      }),
+      dispatch: shouldDispatch ? () => void 0 : void 0,
+      chain: () => this.createChain(tr, shouldDispatch),
+      can: () => this.createCan(tr),
+      get commands() {
+        return Object.fromEntries(
+          Object.entries(rawCommands).map(([name, command2]) => {
+            return [name, (...args) => command2(...args)(props)];
+          })
+        );
+      }
+    };
+    return props;
+  }
+};
+var commands_exports = {};
+__export(commands_exports, {
+  blur: () => blur,
+  clearContent: () => clearContent,
+  clearNodes: () => clearNodes,
+  command: () => command,
+  createParagraphNear: () => createParagraphNear,
+  cut: () => cut,
+  deleteCurrentNode: () => deleteCurrentNode,
+  deleteNode: () => deleteNode,
+  deleteRange: () => deleteRange,
+  deleteSelection: () => deleteSelection,
+  enter: () => enter,
+  exitCode: () => exitCode,
+  extendMarkRange: () => extendMarkRange,
+  first: () => first,
+  focus: () => focus,
+  forEach: () => forEach,
+  insertContent: () => insertContent,
+  insertContentAt: () => insertContentAt,
+  joinBackward: () => joinBackward,
+  joinDown: () => joinDown,
+  joinForward: () => joinForward,
+  joinItemBackward: () => joinItemBackward,
+  joinItemForward: () => joinItemForward,
+  joinTextblockBackward: () => joinTextblockBackward,
+  joinTextblockForward: () => joinTextblockForward,
+  joinUp: () => joinUp,
+  keyboardShortcut: () => keyboardShortcut,
+  lift: () => lift,
+  liftEmptyBlock: () => liftEmptyBlock,
+  liftListItem: () => liftListItem,
+  newlineInCode: () => newlineInCode,
+  resetAttributes: () => resetAttributes,
+  scrollIntoView: () => scrollIntoView,
+  selectAll: () => selectAll,
+  selectNodeBackward: () => selectNodeBackward,
+  selectNodeForward: () => selectNodeForward,
+  selectParentNode: () => selectParentNode,
+  selectTextblockEnd: () => selectTextblockEnd,
+  selectTextblockStart: () => selectTextblockStart,
+  setContent: () => setContent,
+  setMark: () => setMark,
+  setMeta: () => setMeta,
+  setNode: () => setNode,
+  setNodeSelection: () => setNodeSelection,
+  setTextDirection: () => setTextDirection,
+  setTextSelection: () => setTextSelection,
+  sinkListItem: () => sinkListItem,
+  splitBlock: () => splitBlock,
+  splitListItem: () => splitListItem,
+  toggleList: () => toggleList,
+  toggleMark: () => toggleMark,
+  toggleNode: () => toggleNode,
+  toggleWrap: () => toggleWrap,
+  undoInputRule: () => undoInputRule,
+  unsetAllMarks: () => unsetAllMarks,
+  unsetMark: () => unsetMark,
+  unsetTextDirection: () => unsetTextDirection,
+  updateAttributes: () => updateAttributes,
+  wrapIn: () => wrapIn,
+  wrapInList: () => wrapInList
+});
+var blur = () => ({ editor, view }) => {
+  requestAnimationFrame(() => {
+    var _a;
+    if (!editor.isDestroyed) {
+      view.dom.blur();
+      (_a = window == null ? void 0 : window.getSelection()) == null ? void 0 : _a.removeAllRanges();
+    }
+  });
+  return true;
+};
+var clearContent = (emitUpdate = true) => ({ commands }) => {
+  return commands.setContent("", { emitUpdate });
+};
+var clearNodes = () => ({ state, tr, dispatch }) => {
+  const { selection } = tr;
+  const { ranges } = selection;
+  if (!dispatch) {
+    return true;
+  }
+  ranges.forEach(({ $from, $to }) => {
+    state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+      if (node.type.isText) {
+        return;
+      }
+      const { doc, mapping } = tr;
+      const $mappedFrom = doc.resolve(mapping.map(pos));
+      const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
+      const nodeRange = $mappedFrom.blockRange($mappedTo);
+      if (!nodeRange) {
+        return;
+      }
+      const targetLiftDepth = liftTarget(nodeRange);
+      if (node.type.isTextblock) {
+        const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
+        tr.setNodeMarkup(nodeRange.start, defaultType);
+      }
+      if (targetLiftDepth || targetLiftDepth === 0) {
+        tr.lift(nodeRange, targetLiftDepth);
+      }
+    });
+  });
+  return true;
+};
+var command = (fn) => (props) => {
+  return fn(props);
+};
+var createParagraphNear = () => ({ state, dispatch }) => {
+  return createParagraphNear$1(state, dispatch);
+};
+var cut = (originRange, targetPos) => ({ editor, tr }) => {
+  const { state } = editor;
+  const contentSlice = state.doc.slice(originRange.from, originRange.to);
+  tr.deleteRange(originRange.from, originRange.to);
+  const newPos = tr.mapping.map(targetPos);
+  tr.insert(newPos, contentSlice.content);
+  tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
+  return true;
+};
+var deleteCurrentNode = () => ({ tr, dispatch }) => {
+  const { selection } = tr;
+  const currentNode = selection.$anchor.node();
+  if (currentNode.content.size > 0) {
+    return false;
+  }
+  const $pos = tr.selection.$anchor;
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === currentNode.type) {
+      if (dispatch) {
+        const from = $pos.before(depth);
+        const to = $pos.after(depth);
+        tr.delete(from, to).scrollIntoView();
+      }
+      return true;
+    }
+  }
+  return false;
+};
+function getNodeType(nameOrType, schema) {
+  if (typeof nameOrType === "string") {
+    if (!schema.nodes[nameOrType]) {
+      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
+    }
+    return schema.nodes[nameOrType];
+  }
+  return nameOrType;
+}
+var deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const $pos = tr.selection.$anchor;
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === type) {
+      if (dispatch) {
+        const from = $pos.before(depth);
+        const to = $pos.after(depth);
+        tr.delete(from, to).scrollIntoView();
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var deleteRange = (range) => ({ tr, dispatch }) => {
+  const { from, to } = range;
+  if (dispatch) {
+    tr.delete(from, to);
+  }
+  return true;
+};
+var deleteSelection = () => ({ state, dispatch }) => {
+  return deleteSelection$1(state, dispatch);
+};
+var enter = () => ({ commands }) => {
+  return commands.keyboardShortcut("Enter");
+};
+var exitCode = () => ({ state, dispatch }) => {
+  return exitCode$1(state, dispatch);
+};
+function isRegExp(value) {
+  return Object.prototype.toString.call(value) === "[object RegExp]";
+}
+function objectIncludes(object1, object2, options = { strict: true }) {
+  const keys = Object.keys(object2);
+  if (!keys.length) {
+    return true;
+  }
+  return keys.every((key) => {
+    if (options.strict) {
+      return object2[key] === object1[key];
+    }
+    if (isRegExp(object2[key])) {
+      return object2[key].test(object1[key]);
+    }
+    return object2[key] === object1[key];
+  });
+}
+function findMarkInSet(marks, type, attributes = {}) {
+  return marks.find((item) => {
+    return item.type === type && objectIncludes(
+      // Only check equality for the attributes that are provided
+      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
+      attributes
+    );
+  });
+}
+function isMarkInSet(marks, type, attributes = {}) {
+  return !!findMarkInSet(marks, type, attributes);
+}
+function getMarkRange($pos, type, attributes) {
+  var _a;
+  if (!$pos || !type) {
+    return;
+  }
+  let start = $pos.parent.childAfter($pos.parentOffset);
+  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
+    start = $pos.parent.childBefore($pos.parentOffset);
+  }
+  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
+    return;
+  }
+  attributes = attributes || ((_a = start.node.marks[0]) == null ? void 0 : _a.attrs);
+  const mark = findMarkInSet([...start.node.marks], type, attributes);
+  if (!mark) {
+    return;
+  }
+  let startIndex = start.index;
+  let startPos = $pos.start() + start.offset;
+  let endIndex = startIndex + 1;
+  let endPos = startPos + start.node.nodeSize;
+  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
+    startIndex -= 1;
+    startPos -= $pos.parent.child(startIndex).nodeSize;
+  }
+  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
+    endPos += $pos.parent.child(endIndex).nodeSize;
+    endIndex += 1;
+  }
+  return {
+    from: startPos,
+    to: endPos
+  };
+}
+function getMarkType(nameOrType, schema) {
+  if (typeof nameOrType === "string") {
+    if (!schema.marks[nameOrType]) {
+      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
+    }
+    return schema.marks[nameOrType];
+  }
+  return nameOrType;
+}
+var extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  const type = getMarkType(typeOrName, state.schema);
+  const { doc, selection } = tr;
+  const { $from, from, to } = selection;
+  if (dispatch) {
+    const range = getMarkRange($from, type, attributes);
+    if (range && range.from <= from && range.to >= to) {
+      const newSelection = TextSelection.create(doc, range.from, range.to);
+      tr.setSelection(newSelection);
+    }
+  }
+  return true;
+};
+var first = (commands) => (props) => {
+  const items = typeof commands === "function" ? commands(props) : commands;
+  for (let i = 0; i < items.length; i += 1) {
+    if (items[i](props)) {
+      return true;
+    }
+  }
+  return false;
+};
+function isTextSelection(value) {
+  return value instanceof TextSelection;
+}
+function minMax(value = 0, min = 0, max = 0) {
+  return Math.min(Math.max(value, min), max);
+}
+function resolveFocusPosition(doc, position = null) {
+  if (!position) {
+    return null;
+  }
+  const selectionAtStart = Selection.atStart(doc);
+  const selectionAtEnd = Selection.atEnd(doc);
+  if (position === "start" || position === true) {
+    return selectionAtStart;
+  }
+  if (position === "end") {
+    return selectionAtEnd;
+  }
+  const minPos = selectionAtStart.from;
+  const maxPos = selectionAtEnd.to;
+  if (position === "all") {
+    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
+  }
+  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
+}
+function isAndroid() {
+  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
+}
+function isiOS() {
+  return ["iPad Simulator", "iPhone Simulator", "iPod Simulator", "iPad", "iPhone", "iPod"].includes(navigator.platform) || // iPad on iOS 13 detection
+  navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
+var focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
+  options = {
+    scrollIntoView: true,
+    ...options
+  };
+  const delayedFocus = () => {
+    if (isiOS() || isAndroid()) {
+      view.dom.focus();
+    }
+    requestAnimationFrame(() => {
+      if (!editor.isDestroyed) {
+        view.focus();
+        if (options == null ? void 0 : options.scrollIntoView) {
+          editor.commands.scrollIntoView();
+        }
+      }
+    });
+  };
+  if (view.hasFocus() && position === null || position === false) {
+    return true;
+  }
+  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
+    delayedFocus();
+    return true;
+  }
+  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
+  const isSameSelection = editor.state.selection.eq(selection);
+  if (dispatch) {
+    if (!isSameSelection) {
+      tr.setSelection(selection);
+    }
+    if (isSameSelection && tr.storedMarks) {
+      tr.setStoredMarks(tr.storedMarks);
+    }
+    delayedFocus();
+  }
+  return true;
+};
+var forEach = (items, fn) => (props) => {
+  return items.every((item, index) => fn(item, { ...props, index }));
+};
+var insertContent = (value, options) => ({ tr, commands }) => {
+  return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
+};
+var removeWhitespaces = (node) => {
+  const children = node.childNodes;
+  for (let i = children.length - 1; i >= 0; i -= 1) {
+    const child = children[i];
+    if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
+      node.removeChild(child);
+    } else if (child.nodeType === 1) {
+      removeWhitespaces(child);
+    }
+  }
+  return node;
+};
+function elementFromString(value) {
+  if (typeof window === "undefined") {
+    throw new Error("[tiptap error]: there is no window object available, so this function cannot be used");
+  }
+  const wrappedValue = `<body>${value}</body>`;
+  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
+  return removeWhitespaces(html);
+}
+function createNodeFromContent(content, schema, options) {
+  if (content instanceof Node || content instanceof Fragment) {
+    return content;
+  }
+  options = {
+    slice: true,
+    parseOptions: {},
+    ...options
+  };
+  const isJSONContent = typeof content === "object" && content !== null;
+  const isTextContent = typeof content === "string";
+  if (isJSONContent) {
+    try {
+      const isArrayContent = Array.isArray(content) && content.length > 0;
+      if (isArrayContent) {
+        return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
+      }
+      const node = schema.nodeFromJSON(content);
+      if (options.errorOnInvalidContent) {
+        node.check();
+      }
+      return node;
+    } catch (error) {
+      if (options.errorOnInvalidContent) {
+        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
+      }
+      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
+      return createNodeFromContent("", schema, options);
+    }
+  }
+  if (isTextContent) {
+    if (options.errorOnInvalidContent) {
+      let hasInvalidContent = false;
+      let invalidContent = "";
+      const contentCheckSchema = new Schema({
+        topNode: schema.spec.topNode,
+        marks: schema.spec.marks,
+        // Prosemirror's schemas are executed such that: the last to execute, matches last
+        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+        nodes: schema.spec.nodes.append({
+          __tiptap__private__unknown__catch__all__node: {
+            content: "inline*",
+            group: "block",
+            parseDOM: [
+              {
+                tag: "*",
+                getAttrs: (e) => {
+                  hasInvalidContent = true;
+                  invalidContent = typeof e === "string" ? e : e.outerHTML;
+                  return null;
+                }
+              }
+            ]
+          }
+        })
+      });
+      if (options.slice) {
+        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
+      } else {
+        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
+      }
+      if (options.errorOnInvalidContent && hasInvalidContent) {
+        throw new Error("[tiptap error]: Invalid HTML content", {
+          cause: new Error(`Invalid element found: ${invalidContent}`)
+        });
+      }
+    }
+    const parser = DOMParser.fromSchema(schema);
+    if (options.slice) {
+      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
+    }
+    return parser.parse(elementFromString(content), options.parseOptions);
+  }
+  return createNodeFromContent("", schema, options);
+}
+function selectionToInsertionEnd(tr, startLen, bias) {
+  const last = tr.steps.length - 1;
+  if (last < startLen) {
+    return;
+  }
+  const step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
+    return;
+  }
+  const map = tr.mapping.maps[last];
+  let end = 0;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    if (end === 0) {
+      end = newTo;
+    }
+  });
+  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
+}
+var isFragment = (nodeOrFragment) => {
+  return !("type" in nodeOrFragment);
+};
+var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
+  var _a;
+  if (dispatch) {
+    options = {
+      parseOptions: editor.options.parseOptions,
+      updateSelection: true,
+      applyInputRules: false,
+      applyPasteRules: false,
+      ...options
+    };
+    let content;
+    const emitContentError = (error) => {
+      editor.emit("contentError", {
+        editor,
+        error,
+        disableCollaboration: () => {
+          if ("collaboration" in editor.storage && typeof editor.storage.collaboration === "object" && editor.storage.collaboration) {
+            editor.storage.collaboration.isDisabled = true;
+          }
+        }
+      });
+    };
+    const parseOptions = {
+      preserveWhitespace: "full",
+      ...options.parseOptions
+    };
+    if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
+      try {
+        createNodeFromContent(value, editor.schema, {
+          parseOptions,
+          errorOnInvalidContent: true
+        });
+      } catch (e) {
+        emitContentError(e);
+      }
+    }
+    try {
+      content = createNodeFromContent(value, editor.schema, {
+        parseOptions,
+        errorOnInvalidContent: (_a = options.errorOnInvalidContent) != null ? _a : editor.options.enableContentCheck
+      });
+    } catch (e) {
+      emitContentError(e);
+      return false;
+    }
+    let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
+    let isOnlyTextContent = true;
+    let isOnlyBlockContent = true;
+    const nodes = isFragment(content) ? content : [content];
+    nodes.forEach((node) => {
+      node.check();
+      isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false;
+      isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false;
+    });
+    if (from === to && isOnlyBlockContent) {
+      const { parent } = tr.doc.resolve(from);
+      const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
+      if (isEmptyTextBlock) {
+        from -= 1;
+        to += 1;
+      }
+    }
+    let newContent;
+    if (isOnlyTextContent) {
+      if (Array.isArray(value)) {
+        newContent = value.map((v) => v.text || "").join("");
+      } else if (value instanceof Fragment) {
+        let text = "";
+        value.forEach((node) => {
+          if (node.text) {
+            text += node.text;
+          }
+        });
+        newContent = text;
+      } else if (typeof value === "object" && !!value && !!value.text) {
+        newContent = value.text;
+      } else {
+        newContent = value;
+      }
+      tr.insertText(newContent, from, to);
+    } else {
+      newContent = content;
+      const $from = tr.doc.resolve(from);
+      const $fromNode = $from.node();
+      const fromSelectionAtStart = $from.parentOffset === 0;
+      const isTextSelection2 = $fromNode.isText || $fromNode.isTextblock;
+      const hasContent = $fromNode.content.size > 0;
+      if (fromSelectionAtStart && isTextSelection2 && hasContent) {
+        from = Math.max(0, from - 1);
+      }
+      tr.replaceWith(from, to, newContent);
+    }
+    if (options.updateSelection) {
+      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
+    }
+    if (options.applyInputRules) {
+      tr.setMeta("applyInputRules", { from, text: newContent });
+    }
+    if (options.applyPasteRules) {
+      tr.setMeta("applyPasteRules", { from, text: newContent });
+    }
+  }
+  return true;
+};
+var joinUp = () => ({ state, dispatch }) => {
+  return joinUp$1(state, dispatch);
+};
+var joinDown = () => ({ state, dispatch }) => {
+  return joinDown$1(state, dispatch);
+};
+var joinBackward = () => ({ state, dispatch }) => {
+  return joinBackward$1(state, dispatch);
+};
+var joinForward = () => ({ state, dispatch }) => {
+  return joinForward$1(state, dispatch);
+};
+var joinItemBackward = () => ({ state, dispatch, tr }) => {
+  try {
+    const point = joinPoint(state.doc, state.selection.$from.pos, -1);
+    if (point === null || point === void 0) {
+      return false;
+    }
+    tr.join(point, 2);
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var joinItemForward = () => ({ state, dispatch, tr }) => {
+  try {
+    const point = joinPoint(state.doc, state.selection.$from.pos, 1);
+    if (point === null || point === void 0) {
+      return false;
+    }
+    tr.join(point, 2);
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var joinTextblockBackward = () => ({ state, dispatch }) => {
+  return joinTextblockBackward$1(state, dispatch);
+};
+var joinTextblockForward = () => ({ state, dispatch }) => {
+  return joinTextblockForward$1(state, dispatch);
+};
+function isMacOS() {
+  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
+}
+function normalizeKeyName(name) {
+  const parts = name.split(/-(?!$)/);
+  let result = parts[parts.length - 1];
+  if (result === "Space") {
+    result = " ";
+  }
+  let alt;
+  let ctrl;
+  let shift;
+  let meta;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const mod = parts[i];
+    if (/^(cmd|meta|m)$/i.test(mod)) {
+      meta = true;
+    } else if (/^a(lt)?$/i.test(mod)) {
+      alt = true;
+    } else if (/^(c|ctrl|control)$/i.test(mod)) {
+      ctrl = true;
+    } else if (/^s(hift)?$/i.test(mod)) {
+      shift = true;
+    } else if (/^mod$/i.test(mod)) {
+      if (isiOS() || isMacOS()) {
+        meta = true;
+      } else {
+        ctrl = true;
+      }
+    } else {
+      throw new Error(`Unrecognized modifier name: ${mod}`);
+    }
+  }
+  if (alt) {
+    result = `Alt-${result}`;
+  }
+  if (ctrl) {
+    result = `Ctrl-${result}`;
+  }
+  if (meta) {
+    result = `Meta-${result}`;
+  }
+  if (shift) {
+    result = `Shift-${result}`;
+  }
+  return result;
+}
+var keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
+  const keys = normalizeKeyName(name).split(/-(?!$)/);
+  const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
+  const event = new KeyboardEvent("keydown", {
+    key: key === "Space" ? " " : key,
+    altKey: keys.includes("Alt"),
+    ctrlKey: keys.includes("Ctrl"),
+    metaKey: keys.includes("Meta"),
+    shiftKey: keys.includes("Shift"),
+    bubbles: true,
+    cancelable: true
+  });
+  const capturedTransaction = editor.captureTransaction(() => {
+    view.someProp("handleKeyDown", (f) => f(view, event));
+  });
+  capturedTransaction == null ? void 0 : capturedTransaction.steps.forEach((step) => {
+    const newStep = step.map(tr.mapping);
+    if (newStep && dispatch) {
+      tr.maybeStep(newStep);
+    }
+  });
+  return true;
+};
+function isNodeActive(state, typeOrName, attributes = {}) {
+  const { from, to, empty } = state.selection;
+  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
+  const nodeRanges = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isText) {
+      return;
+    }
+    const relativeFrom = Math.max(from, pos);
+    const relativeTo = Math.min(to, pos + node.nodeSize);
+    nodeRanges.push({
+      node,
+      from: relativeFrom,
+      to: relativeTo
+    });
+  });
+  const selectionRange = to - from;
+  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
+    if (!type) {
+      return true;
+    }
+    return type.name === nodeRange.node.type.name;
+  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
+  if (empty) {
+    return !!matchedNodeRanges.length;
+  }
+  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
+  return range >= selectionRange;
+}
+var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (!isActive2) {
+    return false;
+  }
+  return lift$1(state, dispatch);
+};
+var liftEmptyBlock = () => ({ state, dispatch }) => {
+  return liftEmptyBlock$1(state, dispatch);
+};
+var liftListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return liftListItem$1(type)(state, dispatch);
+};
+var newlineInCode = () => ({ state, dispatch }) => {
+  return newlineInCode$1(state, dispatch);
+};
+function getSchemaTypeNameByName(name, schema) {
+  if (schema.nodes[name]) {
+    return "node";
+  }
+  if (schema.marks[name]) {
+    return "mark";
+  }
+  return null;
+}
+function deleteProps(obj, propOrProps) {
+  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
+  return Object.keys(obj).reduce((newObj, prop) => {
+    if (!props.includes(prop)) {
+      newObj[prop] = obj[prop];
+    }
+    return newObj;
+  }, {});
+}
+var resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
+  let nodeType = null;
+  let markType = null;
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === "string" ? typeOrName : typeOrName.name,
+    state.schema
+  );
+  if (!schemaType) {
+    return false;
+  }
+  if (schemaType === "node") {
+    nodeType = getNodeType(typeOrName, state.schema);
+  }
+  if (schemaType === "mark") {
+    markType = getMarkType(typeOrName, state.schema);
+  }
+  let canReset = false;
+  tr.selection.ranges.forEach((range) => {
+    state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+      if (nodeType && nodeType === node.type) {
+        canReset = true;
+        if (dispatch) {
+          tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
+        }
+      }
+      if (markType && node.marks.length) {
+        node.marks.forEach((mark) => {
+          if (markType === mark.type) {
+            canReset = true;
+            if (dispatch) {
+              tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
+            }
+          }
+        });
+      }
+    });
+  });
+  return canReset;
+};
+var scrollIntoView = () => ({ tr, dispatch }) => {
+  if (dispatch) {
+    tr.scrollIntoView();
+  }
+  return true;
+};
+var selectAll = () => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const selection = new AllSelection(tr.doc);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var selectNodeBackward = () => ({ state, dispatch }) => {
+  return selectNodeBackward$1(state, dispatch);
+};
+var selectNodeForward = () => ({ state, dispatch }) => {
+  return selectNodeForward$1(state, dispatch);
+};
+var selectParentNode = () => ({ state, dispatch }) => {
+  return selectParentNode$1(state, dispatch);
+};
+var selectTextblockEnd = () => ({ state, dispatch }) => {
+  return selectTextblockEnd$1(state, dispatch);
+};
+var selectTextblockStart = () => ({ state, dispatch }) => {
+  return selectTextblockStart$1(state, dispatch);
+};
+function createDocument(content, schema, parseOptions = {}, options = {}) {
+  return createNodeFromContent(content, schema, {
+    slice: false,
+    parseOptions,
+    errorOnInvalidContent: options.errorOnInvalidContent
+  });
+}
+var setContent = (content, { errorOnInvalidContent, emitUpdate = true, parseOptions = {} } = {}) => ({ editor, tr, dispatch, commands }) => {
+  const { doc } = tr;
+  if (parseOptions.preserveWhitespace !== "full") {
+    const document2 = createDocument(content, editor.schema, parseOptions, {
+      errorOnInvalidContent: errorOnInvalidContent != null ? errorOnInvalidContent : editor.options.enableContentCheck
+    });
+    if (dispatch) {
+      tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
+    }
+    return true;
+  }
+  if (dispatch) {
+    tr.setMeta("preventUpdate", !emitUpdate);
+  }
+  return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
+    parseOptions,
+    errorOnInvalidContent: errorOnInvalidContent != null ? errorOnInvalidContent : editor.options.enableContentCheck
+  });
+};
+function getMarkAttributes(state, typeOrName) {
+  const type = getMarkType(typeOrName, state.schema);
+  const { from, to, empty } = state.selection;
+  const marks = [];
+  if (empty) {
+    if (state.storedMarks) {
+      marks.push(...state.storedMarks);
+    }
+    marks.push(...state.selection.$head.marks());
+  } else {
+    state.doc.nodesBetween(from, to, (node) => {
+      marks.push(...node.marks);
+    });
+  }
+  const mark = marks.find((markItem) => markItem.type.name === type.name);
+  if (!mark) {
+    return {};
+  }
+  return { ...mark.attrs };
+}
+function combineTransactionSteps(oldDoc, transactions) {
+  const transform = new Transform(oldDoc);
+  transactions.forEach((transaction) => {
+    transaction.steps.forEach((step) => {
+      transform.step(step);
+    });
+  });
+  return transform;
+}
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i += 1) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs()) {
+      return type;
+    }
+  }
+  return null;
+}
+function findParentNodeClosestToPos($pos, predicate) {
+  for (let i = $pos.depth; i > 0; i -= 1) {
+    const node = $pos.node(i);
+    if (predicate(node)) {
+      return {
+        pos: i > 0 ? $pos.before(i) : 0,
+        start: $pos.start(i),
+        depth: i,
+        node
+      };
+    }
+  }
+}
+function findParentNode(predicate) {
+  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
+}
+function getExtensionField(extension, field, context) {
+  if (extension.config[field] === void 0 && extension.parent) {
+    return getExtensionField(extension.parent, field, context);
+  }
+  if (typeof extension.config[field] === "function") {
+    const value = extension.config[field].bind({
+      ...context,
+      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
+    });
+    return value;
+  }
+  return extension.config[field];
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function callOrReturn(value, context = void 0, ...props) {
+  if (isFunction(value)) {
+    if (context) {
+      return value.bind(context)(...props);
+    }
+    return value(...props);
+  }
+  return value;
+}
+function splitExtensions(extensions) {
+  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
+  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
+  const markExtensions = extensions.filter((extension) => extension.type === "mark");
+  return {
+    baseExtensions,
+    nodeExtensions,
+    markExtensions
+  };
+}
+function mergeAttributes(...objects) {
+  return objects.filter((item) => !!item).reduce((items, item) => {
+    const mergedAttributes = { ...items };
+    Object.entries(item).forEach(([key, value]) => {
+      const exists = mergedAttributes[key];
+      if (!exists) {
+        mergedAttributes[key] = value;
+        return;
+      }
+      if (key === "class") {
+        const valueClasses = value ? String(value).split(" ") : [];
+        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
+        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
+        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
+      } else if (key === "style") {
+        const newStyles = value ? value.split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+        const styleMap = /* @__PURE__ */ new Map();
+        existingStyles.forEach((style2) => {
+          const [property, val] = style2.split(":").map((part) => part.trim());
+          styleMap.set(property, val);
+        });
+        newStyles.forEach((style2) => {
+          const [property, val] = style2.split(":").map((part) => part.trim());
+          styleMap.set(property, val);
+        });
+        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
+      } else {
+        mergedAttributes[key] = value;
+      }
+    });
+    return mergedAttributes;
+  }, {});
+}
+function getTextBetween(startNode, range, options) {
+  const { from, to } = range;
+  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
+  let text = "";
+  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
+    var _a;
+    if (node.isBlock && pos > from) {
+      text += blockSeparator;
+    }
+    const textSerializer = textSerializers == null ? void 0 : textSerializers[node.type.name];
+    if (textSerializer) {
+      if (parent) {
+        text += textSerializer({
+          node,
+          pos,
+          parent,
+          index,
+          range
+        });
+      }
+      return false;
+    }
+    if (node.isText) {
+      text += (_a = node == null ? void 0 : node.text) == null ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
+    }
+  });
+  return text;
+}
+function getTextSerializersFromSchema(schema) {
+  return Object.fromEntries(
+    Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText])
+  );
+}
+function removeDuplicates(array, by = JSON.stringify) {
+  const seen = {};
+  return array.filter((item) => {
+    const key = by(item);
+    return Object.prototype.hasOwnProperty.call(seen, key) ? false : seen[key] = true;
+  });
+}
+function simplifyChangedRanges(changes) {
+  const uniqueChanges = removeDuplicates(changes);
+  return uniqueChanges.length === 1 ? uniqueChanges : uniqueChanges.filter((change, index) => {
+    const rest = uniqueChanges.filter((_, i) => i !== index);
+    return !rest.some((otherChange) => {
+      return change.oldRange.from >= otherChange.oldRange.from && change.oldRange.to <= otherChange.oldRange.to && change.newRange.from >= otherChange.newRange.from && change.newRange.to <= otherChange.newRange.to;
+    });
+  });
+}
+function getChangedRanges(transform) {
+  const { mapping, steps } = transform;
+  const changes = [];
+  mapping.maps.forEach((stepMap, index) => {
+    const ranges = [];
+    if (!stepMap.ranges.length) {
+      const { from, to } = steps[index];
+      if (from === void 0 || to === void 0) {
+        return;
+      }
+      ranges.push({ from, to });
+    } else {
+      stepMap.forEach((from, to) => {
+        ranges.push({ from, to });
+      });
+    }
+    ranges.forEach(({ from, to }) => {
+      const newStart = mapping.slice(index).map(from, -1);
+      const newEnd = mapping.slice(index).map(to);
+      const oldStart = mapping.invert().map(newStart, -1);
+      const oldEnd = mapping.invert().map(newEnd);
+      changes.push({
+        oldRange: {
+          from: oldStart,
+          to: oldEnd
+        },
+        newRange: {
+          from: newStart,
+          to: newEnd
+        }
+      });
+    });
+  });
+  return simplifyChangedRanges(changes);
+}
+function getSplittedAttributes(extensionAttributes, typeName, attributes) {
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([name]) => {
+      const extensionAttribute = extensionAttributes.find((item) => {
+        return item.type === typeName && item.name === name;
+      });
+      if (!extensionAttribute) {
+        return false;
+      }
+      return extensionAttribute.attribute.keepOnSplit;
+    })
+  );
+}
+function isMarkActive(state, typeOrName, attributes = {}) {
+  const { empty, ranges } = state.selection;
+  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
+  if (empty) {
+    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
+      if (!type) {
+        return true;
+      }
+      return type.name === mark.type.name;
+    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
+  }
+  let selectionRange = 0;
+  const markRanges = [];
+  ranges.forEach(({ $from, $to }) => {
+    const from = $from.pos;
+    const to = $to.pos;
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (!node.isText && !node.marks.length) {
+        return;
+      }
+      const relativeFrom = Math.max(from, pos);
+      const relativeTo = Math.min(to, pos + node.nodeSize);
+      const range2 = relativeTo - relativeFrom;
+      selectionRange += range2;
+      markRanges.push(
+        ...node.marks.map((mark) => ({
+          mark,
+          from: relativeFrom,
+          to: relativeTo
+        }))
+      );
+    });
+  });
+  if (selectionRange === 0) {
+    return false;
+  }
+  const matchedRange = markRanges.filter((markRange) => {
+    if (!type) {
+      return true;
+    }
+    return type.name === markRange.mark.type.name;
+  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+  const excludedRange = markRanges.filter((markRange) => {
+    if (!type) {
+      return true;
+    }
+    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
+  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
+  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
+  return range >= selectionRange;
+}
+function isList(name, extensions) {
+  const { nodeExtensions } = splitExtensions(extensions);
+  const extension = nodeExtensions.find((item) => item.name === name);
+  if (!extension) {
+    return false;
+  }
+  const context = {
+    name: extension.name,
+    options: extension.options,
+    storage: extension.storage
+  };
+  const group = callOrReturn(getExtensionField(extension, "group", context));
+  if (typeof group !== "string") {
+    return false;
+  }
+  return group.split(" ").includes("list");
+}
+function isNodeEmpty(node, {
+  checkChildren = true,
+  ignoreWhitespace = false
+} = {}) {
+  var _a;
+  if (ignoreWhitespace) {
+    if (node.type.name === "hardBreak") {
+      return true;
+    }
+    if (node.isText) {
+      return /^\s*$/m.test((_a = node.text) != null ? _a : "");
+    }
+  }
+  if (node.isText) {
+    return !node.text;
+  }
+  if (node.isAtom || node.isLeaf) {
+    return false;
+  }
+  if (node.content.childCount === 0) {
+    return true;
+  }
+  if (checkChildren) {
+    let isContentEmpty = true;
+    node.content.forEach((childNode) => {
+      if (isContentEmpty === false) {
+        return;
+      }
+      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
+        isContentEmpty = false;
+      }
+    });
+    return isContentEmpty;
+  }
+  return false;
+}
+function canSetMark(state, tr, newMarkType) {
+  var _a;
+  const { selection } = tr;
+  let cursor = null;
+  if (isTextSelection(selection)) {
+    cursor = selection.$cursor;
+  }
+  if (cursor) {
+    const currentMarks = (_a = state.storedMarks) != null ? _a : cursor.marks();
+    const parentAllowsMarkType = cursor.parent.type.allowsMarkType(newMarkType);
+    return parentAllowsMarkType && (!!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType)));
+  }
+  const { ranges } = selection;
+  return ranges.some(({ $from, $to }) => {
+    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
+    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
+      if (someNodeSupportsMark) {
+        return false;
+      }
+      if (node.isInline) {
+        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
+        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
+        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
+      }
+      return !someNodeSupportsMark;
+    });
+    return someNodeSupportsMark;
+  });
+}
+var setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  const { selection } = tr;
+  const { empty, ranges } = selection;
+  const type = getMarkType(typeOrName, state.schema);
+  if (dispatch) {
+    if (empty) {
+      const oldAttributes = getMarkAttributes(state, type);
+      tr.addStoredMark(
+        type.create({
+          ...oldAttributes,
+          ...attributes
+        })
+      );
+    } else {
+      ranges.forEach((range) => {
+        const from = range.$from.pos;
+        const to = range.$to.pos;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          const trimmedFrom = Math.max(pos, from);
+          const trimmedTo = Math.min(pos + node.nodeSize, to);
+          const someHasMark = node.marks.find((mark) => mark.type === type);
+          if (someHasMark) {
+            node.marks.forEach((mark) => {
+              if (type === mark.type) {
+                tr.addMark(
+                  trimmedFrom,
+                  trimmedTo,
+                  type.create({
+                    ...mark.attrs,
+                    ...attributes
+                  })
+                );
+              }
+            });
+          } else {
+            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
+          }
+        });
+      });
+    }
+  }
+  return canSetMark(state, tr, type);
+};
+var setMeta = (key, value) => ({ tr }) => {
+  tr.setMeta(key, value);
+  return true;
+};
+var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  let attributesToCopy;
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    attributesToCopy = state.selection.$anchor.parent.attrs;
+  }
+  if (!type.isTextblock) {
+    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
+    return false;
+  }
+  return chain().command(({ commands }) => {
+    const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
+    if (canSetBlock) {
+      return true;
+    }
+    return commands.clearNodes();
+  }).command(({ state: updatedState }) => {
+    return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
+  }).run();
+};
+var setNodeSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const from = minMax(position, 0, doc.content.size);
+    const selection = NodeSelection.create(doc, from);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var setTextDirection = (direction, position) => ({ tr, state, dispatch }) => {
+  const { selection } = state;
+  let from;
+  let to;
+  if (typeof position === "number") {
+    from = position;
+    to = position;
+  } else if (position && "from" in position && "to" in position) {
+    from = position.from;
+    to = position.to;
+  } else {
+    from = selection.from;
+    to = selection.to;
+  }
+  if (dispatch) {
+    tr.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isText) {
+        return;
+      }
+      tr.setNodeMarkup(pos, void 0, {
+        ...node.attrs,
+        dir: direction
+      });
+    });
+  }
+  return true;
+};
+var setTextSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
+    const minPos = TextSelection.atStart(doc).from;
+    const maxPos = TextSelection.atEnd(doc).to;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return sinkListItem$1(type)(state, dispatch);
+};
+function ensureMarks(state, splittableMarks) {
+  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
+  if (marks) {
+    const filteredMarks = marks.filter((mark) => splittableMarks == null ? void 0 : splittableMarks.includes(mark.type.name));
+    state.tr.ensureMarks(filteredMarks);
+  }
+}
+var splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
+  const { selection, doc } = tr;
+  const { $from, $to } = selection;
+  const extensionAttributes = editor.extensionManager.attributes;
+  const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+  if (selection instanceof NodeSelection && selection.node.isBlock) {
+    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+      return false;
+    }
+    if (dispatch) {
+      if (keepMarks) {
+        ensureMarks(state, editor.extensionManager.splittableMarks);
+      }
+      tr.split($from.pos).scrollIntoView();
+    }
+    return true;
+  }
+  if (!$from.parent.isBlock) {
+    return false;
+  }
+  const atEnd = $to.parentOffset === $to.parent.content.size;
+  const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
+  let types = atEnd && deflt ? [
+    {
+      type: deflt,
+      attrs: newAttributes
+    }
+  ] : void 0;
+  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
+  if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
+    can = true;
+    types = deflt ? [
+      {
+        type: deflt,
+        attrs: newAttributes
+      }
+    ] : void 0;
+  }
+  if (dispatch) {
+    if (can) {
+      if (selection instanceof TextSelection) {
+        tr.deleteSelection();
+      }
+      tr.split(tr.mapping.map($from.pos), 1, types);
+      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
+        const first2 = tr.mapping.map($from.before());
+        const $first = tr.doc.resolve(first2);
+        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+        }
+      }
+    }
+    if (keepMarks) {
+      ensureMarks(state, editor.extensionManager.splittableMarks);
+    }
+    tr.scrollIntoView();
+  }
+  return can;
+};
+var splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
+  var _a;
+  const type = getNodeType(typeOrName, state.schema);
+  const { $from, $to } = state.selection;
+  const node = state.selection.node;
+  if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
+    return false;
+  }
+  const grandParent = $from.node(-1);
+  if (grandParent.type !== type) {
+    return false;
+  }
+  const extensionAttributes = editor.extensionManager.attributes;
+  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
+    if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
+      return false;
+    }
+    if (dispatch) {
+      let wrap = Fragment.empty;
+      const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
+        wrap = Fragment.from($from.node(d).copy(wrap));
+      }
+      const depthAfter = (
+        // eslint-disable-next-line no-nested-ternary
+        $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3
+      );
+      const newNextTypeAttributes2 = {
+        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+        ...overrideAttrs
+      };
+      const nextType2 = ((_a = type.contentMatch.defaultType) == null ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
+      wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType2) || void 0));
+      const start = $from.before($from.depth - (depthBefore - 1));
+      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+      let sel = -1;
+      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+        if (sel > -1) {
+          return false;
+        }
+        if (n.isTextblock && n.content.size === 0) {
+          sel = pos + 1;
+        }
+      });
+      if (sel > -1) {
+        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
+      }
+      tr.scrollIntoView();
+    }
+    return true;
+  }
+  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
+  const newTypeAttributes = {
+    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+    ...overrideAttrs
+  };
+  const newNextTypeAttributes = {
+    ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+    ...overrideAttrs
+  };
+  tr.delete($from.pos, $to.pos);
+  const types = nextType ? [
+    { type, attrs: newTypeAttributes },
+    { type: nextType, attrs: newNextTypeAttributes }
+  ] : [{ type, attrs: newTypeAttributes }];
+  if (!canSplit(tr.doc, $from.pos, 2)) {
+    return false;
+  }
+  if (dispatch) {
+    const { selection, storedMarks } = state;
+    const { splittableMarks } = editor.extensionManager;
+    const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+    tr.split($from.pos, 2, types).scrollIntoView();
+    if (!marks || !dispatch) {
+      return true;
+    }
+    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+    tr.ensureMarks(filteredMarks);
+  }
+  return true;
+};
+var joinListBackwards = (tr, listType) => {
+  const list = findParentNode((node) => node.type === listType)(tr.selection);
+  if (!list) {
+    return true;
+  }
+  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
+  if (before === void 0) {
+    return true;
+  }
+  const nodeBefore = tr.doc.nodeAt(before);
+  const canJoinBackwards = list.node.type === (nodeBefore == null ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
+  if (!canJoinBackwards) {
+    return true;
+  }
+  tr.join(list.pos);
+  return true;
+};
+var joinListForwards = (tr, listType) => {
+  const list = findParentNode((node) => node.type === listType)(tr.selection);
+  if (!list) {
+    return true;
+  }
+  const after = tr.doc.resolve(list.start).after(list.depth);
+  if (after === void 0) {
+    return true;
+  }
+  const nodeAfter = tr.doc.nodeAt(after);
+  const canJoinForwards = list.node.type === (nodeAfter == null ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
+  if (!canJoinForwards) {
+    return true;
+  }
+  tr.join(after);
+  return true;
+};
+var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands, can }) => {
+  const { extensions, splittableMarks } = editor.extensionManager;
+  const listType = getNodeType(listTypeOrName, state.schema);
+  const itemType = getNodeType(itemTypeOrName, state.schema);
+  const { selection, storedMarks } = state;
+  const { $from, $to } = selection;
+  const range = $from.blockRange($to);
+  const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+  if (!range) {
+    return false;
+  }
+  const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
+  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
+    if (parentList.node.type === listType) {
+      return commands.liftListItem(itemType);
+    }
+    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+      return chain().command(() => {
+        tr.setNodeMarkup(parentList.pos, listType);
+        return true;
+      }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+    }
+  }
+  if (!keepMarks || !marks || !dispatch) {
+    return chain().command(() => {
+      const canWrapInList = can().wrapInList(listType, attributes);
+      if (canWrapInList) {
+        return true;
+      }
+      return commands.clearNodes();
+    }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+  }
+  return chain().command(() => {
+    const canWrapInList = can().wrapInList(listType, attributes);
+    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+    tr.ensureMarks(filteredMarks);
+    if (canWrapInList) {
+      return true;
+    }
+    return commands.clearNodes();
+  }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+};
+var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
+  const { extendEmptyMarkRange = false } = options;
+  const type = getMarkType(typeOrName, state.schema);
+  const isActive2 = isMarkActive(state, type, attributes);
+  if (isActive2) {
+    return commands.unsetMark(type, { extendEmptyMarkRange });
+  }
+  return commands.setMark(type, attributes);
+};
+var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const toggleType = getNodeType(toggleTypeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  let attributesToCopy;
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    attributesToCopy = state.selection.$anchor.parent.attrs;
+  }
+  if (isActive2) {
+    return commands.setNode(toggleType, attributesToCopy);
+  }
+  return commands.setNode(type, { ...attributesToCopy, ...attributes });
+};
+var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (isActive2) {
+    return commands.lift(type);
+  }
+  return commands.wrapIn(type, attributes);
+};
+var undoInputRule = () => ({ state, dispatch }) => {
+  const plugins = state.plugins;
+  for (let i = 0; i < plugins.length; i += 1) {
+    const plugin = plugins[i];
+    let undoable;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        const tr = state.tr;
+        const toUndo = undoable.transform;
+        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+        }
+        if (undoable.text) {
+          const marks = tr.doc.resolve(undoable.from).marks();
+          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+        } else {
+          tr.delete(undoable.from, undoable.to);
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var unsetAllMarks = () => ({ tr, dispatch }) => {
+  const { selection } = tr;
+  const { empty, ranges } = selection;
+  if (empty) {
+    return true;
+  }
+  if (dispatch) {
+    ranges.forEach((range) => {
+      tr.removeMark(range.$from.pos, range.$to.pos);
+    });
+  }
+  return true;
+};
+var unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
+  var _a;
+  const { extendEmptyMarkRange = false } = options;
+  const { selection } = tr;
+  const type = getMarkType(typeOrName, state.schema);
+  const { $from, empty, ranges } = selection;
+  if (!dispatch) {
+    return true;
+  }
+  if (empty && extendEmptyMarkRange) {
+    let { from, to } = selection;
+    const attrs = (_a = $from.marks().find((mark) => mark.type === type)) == null ? void 0 : _a.attrs;
+    const range = getMarkRange($from, type, attrs);
+    if (range) {
+      from = range.from;
+      to = range.to;
+    }
+    tr.removeMark(from, to, type);
+  } else {
+    ranges.forEach((range) => {
+      tr.removeMark(range.$from.pos, range.$to.pos, type);
+    });
+  }
+  tr.removeStoredMark(type);
+  return true;
+};
+var unsetTextDirection = (position) => ({ tr, state, dispatch }) => {
+  const { selection } = state;
+  let from;
+  let to;
+  if (typeof position === "number") {
+    from = position;
+    to = position;
+  } else if (position && "from" in position && "to" in position) {
+    from = position.from;
+    to = position.to;
+  } else {
+    from = selection.from;
+    to = selection.to;
+  }
+  if (dispatch) {
+    tr.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isText) {
+        return;
+      }
+      const newAttrs = { ...node.attrs };
+      delete newAttrs.dir;
+      tr.setNodeMarkup(pos, void 0, newAttrs);
+    });
+  }
+  return true;
+};
+var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  let nodeType = null;
+  let markType = null;
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === "string" ? typeOrName : typeOrName.name,
+    state.schema
+  );
+  if (!schemaType) {
+    return false;
+  }
+  if (schemaType === "node") {
+    nodeType = getNodeType(typeOrName, state.schema);
+  }
+  if (schemaType === "mark") {
+    markType = getMarkType(typeOrName, state.schema);
+  }
+  let canUpdate = false;
+  tr.selection.ranges.forEach((range) => {
+    const from = range.$from.pos;
+    const to = range.$to.pos;
+    let lastPos;
+    let lastNode;
+    let trimmedFrom;
+    let trimmedTo;
+    if (tr.selection.empty) {
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (nodeType && nodeType === node.type) {
+          canUpdate = true;
+          trimmedFrom = Math.max(pos, from);
+          trimmedTo = Math.min(pos + node.nodeSize, to);
+          lastPos = pos;
+          lastNode = node;
+        }
+      });
+    } else {
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (pos < from && nodeType && nodeType === node.type) {
+          canUpdate = true;
+          trimmedFrom = Math.max(pos, from);
+          trimmedTo = Math.min(pos + node.nodeSize, to);
+          lastPos = pos;
+          lastNode = node;
+        }
+        if (pos >= from && pos <= to) {
+          if (nodeType && nodeType === node.type) {
+            canUpdate = true;
+            if (dispatch) {
+              tr.setNodeMarkup(pos, void 0, {
+                ...node.attrs,
+                ...attributes
+              });
+            }
+          }
+          if (markType && node.marks.length) {
+            node.marks.forEach((mark) => {
+              if (markType === mark.type) {
+                canUpdate = true;
+                if (dispatch) {
+                  const trimmedFrom2 = Math.max(pos, from);
+                  const trimmedTo2 = Math.min(pos + node.nodeSize, to);
+                  tr.addMark(
+                    trimmedFrom2,
+                    trimmedTo2,
+                    markType.create({
+                      ...mark.attrs,
+                      ...attributes
+                    })
+                  );
+                }
+              }
+            });
+          }
+        }
+      });
+    }
+    if (lastNode) {
+      if (lastPos !== void 0 && dispatch) {
+        tr.setNodeMarkup(lastPos, void 0, {
+          ...lastNode.attrs,
+          ...attributes
+        });
+      }
+      if (markType && lastNode.marks.length) {
+        lastNode.marks.forEach((mark) => {
+          if (markType === mark.type && dispatch) {
+            tr.addMark(
+              trimmedFrom,
+              trimmedTo,
+              markType.create({
+                ...mark.attrs,
+                ...attributes
+              })
+            );
+          }
+        });
+      }
+    }
+  });
+  return canUpdate;
+};
+var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return wrapIn$1(type, attributes)(state, dispatch);
+};
+var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return wrapInList$1(type, attributes)(state, dispatch);
+};
+function getType(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+function isPlainObject(value) {
+  if (getType(value) !== "Object") {
+    return false;
+  }
+  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
+}
+function mergeDeep(target, source) {
+  const output = { ...target };
+  if (isPlainObject(target) && isPlainObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
+        output[key] = mergeDeep(target[key], source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    });
+  }
+  return output;
+}
+var Extendable = class {
+  constructor(config = {}) {
+    this.type = "extendable";
+    this.parent = null;
+    this.child = null;
+    this.name = "";
+    this.config = {
+      name: this.name
+    };
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    this.name = this.config.name;
+  }
+  get options() {
+    return {
+      ...callOrReturn(
+        getExtensionField(this, "addOptions", {
+          name: this.name
+        })
+      ) || {}
+    };
+  }
+  get storage() {
+    return {
+      ...callOrReturn(
+        getExtensionField(this, "addStorage", {
+          name: this.name,
+          options: this.options
+        })
+      ) || {}
+    };
+  }
+  configure(options = {}) {
+    const extension = this.extend({
+      ...this.config,
+      addOptions: () => {
+        return mergeDeep(this.options, options);
+      }
+    });
+    extension.name = this.name;
+    extension.parent = this.parent;
+    return extension;
+  }
+  extend(extendedConfig = {}) {
+    const extension = new this.constructor({ ...this.config, ...extendedConfig });
+    extension.parent = this;
+    this.child = extension;
+    extension.name = "name" in extendedConfig ? extendedConfig.name : extension.parent.name;
+    return extension;
+  }
+};
+var extensions_exports = {};
+__export(extensions_exports, {
+  ClipboardTextSerializer: () => ClipboardTextSerializer,
+  Commands: () => Commands,
+  Delete: () => Delete,
+  Drop: () => Drop,
+  Editable: () => Editable,
+  FocusEvents: () => FocusEvents,
+  Keymap: () => Keymap,
+  Paste: () => Paste,
+  Tabindex: () => Tabindex,
+  TextDirection: () => TextDirection,
+  focusEventsPluginKey: () => focusEventsPluginKey
+});
+var Extension = class _Extension extends Extendable {
+  constructor() {
+    super(...arguments);
+    this.type = "extension";
+  }
+  /**
+   * Create a new Extension instance
+   * @param config - Extension configuration object or a function that returns a configuration object
+   */
+  static create(config = {}) {
+    const resolvedConfig = typeof config === "function" ? config() : config;
+    return new _Extension(resolvedConfig);
+  }
+  configure(options) {
+    return super.configure(options);
+  }
+  extend(extendedConfig) {
+    const resolvedConfig = typeof extendedConfig === "function" ? extendedConfig() : extendedConfig;
+    return super.extend(resolvedConfig);
+  }
+};
+var ClipboardTextSerializer = Extension.create({
+  name: "clipboardTextSerializer",
+  addOptions() {
+    return {
+      blockSeparator: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("clipboardTextSerializer"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor } = this;
+            const { state, schema } = editor;
+            const { doc, selection } = state;
+            const { ranges } = selection;
+            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
+            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
+            const textSerializers = getTextSerializersFromSchema(schema);
+            const range = { from, to };
+            return getTextBetween(doc, range, {
+              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
+              textSerializers
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Commands = Extension.create({
+  name: "commands",
+  addCommands() {
+    return {
+      ...commands_exports
+    };
+  }
+});
+var Delete = Extension.create({
+  name: "delete",
+  onUpdate({ transaction, appendedTransactions }) {
+    var _a, _b, _c;
+    const callback = () => {
+      var _a2, _b2, _c2, _d;
+      if ((_d = (_c2 = (_b2 = (_a2 = this.editor.options.coreExtensionOptions) == null ? void 0 : _a2.delete) == null ? void 0 : _b2.filterTransaction) == null ? void 0 : _c2.call(_b2, transaction)) != null ? _d : transaction.getMeta("y-sync$")) {
+        return;
+      }
+      const nextTransaction = combineTransactionSteps(transaction.before, [transaction, ...appendedTransactions]);
+      const changes = getChangedRanges(nextTransaction);
+      changes.forEach((change) => {
+        if (nextTransaction.mapping.mapResult(change.oldRange.from).deletedAfter && nextTransaction.mapping.mapResult(change.oldRange.to).deletedBefore) {
+          nextTransaction.before.nodesBetween(change.oldRange.from, change.oldRange.to, (node, from) => {
+            const to = from + node.nodeSize - 2;
+            const isFullyWithinRange = change.oldRange.from <= from && to <= change.oldRange.to;
+            this.editor.emit("delete", {
+              type: "node",
+              node,
+              from,
+              to,
+              newFrom: nextTransaction.mapping.map(from),
+              newTo: nextTransaction.mapping.map(to),
+              deletedRange: change.oldRange,
+              newRange: change.newRange,
+              partial: !isFullyWithinRange,
+              editor: this.editor,
+              transaction,
+              combinedTransform: nextTransaction
+            });
+          });
+        }
+      });
+      const mapping = nextTransaction.mapping;
+      nextTransaction.steps.forEach((step, index) => {
+        var _a3, _b3;
+        if (step instanceof RemoveMarkStep) {
+          const newStart = mapping.slice(index).map(step.from, -1);
+          const newEnd = mapping.slice(index).map(step.to);
+          const oldStart = mapping.invert().map(newStart, -1);
+          const oldEnd = mapping.invert().map(newEnd);
+          const foundBeforeMark = (_a3 = nextTransaction.doc.nodeAt(newStart - 1)) == null ? void 0 : _a3.marks.some((mark) => mark.eq(step.mark));
+          const foundAfterMark = (_b3 = nextTransaction.doc.nodeAt(newEnd)) == null ? void 0 : _b3.marks.some((mark) => mark.eq(step.mark));
+          this.editor.emit("delete", {
+            type: "mark",
+            mark: step.mark,
+            from: step.from,
+            to: step.to,
+            deletedRange: {
+              from: oldStart,
+              to: oldEnd
+            },
+            newRange: {
+              from: newStart,
+              to: newEnd
+            },
+            partial: Boolean(foundAfterMark || foundBeforeMark),
+            editor: this.editor,
+            transaction,
+            combinedTransform: nextTransaction
+          });
+        }
+      });
+    };
+    if ((_c = (_b = (_a = this.editor.options.coreExtensionOptions) == null ? void 0 : _a.delete) == null ? void 0 : _b.async) != null ? _c : true) {
+      setTimeout(callback, 0);
+    } else {
+      callback();
+    }
+  }
+});
+var Drop = Extension.create({
+  name: "drop",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("tiptapDrop"),
+        props: {
+          handleDrop: (_, e, slice, moved) => {
+            this.editor.emit("drop", {
+              editor: this.editor,
+              event: e,
+              slice,
+              moved
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Editable = Extension.create({
+  name: "editable",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("editable"),
+        props: {
+          editable: () => this.editor.options.editable
+        }
+      })
+    ];
+  }
+});
+var focusEventsPluginKey = new PluginKey("focusEvents");
+var FocusEvents = Extension.create({
+  name: "focusEvents",
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      new Plugin({
+        key: focusEventsPluginKey,
+        props: {
+          handleDOMEvents: {
+            focus: (view, event) => {
+              editor.isFocused = true;
+              const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
+              view.dispatch(transaction);
+              return false;
+            },
+            blur: (view, event) => {
+              editor.isFocused = false;
+              const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
+              view.dispatch(transaction);
+              return false;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+var Keymap = Extension.create({
+  name: "keymap",
+  addKeyboardShortcuts() {
+    const handleBackspace = () => this.editor.commands.first(({ commands }) => [
+      () => commands.undoInputRule(),
+      // maybe convert first text block node to default node
+      () => commands.command(({ tr }) => {
+        const { selection, doc } = tr;
+        const { empty, $anchor } = selection;
+        const { pos, parent } = $anchor;
+        const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
+        const parentIsIsolating = $parentPos.parent.type.spec.isolating;
+        const parentPos = $anchor.pos - $anchor.parentOffset;
+        const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : Selection.atStart(doc).from === pos;
+        if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
+          return false;
+        }
+        return commands.clearNodes();
+      }),
+      () => commands.deleteSelection(),
+      () => commands.joinBackward(),
+      () => commands.selectNodeBackward()
+    ]);
+    const handleDelete = () => this.editor.commands.first(({ commands }) => [
+      () => commands.deleteSelection(),
+      () => commands.deleteCurrentNode(),
+      () => commands.joinForward(),
+      () => commands.selectNodeForward()
+    ]);
+    const handleEnter = () => this.editor.commands.first(({ commands }) => [
+      () => commands.newlineInCode(),
+      () => commands.createParagraphNear(),
+      () => commands.liftEmptyBlock(),
+      () => commands.splitBlock()
+    ]);
+    const baseKeymap = {
+      Enter: handleEnter,
+      "Mod-Enter": () => this.editor.commands.exitCode(),
+      Backspace: handleBackspace,
+      "Mod-Backspace": handleBackspace,
+      "Shift-Backspace": handleBackspace,
+      Delete: handleDelete,
+      "Mod-Delete": handleDelete,
+      "Mod-a": () => this.editor.commands.selectAll()
+    };
+    const pcKeymap = {
+      ...baseKeymap
+    };
+    const macKeymap = {
+      ...baseKeymap,
+      "Ctrl-h": handleBackspace,
+      "Alt-Backspace": handleBackspace,
+      "Ctrl-d": handleDelete,
+      "Ctrl-Alt-Backspace": handleDelete,
+      "Alt-Delete": handleDelete,
+      "Alt-d": handleDelete,
+      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
+      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
+    };
+    if (isiOS() || isMacOS()) {
+      return macKeymap;
+    }
+    return pcKeymap;
+  },
+  addProseMirrorPlugins() {
+    return [
+      // With this plugin we check if the whole document was selected and deleted.
+      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
+      // to a paragraph if necessary.
+      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
+      // with many other commands.
+      new Plugin({
+        key: new PluginKey("clearDocument"),
+        appendTransaction: (transactions, oldState, newState) => {
+          if (transactions.some((tr2) => tr2.getMeta("composition"))) {
+            return;
+          }
+          const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
+          const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
+          if (!docChanges || ignoreTr) {
+            return;
+          }
+          const { empty, from, to } = oldState.selection;
+          const allFrom = Selection.atStart(oldState.doc).from;
+          const allEnd = Selection.atEnd(oldState.doc).to;
+          const allWasSelected = from === allFrom && to === allEnd;
+          if (empty || !allWasSelected) {
+            return;
+          }
+          const isEmpty = isNodeEmpty(newState.doc);
+          if (!isEmpty) {
+            return;
+          }
+          const tr = newState.tr;
+          const state = createChainableState({
+            state: newState,
+            transaction: tr
+          });
+          const { commands } = new CommandManager({
+            editor: this.editor,
+            state
+          });
+          commands.clearNodes();
+          if (!tr.steps.length) {
+            return;
+          }
+          return tr;
+        }
+      })
+    ];
+  }
+});
+var Paste = Extension.create({
+  name: "paste",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("tiptapPaste"),
+        props: {
+          handlePaste: (_view, e, slice) => {
+            this.editor.emit("paste", {
+              editor: this.editor,
+              event: e,
+              slice
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Tabindex = Extension.create({
+  name: "tabindex",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("tabindex"),
+        props: {
+          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
+        }
+      })
+    ];
+  }
+});
+var TextDirection = Extension.create({
+  name: "textDirection",
+  addOptions() {
+    return {
+      direction: void 0
+    };
+  },
+  addGlobalAttributes() {
+    if (!this.options.direction) {
+      return [];
+    }
+    const { nodeExtensions } = splitExtensions(this.extensions);
+    return [
+      {
+        types: nodeExtensions.filter((extension) => extension.name !== "text").map((extension) => extension.name),
+        attributes: {
+          dir: {
+            default: this.options.direction,
+            parseHTML: (element) => {
+              const dir = element.getAttribute("dir");
+              if (dir && (dir === "ltr" || dir === "rtl" || dir === "auto")) {
+                return dir;
+              }
+              return this.options.direction;
+            },
+            renderHTML: (attributes) => {
+              if (!attributes.dir) {
+                return {};
+              }
+              return {
+                dir: attributes.dir
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("textDirection"),
+        props: {
+          attributes: () => {
+            const direction = this.options.direction;
+            if (!direction) {
+              return {};
+            }
+            return {
+              dir: direction
+            };
+          }
+        }
+      })
+    ];
+  }
+});
+var markdown_exports = {};
+__export(markdown_exports, {
+  createAtomBlockMarkdownSpec: () => createAtomBlockMarkdownSpec,
+  createBlockMarkdownSpec: () => createBlockMarkdownSpec,
+  createInlineMarkdownSpec: () => createInlineMarkdownSpec,
+  parseAttributes: () => parseAttributes,
+  parseIndentedBlocks: () => parseIndentedBlocks,
+  renderNestedMarkdownContent: () => renderNestedMarkdownContent,
+  serializeAttributes: () => serializeAttributes
+});
+function parseAttributes(attrString) {
+  if (!(attrString == null ? void 0 : attrString.trim())) {
+    return {};
+  }
+  const attributes = {};
+  const quotedStrings = [];
+  const tempString = attrString.replace(/["']([^"']*)["']/g, (match) => {
+    quotedStrings.push(match);
+    return `__QUOTED_${quotedStrings.length - 1}__`;
+  });
+  const classMatches = tempString.match(/(?:^|\s)\.([a-zA-Z][\w-]*)/g);
+  if (classMatches) {
+    const classes = classMatches.map((match) => match.trim().slice(1));
+    attributes.class = classes.join(" ");
+  }
+  const idMatch = tempString.match(/(?:^|\s)#([a-zA-Z][\w-]*)/);
+  if (idMatch) {
+    attributes.id = idMatch[1];
+  }
+  const kvRegex = /([a-zA-Z][\w-]*)\s*=\s*(__QUOTED_\d+__)/g;
+  const kvMatches = Array.from(tempString.matchAll(kvRegex));
+  kvMatches.forEach(([, key, quotedRef]) => {
+    var _a;
+    const quotedIndex = parseInt(((_a = quotedRef.match(/__QUOTED_(\d+)__/)) == null ? void 0 : _a[1]) || "0", 10);
+    const quotedValue = quotedStrings[quotedIndex];
+    if (quotedValue) {
+      attributes[key] = quotedValue.slice(1, -1);
+    }
+  });
+  const cleanString = tempString.replace(/(?:^|\s)\.([a-zA-Z][\w-]*)/g, "").replace(/(?:^|\s)#([a-zA-Z][\w-]*)/g, "").replace(/([a-zA-Z][\w-]*)\s*=\s*__QUOTED_\d+__/g, "").trim();
+  if (cleanString) {
+    const booleanAttrs = cleanString.split(/\s+/).filter(Boolean);
+    booleanAttrs.forEach((attr) => {
+      if (attr.match(/^[a-zA-Z][\w-]*$/)) {
+        attributes[attr] = true;
+      }
+    });
+  }
+  return attributes;
+}
+function serializeAttributes(attributes) {
+  if (!attributes || Object.keys(attributes).length === 0) {
+    return "";
+  }
+  const parts = [];
+  if (attributes.class) {
+    const classes = String(attributes.class).split(/\s+/).filter(Boolean);
+    classes.forEach((cls) => parts.push(`.${cls}`));
+  }
+  if (attributes.id) {
+    parts.push(`#${attributes.id}`);
+  }
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (key === "class" || key === "id") {
+      return;
+    }
+    if (value === true) {
+      parts.push(key);
+    } else if (value !== false && value != null) {
+      parts.push(`${key}="${String(value)}"`);
+    }
+  });
+  return parts.join(" ");
+}
+function createAtomBlockMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: markdownName,
+    parseAttributes: parseAttributes2 = parseAttributes,
+    serializeAttributes: serializeAttributes2 = serializeAttributes,
+    defaultAttributes = {},
+    requiredAttributes = [],
+    allowedAttributes
+  } = options;
+  const blockName = markdownName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((key) => {
+      if (key in attrs) {
+        filtered[key] = attrs[key];
+      }
+    });
+    return filtered;
+  };
+  return {
+    parseMarkdown: (token, h2) => {
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      return h2.createNode(nodeName, attrs, []);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "block",
+      start(src) {
+        var _a;
+        const regex = new RegExp(`^:::${blockName}(?:\\s|$)`, "m");
+        const index = (_a = src.match(regex)) == null ? void 0 : _a.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, _lexer) {
+        const regex = new RegExp(`^:::${blockName}(?:\\s+\\{([^}]*)\\})?\\s*:::(?:\\n|$)`);
+        const match = src.match(regex);
+        if (!match) {
+          return void 0;
+        }
+        const attrString = match[1] || "";
+        const attributes = parseAttributes2(attrString);
+        const missingRequired = requiredAttributes.find((required) => !(required in attributes));
+        if (missingRequired) {
+          return void 0;
+        }
+        return {
+          type: nodeName,
+          raw: match[0],
+          attributes
+        };
+      }
+    },
+    renderMarkdown: (node) => {
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` {${attrs}}` : "";
+      return `:::${blockName}${attrString} :::`;
+    }
+  };
+}
+function createBlockMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: markdownName,
+    getContent,
+    parseAttributes: parseAttributes2 = parseAttributes,
+    serializeAttributes: serializeAttributes2 = serializeAttributes,
+    defaultAttributes = {},
+    content = "block",
+    allowedAttributes
+  } = options;
+  const blockName = markdownName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((key) => {
+      if (key in attrs) {
+        filtered[key] = attrs[key];
+      }
+    });
+    return filtered;
+  };
+  return {
+    parseMarkdown: (token, h2) => {
+      let nodeContent;
+      if (getContent) {
+        const contentResult = getContent(token);
+        nodeContent = typeof contentResult === "string" ? [{ type: "text", text: contentResult }] : contentResult;
+      } else if (content === "block") {
+        nodeContent = h2.parseChildren(token.tokens || []);
+      } else {
+        nodeContent = h2.parseInline(token.tokens || []);
+      }
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      return h2.createNode(nodeName, attrs, nodeContent);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "block",
+      start(src) {
+        var _a;
+        const regex = new RegExp(`^:::${blockName}`, "m");
+        const index = (_a = src.match(regex)) == null ? void 0 : _a.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, lexer) {
+        var _a;
+        const openingRegex = new RegExp(`^:::${blockName}(?:\\s+\\{([^}]*)\\})?\\s*\\n`);
+        const openingMatch = src.match(openingRegex);
+        if (!openingMatch) {
+          return void 0;
+        }
+        const [openingTag, attrString = ""] = openingMatch;
+        const attributes = parseAttributes2(attrString);
+        let level = 1;
+        const position = openingTag.length;
+        let matchedContent = "";
+        const blockPattern = /^:::([\w-]*)(\s.*)?/gm;
+        const remaining = src.slice(position);
+        blockPattern.lastIndex = 0;
+        for (; ; ) {
+          const match = blockPattern.exec(remaining);
+          if (match === null) {
+            break;
+          }
+          const matchPos = match.index;
+          const blockType = match[1];
+          if ((_a = match[2]) == null ? void 0 : _a.endsWith(":::")) {
+            continue;
+          }
+          if (blockType) {
+            level += 1;
+          } else {
+            level -= 1;
+            if (level === 0) {
+              const rawContent = remaining.slice(0, matchPos);
+              matchedContent = rawContent.trim();
+              const fullMatch = src.slice(0, position + matchPos + match[0].length);
+              let contentTokens = [];
+              if (matchedContent) {
+                if (content === "block") {
+                  contentTokens = lexer.blockTokens(rawContent);
+                  contentTokens.forEach((token) => {
+                    if (token.text && (!token.tokens || token.tokens.length === 0)) {
+                      token.tokens = lexer.inlineTokens(token.text);
+                    }
+                  });
+                  while (contentTokens.length > 0) {
+                    const lastToken = contentTokens[contentTokens.length - 1];
+                    if (lastToken.type === "paragraph" && (!lastToken.text || lastToken.text.trim() === "")) {
+                      contentTokens.pop();
+                    } else {
+                      break;
+                    }
+                  }
+                } else {
+                  contentTokens = lexer.inlineTokens(matchedContent);
+                }
+              }
+              return {
+                type: nodeName,
+                raw: fullMatch,
+                attributes,
+                content: matchedContent,
+                tokens: contentTokens
+              };
+            }
+          }
+        }
+        return void 0;
+      }
+    },
+    renderMarkdown: (node, h2) => {
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` {${attrs}}` : "";
+      const renderedContent = h2.renderChildren(node.content || [], "\n\n");
+      return `:::${blockName}${attrString}
+
+${renderedContent}
+
+:::`;
+    }
+  };
+}
+function parseShortcodeAttributes(attrString) {
+  if (!attrString.trim()) {
+    return {};
+  }
+  const attributes = {};
+  const regex = /(\w+)=(?:"([^"]*)"|'([^']*)')/g;
+  let match = regex.exec(attrString);
+  while (match !== null) {
+    const [, key, doubleQuoted, singleQuoted] = match;
+    attributes[key] = doubleQuoted || singleQuoted;
+    match = regex.exec(attrString);
+  }
+  return attributes;
+}
+function serializeShortcodeAttributes(attrs) {
+  return Object.entries(attrs).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}="${value}"`).join(" ");
+}
+function createInlineMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: shortcodeName,
+    getContent,
+    parseAttributes: parseAttributes2 = parseShortcodeAttributes,
+    serializeAttributes: serializeAttributes2 = serializeShortcodeAttributes,
+    defaultAttributes = {},
+    selfClosing = false,
+    allowedAttributes
+  } = options;
+  const shortcode = shortcodeName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((attr) => {
+      const attrName = typeof attr === "string" ? attr : attr.name;
+      const skipIfDefault = typeof attr === "string" ? void 0 : attr.skipIfDefault;
+      if (attrName in attrs) {
+        const value = attrs[attrName];
+        if (skipIfDefault !== void 0 && value === skipIfDefault) {
+          return;
+        }
+        filtered[attrName] = value;
+      }
+    });
+    return filtered;
+  };
+  const escapedShortcode = shortcode.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return {
+    parseMarkdown: (token, h2) => {
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      if (selfClosing) {
+        return h2.createNode(nodeName, attrs);
+      }
+      const content = getContent ? getContent(token) : token.content || "";
+      if (content) {
+        return h2.createNode(nodeName, attrs, [h2.createTextNode(content)]);
+      }
+      return h2.createNode(nodeName, attrs, []);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "inline",
+      start(src) {
+        const startPattern = selfClosing ? new RegExp(`\\[${escapedShortcode}\\s*[^\\]]*\\]`) : new RegExp(`\\[${escapedShortcode}\\s*[^\\]]*\\][\\s\\S]*?\\[\\/${escapedShortcode}\\]`);
+        const match = src.match(startPattern);
+        const index = match == null ? void 0 : match.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, _lexer) {
+        const tokenPattern = selfClosing ? new RegExp(`^\\[${escapedShortcode}\\s*([^\\]]*)\\]`) : new RegExp(`^\\[${escapedShortcode}\\s*([^\\]]*)\\]([\\s\\S]*?)\\[\\/${escapedShortcode}\\]`);
+        const match = src.match(tokenPattern);
+        if (!match) {
+          return void 0;
+        }
+        let content = "";
+        let attrString = "";
+        if (selfClosing) {
+          const [, attrs] = match;
+          attrString = attrs;
+        } else {
+          const [, attrs, contentMatch] = match;
+          attrString = attrs;
+          content = contentMatch || "";
+        }
+        const attributes = parseAttributes2(attrString.trim());
+        return {
+          type: nodeName,
+          raw: match[0],
+          content: content.trim(),
+          attributes
+        };
+      }
+    },
+    renderMarkdown: (node) => {
+      let content = "";
+      if (getContent) {
+        content = getContent(node);
+      } else if (node.content && node.content.length > 0) {
+        content = node.content.filter((child) => child.type === "text").map((child) => child.text).join("");
+      }
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` ${attrs}` : "";
+      if (selfClosing) {
+        return `[${shortcode}${attrString}]`;
+      }
+      return `[${shortcode}${attrString}]${content}[/${shortcode}]`;
+    }
+  };
+}
+function parseIndentedBlocks(src, config, lexer) {
+  var _a, _b, _c, _d;
+  const lines = src.split("\n");
+  const items = [];
+  let totalRaw = "";
+  let i = 0;
+  const baseIndentSize = config.baseIndentSize || 2;
+  while (i < lines.length) {
+    const currentLine = lines[i];
+    const itemMatch = currentLine.match(config.itemPattern);
+    if (!itemMatch) {
+      if (items.length > 0) {
+        break;
+      } else if (currentLine.trim() === "") {
+        i += 1;
+        totalRaw = `${totalRaw}${currentLine}
+`;
+        continue;
+      } else {
+        return void 0;
+      }
+    }
+    const itemData = config.extractItemData(itemMatch);
+    const { indentLevel, mainContent } = itemData;
+    totalRaw = `${totalRaw}${currentLine}
+`;
+    const itemContent = [mainContent];
+    i += 1;
+    while (i < lines.length) {
+      const nextLine = lines[i];
+      if (nextLine.trim() === "") {
+        const nextNonEmptyIndex = lines.slice(i + 1).findIndex((l) => l.trim() !== "");
+        if (nextNonEmptyIndex === -1) {
+          break;
+        }
+        const nextNonEmpty = lines[i + 1 + nextNonEmptyIndex];
+        const nextIndent2 = ((_b = (_a = nextNonEmpty.match(/^(\s*)/)) == null ? void 0 : _a[1]) == null ? void 0 : _b.length) || 0;
+        if (nextIndent2 > indentLevel) {
+          itemContent.push(nextLine);
+          totalRaw = `${totalRaw}${nextLine}
+`;
+          i += 1;
+          continue;
+        } else {
+          break;
+        }
+      }
+      const nextIndent = ((_d = (_c = nextLine.match(/^(\s*)/)) == null ? void 0 : _c[1]) == null ? void 0 : _d.length) || 0;
+      if (nextIndent > indentLevel) {
+        itemContent.push(nextLine);
+        totalRaw = `${totalRaw}${nextLine}
+`;
+        i += 1;
+      } else {
+        break;
+      }
+    }
+    let nestedTokens;
+    const nestedContent = itemContent.slice(1);
+    if (nestedContent.length > 0) {
+      const dedentedNested = nestedContent.map((nestedLine) => nestedLine.slice(indentLevel + baseIndentSize)).join("\n");
+      if (dedentedNested.trim()) {
+        if (config.customNestedParser) {
+          nestedTokens = config.customNestedParser(dedentedNested);
+        } else {
+          nestedTokens = lexer.blockTokens(dedentedNested);
+        }
+      }
+    }
+    const token = config.createToken(itemData, nestedTokens);
+    items.push(token);
+  }
+  if (items.length === 0) {
+    return void 0;
+  }
+  return {
+    items,
+    raw: totalRaw
+  };
+}
+function renderNestedMarkdownContent(node, h2, prefixOrGenerator, ctx) {
+  if (!node || !Array.isArray(node.content)) {
+    return "";
+  }
+  const prefix = typeof prefixOrGenerator === "function" ? prefixOrGenerator(ctx) : prefixOrGenerator;
+  const [content, ...children] = node.content;
+  const mainContent = h2.renderChildren([content]);
+  const output = [`${prefix}${mainContent}`];
+  if (children && children.length > 0) {
+    children.forEach((child) => {
+      const childContent = h2.renderChildren([child]);
+      if (childContent) {
+        const indentedChild = childContent.split("\n").map((line) => line ? h2.indent(line) : "").join("\n");
+        output.push(indentedChild);
+      }
+    });
+  }
+  return output.join("\n");
+}
+var Node3 = class _Node extends Extendable {
+  constructor() {
+    super(...arguments);
+    this.type = "node";
+  }
+  /**
+   * Create a new Node instance
+   * @param config - Node configuration object or a function that returns a configuration object
+   */
+  static create(config = {}) {
+    const resolvedConfig = typeof config === "function" ? config() : config;
+    return new _Node(resolvedConfig);
+  }
+  configure(options) {
+    return super.configure(options);
+  }
+  extend(extendedConfig) {
+    const resolvedConfig = typeof extendedConfig === "function" ? extendedConfig() : extendedConfig;
+    return super.extend(resolvedConfig);
+  }
+};
+function get_current_font_size2(editor) {
+  const attrs = editor.getAttributes("textStyle");
+  if (attrs?.fontSize) {
+    const parsed = parseInt(attrs.fontSize.replace("px", ""), 10);
+    return isNaN(parsed) ? DEFAULT_FONT_SIZE : parsed;
+  }
+  return DEFAULT_FONT_SIZE;
+}
+function get_next_font_size(current, direction) {
+  let index = FONT_SIZES.findIndex((s) => s >= current);
+  if (index === -1) {
+    index = FONT_SIZES.length - 1;
+  }
+  if (direction === "increase") {
+    if (FONT_SIZES[index] === current) {
+      return Math.min(FONT_SIZES[index + 1] ?? MAX_FONT_SIZE, MAX_FONT_SIZE);
+    }
+    return Math.min(FONT_SIZES[index], MAX_FONT_SIZE);
+  } else {
+    if (FONT_SIZES[index] === current && index > 0) {
+      return Math.max(FONT_SIZES[index - 1], MIN_FONT_SIZE);
+    }
+    const prev_index = index > 0 ? index - 1 : 0;
+    return Math.max(FONT_SIZES[prev_index], MIN_FONT_SIZE);
+  }
+}
+var FontSizeExtension = Extension.create({
+  name: "hazoFontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (element) => element.style.fontSize?.replace(/['"]+/g, ""),
+            renderHTML: (attributes) => {
+              if (!attributes.fontSize) {
+                return {};
+              }
+              return {
+                style: `font-size: ${attributes.fontSize}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (size) => ({ chain }) => {
+        return chain().setMark("textStyle", { fontSize: size }).run();
+      },
+      unsetFontSize: () => ({ chain }) => {
+        return chain().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run();
+      },
+      increaseFontSize: () => ({ chain, editor }) => {
+        const current_size = get_current_font_size2(editor);
+        const next_size = get_next_font_size(current_size, "increase");
+        return chain().setMark("textStyle", { fontSize: `${next_size}px` }).run();
+      },
+      decreaseFontSize: () => ({ chain, editor }) => {
+        const current_size = get_current_font_size2(editor);
+        const next_size = get_next_font_size(current_size, "decrease");
+        return chain().setMark("textStyle", { fontSize: `${next_size}px` }).run();
+      }
+    };
+  }
+});
+function VariableChipNodeView({ node }) {
+  const { variable_name, variable_text } = node.attrs;
+  return /* @__PURE__ */ jsxs(
+    NodeViewWrapper,
+    {
+      as: "span",
+      className: "cls_variable_chip inline-flex items-center px-2 py-0.5 mx-0.5 rounded-md bg-primary/10 text-primary text-sm font-medium border border-primary/20 cursor-default select-none",
+      contentEditable: false,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "cls_variable_chip_icon mr-1 text-xs opacity-70", children: "{" }),
+        /* @__PURE__ */ jsx("span", { className: "cls_variable_chip_text", children: variable_text || variable_name }),
+        /* @__PURE__ */ jsx("span", { className: "cls_variable_chip_icon ml-1 text-xs opacity-70", children: "}" })
+      ]
+    }
+  );
+}
+var variable_chip_default = VariableChipNodeView;
+
+// src/components/hazo_ui_richtext_editor/extensions/variable_extension.ts
+var VariableExtension = Node3.create({
+  name: "variable",
+  group: "inline",
+  inline: true,
+  // Atomic means it's not editable directly
+  atom: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      variable_name: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-variable-name"),
+        renderHTML: (attributes) => ({
+          "data-variable-name": attributes.variable_name
+        })
+      },
+      variable_text: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-variable-text"),
+        renderHTML: (attributes) => ({
+          "data-variable-text": attributes.variable_text
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-type="variable"]'
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": "variable",
+        class: "cls_variable_chip_output"
+      }),
+      `{{${node.attrs.variable_name}}}`
+    ];
+  },
+  // Include variable placeholder in plain text output
+  renderText({ node }) {
+    return `{{${node.attrs.variable_name}}}`;
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(variable_chip_default);
+  },
+  addCommands() {
+    return {
+      insertVariable: (variable_name, variable_text) => ({ commands }) => {
+        return commands.insertContent({
+          type: this.name,
+          attrs: { variable_name, variable_text }
+        });
+      }
+    };
+  }
+});
+
+// src/components/hazo_ui_richtext_editor/extensions/column_layout_extension.ts
+var ColumnLayoutExtension = Node3.create({
+  name: "columnLayout",
+  group: "block",
+  content: "column+",
+  defining: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      columns: {
+        default: 2,
+        parseHTML: (element) => parseInt(element.getAttribute("data-columns") || "2", 10),
+        renderHTML: (attributes) => ({
+          "data-columns": attributes.columns
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="column-layout"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const columns = HTMLAttributes.columns || 2;
+    return [
+      "div",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": "column-layout",
+        class: `cls_column_layout cls_columns_${columns}`,
+        style: `display: grid; grid-template-columns: repeat(${columns}, 1fr); gap: 1rem;`
+      }),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      insertColumnLayout: (columns) => ({ commands }) => {
+        const column_content = Array(columns).fill(null).map(() => ({
+          type: "column",
+          content: [{ type: "paragraph" }]
+        }));
+        return commands.insertContent({
+          type: this.name,
+          attrs: { columns },
+          content: column_content
+        });
+      }
+    };
+  }
+});
+var ColumnExtension = Node3.create({
+  name: "column",
+  group: "column",
+  content: "block+",
+  defining: true,
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="column"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-type": "column",
+        class: "cls_column",
+        style: "min-width: 0;"
+      }),
+      0
+    ];
+  }
+});
+function format_file_size(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function HazoRichtextEditor({
+  initial_html = "",
+  initial_text = "",
+  variables = [],
+  initial_attachments = [],
+  on_save,
+  on_change,
+  on_attachments_change,
+  on_file_attach,
+  placeholder = DEFAULT_PLACEHOLDER,
+  min_height = DEFAULT_MIN_HEIGHT,
+  max_height = DEFAULT_MAX_HEIGHT,
+  read_only = false,
+  show_save_button = true,
+  save_button_text = "Save",
+  className
+}) {
+  const [state, set_state] = React14.useState({
+    active_tab: "visual",
+    html_view_mode: "preview",
+    html_content: initial_html,
+    text_content: initial_text,
+    is_variables_modal_open: false
+  });
+  const [attachments, set_attachments] = React14.useState(initial_attachments);
+  const editor = useEditor({
+    extensions: [
+      StarterKit.configure({
+        heading: {
+          levels: [1, 2, 3]
+        }
+      }),
+      Underline,
+      TextStyle,
+      Color,
+      Highlight.configure({
+        multicolor: true
+      }),
+      FontFamily,
+      FontSizeExtension,
+      TextAlign.configure({
+        types: ["heading", "paragraph"]
+      }),
+      Link.configure({
+        openOnClick: false,
+        HTMLAttributes: {
+          class: "cls_editor_link text-primary underline cursor-pointer"
+        }
+      }),
+      Image.configure({
+        HTMLAttributes: {
+          class: "cls_editor_image max-w-full h-auto rounded-md"
+        }
+      }),
+      Table.configure({
+        resizable: true,
+        HTMLAttributes: {
+          class: "cls_editor_table border-collapse w-full"
+        }
+      }),
+      TableRow,
+      TableCell.configure({
+        HTMLAttributes: {
+          class: "cls_editor_table_cell border border-border p-2"
+        }
+      }),
+      TableHeader.configure({
+        HTMLAttributes: {
+          class: "cls_editor_table_header border border-border p-2 bg-muted font-medium"
+        }
+      }),
+      TaskList.configure({
+        HTMLAttributes: {
+          class: "cls_editor_task_list"
+        }
+      }),
+      TaskItem.configure({
+        nested: true,
+        HTMLAttributes: {
+          class: "cls_editor_task_item"
+        }
+      }),
+      Subscript,
+      Superscript,
+      Placeholder.configure({
+        placeholder,
+        emptyEditorClass: "cls_editor_empty"
+      }),
+      VariableExtension,
+      ColumnLayoutExtension,
+      ColumnExtension
+    ],
+    content: initial_html || `<p>${initial_text}</p>`,
+    editable: !read_only,
+    immediatelyRender: false,
+    onUpdate: ({ editor: editor2 }) => {
+      const html = editor2.getHTML();
+      const text = editor2.getText();
+      set_state((prev) => ({
+        ...prev,
+        html_content: html,
+        text_content: text
+      }));
+      on_change?.(html, text);
+    }
+  });
+  React14.useEffect(() => {
+    if (editor && state.active_tab === "visual") {
+      const current_html = editor.getHTML();
+      if (current_html !== state.html_content && state.html_content) {
+        editor.commands.setContent(state.html_content);
+      }
+    }
+  }, [state.active_tab, editor, state.html_content]);
+  const handle_tab_change = (tab) => {
+    if (editor && tab !== "visual" && state.active_tab === "visual") {
+      set_state((prev) => ({
+        ...prev,
+        active_tab: tab,
+        html_content: editor.getHTML(),
+        text_content: editor.getText()
+      }));
+    } else {
+      set_state((prev) => ({
+        ...prev,
+        active_tab: tab
+      }));
+    }
+  };
+  const handle_html_change = (html) => {
+    set_state((prev) => ({
+      ...prev,
+      html_content: html
+    }));
+  };
+  const handle_text_change = (text) => {
+    set_state((prev) => ({
+      ...prev,
+      text_content: text
+    }));
+  };
+  const handle_html_view_mode_change = (mode) => {
+    set_state((prev) => ({
+      ...prev,
+      html_view_mode: mode
+    }));
+  };
+  const handle_variable_select = (variable) => {
+    if (editor) {
+      editor.chain().focus().insertVariable(variable.text, variable.description).run();
+    }
+  };
+  const handle_save = () => {
+    const html = editor?.getHTML() || state.html_content;
+    const text = editor?.getText() || state.text_content;
+    on_save?.(html, text, attachments);
+  };
+  const open_variables_modal = () => {
+    set_state((prev) => ({
+      ...prev,
+      is_variables_modal_open: true
+    }));
+  };
+  const close_variables_modal = () => {
+    set_state((prev) => ({
+      ...prev,
+      is_variables_modal_open: false
+    }));
+  };
+  const generate_attachment_id = () => {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  };
+  const handle_add_attachment = async (file) => {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        const new_attachment = {
+          id: generate_attachment_id(),
+          name: file.name,
+          type: file.type,
+          size: file.size,
+          data: reader.result
+        };
+        const updated_attachments = [...attachments, new_attachment];
+        set_attachments(updated_attachments);
+        on_attachments_change?.(updated_attachments);
+        resolve();
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(file);
+    });
+  };
+  const handle_remove_attachment = (id) => {
+    const updated_attachments = attachments.filter((a) => a.id !== id);
+    set_attachments(updated_attachments);
+    on_attachments_change?.(updated_attachments);
+  };
+  const handle_image_embed = async (file) => {
+    let url;
+    let base64_data;
+    if (on_file_attach) {
+      url = await on_file_attach(file);
+      base64_data = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+      });
+    } else {
+      base64_data = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+      });
+      url = base64_data;
+    }
+    if (editor) {
+      editor.chain().focus().setImage({ src: url, alt: file.name }).run();
+    }
+    const new_attachment = {
+      id: generate_attachment_id(),
+      name: file.name,
+      type: file.type,
+      size: file.size,
+      data: base64_data
+    };
+    const updated_attachments = [...attachments, new_attachment];
+    set_attachments(updated_attachments);
+    on_attachments_change?.(updated_attachments);
+    return url;
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "cls_richtext_editor border border-border rounded-lg overflow-hidden bg-background",
+        className
+      ),
+      children: [
+        state.active_tab === "visual" && !read_only && /* @__PURE__ */ jsx(
+          Toolbar,
+          {
+            editor,
+            on_open_variables_modal: open_variables_modal,
+            variables,
+            on_image_embed: handle_image_embed,
+            on_add_attachment: handle_add_attachment
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ViewTabs,
+          {
+            active_tab: state.active_tab,
+            on_tab_change: handle_tab_change,
+            editor,
+            html_content: state.html_content,
+            text_content: state.text_content,
+            on_html_change: handle_html_change,
+            on_text_change: handle_text_change,
+            html_view_mode: state.html_view_mode,
+            on_html_view_mode_change: handle_html_view_mode_change,
+            min_height,
+            max_height,
+            read_only,
+            children: /* @__PURE__ */ jsx(
+              EditorContent,
+              {
+                editor,
+                className: cn(
+                  "cls_editor_content prose prose-sm max-w-none p-4",
+                  "focus-within:outline-none",
+                  "[&_.ProseMirror]:outline-none [&_.ProseMirror]:min-h-[inherit]",
+                  "[&_.ProseMirror_p.is-editor-empty:first-child::before]:text-muted-foreground",
+                  "[&_.ProseMirror_p.is-editor-empty:first-child::before]:content-[attr(data-placeholder)]",
+                  "[&_.ProseMirror_p.is-editor-empty:first-child::before]:float-left",
+                  "[&_.ProseMirror_p.is-editor-empty:first-child::before]:h-0",
+                  "[&_.ProseMirror_p.is-editor-empty:first-child::before]:pointer-events-none"
+                )
+              }
+            )
+          }
+        ),
+        attachments.length > 0 && /* @__PURE__ */ jsxs("div", { className: "cls_attachments_section border-t border-border p-3 bg-muted/20", children: [
+          /* @__PURE__ */ jsxs("div", { className: "cls_attachments_header text-xs font-medium text-muted-foreground mb-2", children: [
+            "Attachments (",
+            attachments.length,
+            ")"
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "cls_attachments_list flex flex-wrap gap-2", children: attachments.map((attachment) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "cls_attachment_item flex items-center gap-2 px-2 py-1 rounded-md bg-background border border-border text-sm",
+              children: [
+                attachment.type.startsWith("image/") ? /* @__PURE__ */ jsx(
+                  "img",
+                  {
+                    src: attachment.data,
+                    alt: attachment.name,
+                    className: "cls_attachment_thumbnail h-6 w-6 object-cover rounded"
+                  }
+                ) : /* @__PURE__ */ jsx("span", { className: "cls_attachment_icon text-muted-foreground", children: "\u{1F4CE}" }),
+                /* @__PURE__ */ jsx("span", { className: "cls_attachment_name max-w-[150px] truncate", children: attachment.name }),
+                /* @__PURE__ */ jsxs("span", { className: "cls_attachment_size text-xs text-muted-foreground", children: [
+                  "(",
+                  format_file_size(attachment.size),
+                  ")"
+                ] }),
+                !read_only && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: () => handle_remove_attachment(attachment.id),
+                    className: "cls_attachment_remove ml-1 text-muted-foreground hover:text-destructive",
+                    "aria-label": "Remove attachment",
+                    children: "\xD7"
+                  }
+                )
+              ]
+            },
+            attachment.id
+          )) })
+        ] }),
+        show_save_button && on_save && /* @__PURE__ */ jsx("div", { className: "cls_richtext_editor_footer flex items-center justify-end p-3 border-t border-border bg-muted/30", children: /* @__PURE__ */ jsx(Button, { onClick: handle_save, size: "sm", children: save_button_text }) }),
+        /* @__PURE__ */ jsx(
+          VariablesModal,
+          {
+            is_open: state.is_variables_modal_open,
+            on_close: close_variables_modal,
+            variables,
+            on_select_variable: handle_variable_select
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { HazoRichtextEditor, HazoUiFlexInput, HazoUiFlexRadio, HazoUiMultiFilterDialog, HazoUiMultiSortDialog };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map