react-word-editor 0.0.0-stage → 0.1.0

package/dist/chunk-JQEG2JQ7.js

@@ -0,0 +1,1887 @@
+// src/toolbar/constants.js
+var BLOCK_TYPES = [
+  { value: "paragraph", label: "Normal" },
+  { value: "h1", label: "Heading 1" },
+  { value: "h2", label: "Heading 2" },
+  { value: "h3", label: "Heading 3" },
+  { value: "h4", label: "Heading 4" }
+];
+var DEFAULT_FONT_FAMILIES = [
+  { value: "", label: "Default font" },
+  { value: "Roboto, sans-serif", label: "Roboto" },
+  { value: "Arial, Helvetica, sans-serif", label: "Arial" },
+  { value: "Calibri, Carlito, sans-serif", label: "Calibri" },
+  { value: '"Times New Roman", Times, serif', label: "Times New Roman" },
+  { value: "Georgia, serif", label: "Georgia" },
+  { value: "Verdana, sans-serif", label: "Verdana" },
+  { value: '"Courier New", Courier, monospace', label: "Courier New" }
+];
+var DEFAULT_FONT_SIZES = ["8", "9", "10", "11", "12", "14", "16", "18", "20", "24", "28", "36", "48"];
+var LINE_HEIGHTS = [
+  { value: "", label: "Line spacing", menuLabel: "Default" },
+  { value: "1", label: "1.0" },
+  { value: "1.15", label: "1.15" },
+  { value: "1.5", label: "1.5" },
+  { value: "2", label: "2.0" },
+  { value: "2.5", label: "2.5" },
+  { value: "3", label: "3.0" }
+];
+var COLOR_SWATCHES = [
+  "#000000",
+  "#434343",
+  "#666666",
+  "#999999",
+  "#cccccc",
+  "#ffffff",
+  "#c00000",
+  "#ff0000",
+  "#ffc000",
+  "#ffff00",
+  "#92d050",
+  "#00b050",
+  "#00b0f0",
+  "#0070c0",
+  "#002060",
+  "#7030a0",
+  "#2d5cf2",
+  "#f4b183",
+  "#fde9d9",
+  "#fff2cc",
+  "#e2efda",
+  "#ddebf7",
+  "#d9e2f3",
+  "#ededed"
+];
+var DEFAULT_TOOLBAR = [
+  "undo",
+  "redo",
+  "|",
+  "blockType",
+  "fontFamily",
+  "fontSize",
+  "textCase",
+  "|",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "subscript",
+  "superscript",
+  "|",
+  "textColor",
+  "highlight",
+  "|",
+  "alignLeft",
+  "alignCenter",
+  "alignRight",
+  "alignJustify",
+  "|",
+  "bulletList",
+  "orderedList",
+  "outdent",
+  "indent",
+  "lineHeight",
+  "paragraphSpacing",
+  "|",
+  "table",
+  "image",
+  "link",
+  "horizontalRule",
+  "|",
+  "clearFormatting"
+];
+var TABLE_PICKER_SIZE = { rows: 8, cols: 10 };
+var PARAGRAPH_SPACING = [
+  { value: "default", label: "Default", before: null, after: null, lineHeight: null },
+  { value: "none", label: "No Paragraph Space", before: 0, after: 0, lineHeight: 1 },
+  { value: "compact", label: "Compact", before: 0, after: 4, lineHeight: 1 },
+  { value: "tight", label: "Tight", before: 0, after: 6, lineHeight: 1.15 },
+  { value: "open", label: "Open", before: 0, after: 10, lineHeight: 1.15 },
+  { value: "relaxed", label: "Relaxed", before: 0, after: 6, lineHeight: 1.5 },
+  { value: "double", label: "Double", before: 0, after: 8, lineHeight: 2 }
+];
+var TEXT_CASES = [
+  { value: "sentence", label: "Sentence case." },
+  { value: "lower", label: "lowercase" },
+  { value: "upper", label: "UPPERCASE" },
+  { value: "capitalize", label: "Capitalise Each Word" },
+  { value: "toggle", label: "tOGGLE cASE" }
+];
+var TABLE_BORDER_OPTIONS = [
+  { value: "bottom", label: "Bottom Border", lines: ["bottom"] },
+  { value: "top", label: "Top Border", lines: ["top"] },
+  { value: "left", label: "Left Border", lines: ["left"] },
+  { value: "right", label: "Right Border", lines: ["right"] },
+  "|",
+  { value: "none", label: "No Border", lines: [] },
+  { value: "all", label: "All Borders", lines: ["top", "bottom", "left", "right", "insideH", "insideV"] },
+  { value: "outside", label: "Outside Borders", lines: ["top", "bottom", "left", "right"] },
+  { value: "inside", label: "Inside Borders", lines: ["insideH", "insideV"] },
+  "|",
+  { value: "insideH", label: "Inside Horizontal Border", lines: ["insideH"] },
+  { value: "insideV", label: "Inside Vertical Border", lines: ["insideV"] }
+];
+
+// src/extensions/paragraphFormat.js
+import { Extension } from "@tiptap/core";
+
+// src/utils/units.js
+var PX_PER_UNIT = {
+  px: 1,
+  pt: 96 / 72,
+  pc: 16,
+  in: 96,
+  cm: 96 / 2.54,
+  mm: 96 / 25.4
+};
+var LENGTH_RE = /^(-?\d*\.?\d+)\s*(px|pt|pc|in|cm|mm|em|rem)?$/i;
+var toPx = (value, fontSizePx = 16) => {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  const match = String(value).trim().match(LENGTH_RE);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  const unit = (match[2] || "px").toLowerCase();
+  if (unit === "em" || unit === "rem") return num * fontSizePx;
+  return num * PX_PER_UNIT[unit];
+};
+var round = (n, digits = 2) => {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+};
+var pxToPt = (px) => round(px * 0.75);
+var toPt = (value, fontSizePx) => {
+  const px = toPx(value, fontSizePx);
+  return px === null ? null : pxToPt(px);
+};
+var parseLineHeight = (value) => {
+  if (value === null || value === void 0 || value === "") return null;
+  const str = String(value).trim().toLowerCase();
+  if (str === "normal" || str === "inherit" || str === "initial") return null;
+  if (str.endsWith("%")) {
+    const pct2 = parseFloat(str);
+    return Number.isFinite(pct2) && pct2 > 0 ? round(pct2 / 100) : null;
+  }
+  const num = Number(str);
+  if (Number.isFinite(num) && num > 0) return round(num);
+  return null;
+};
+
+// src/extensions/paragraphFormat.js
+var INDENT_STEP_PX = 48;
+var MAX_INDENT_PX = INDENT_STEP_PX * 12;
+var BLOCK_TYPES2 = ["paragraph", "heading"];
+var pxAttribute = (cssProp, styleKey, { allowNegative = false, keepZero = false } = {}) => ({
+  default: null,
+  keepOnSplit: true,
+  parseHTML: (el) => {
+    var _a;
+    const px = toPx((_a = el.style) == null ? void 0 : _a[styleKey]);
+    if (px === null || !allowNegative && px < 0) return null;
+    if (px === 0 && !keepZero) return null;
+    return round(px);
+  },
+  renderHTML: (attrs) => {
+    const value = attrs[styleKey];
+    if (value === null || value === void 0) return {};
+    return { style: `${cssProp}: ${value}px` };
+  }
+});
+var updateBlocks = (tr, state, fn) => {
+  const { from, to } = state.selection;
+  let changed = false;
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (!BLOCK_TYPES2.includes(node.type.name)) return true;
+    const next = fn(node.attrs);
+    if (next) {
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...next });
+      changed = true;
+    }
+    return false;
+  });
+  return changed;
+};
+var ptToPx = (pt) => pt === null ? null : round(toPx(`${pt}pt`));
+var spacingAttrs = (preset) => ({
+  marginTop: preset.before ? ptToPx(preset.before) : null,
+  marginBottom: ptToPx(preset.after),
+  lineHeight: preset.lineHeight
+});
+var matchSpacingPreset = (attrs = {}) => {
+  var _a;
+  return ((_a = PARAGRAPH_SPACING.find((preset) => {
+    const want = spacingAttrs(preset);
+    return Object.keys(want).every((k) => {
+      var _a2;
+      return ((_a2 = attrs[k]) != null ? _a2 : null) === want[k];
+    });
+  })) == null ? void 0 : _a.value) || null;
+};
+var ParagraphFormat = Extension.create({
+  name: "paragraphFormat",
+  priority: 50,
+  addGlobalAttributes() {
+    return [
+      {
+        types: BLOCK_TYPES2,
+        attributes: {
+          marginLeft: {
+            ...pxAttribute("margin-left", "marginLeft"),
+            // TinyMCE indents with padding-left; treat both as the indent.
+            parseHTML: (el) => {
+              var _a, _b;
+              const px = (toPx((_a = el.style) == null ? void 0 : _a.marginLeft) || 0) + (toPx((_b = el.style) == null ? void 0 : _b.paddingLeft) || 0);
+              return px > 0 ? round(px) : null;
+            }
+          },
+          textIndent: pxAttribute("text-indent", "textIndent", { allowNegative: true }),
+          marginTop: pxAttribute("margin-top", "marginTop"),
+          marginBottom: pxAttribute("margin-bottom", "marginBottom", { keepZero: true }),
+          lineHeight: {
+            default: null,
+            keepOnSplit: true,
+            parseHTML: (el) => {
+              var _a;
+              return parseLineHeight((_a = el.style) == null ? void 0 : _a.lineHeight);
+            },
+            renderHTML: (attrs) => attrs.lineHeight ? { style: `line-height: ${attrs.lineHeight}` } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      indent: () => ({ editor, tr, state, dispatch }) => {
+        if (editor.isActive("listItem")) return editor.commands.sinkListItem("listItem");
+        const changed = updateBlocks(tr, state, (attrs) => {
+          const next = Math.min((attrs.marginLeft || 0) + INDENT_STEP_PX, MAX_INDENT_PX);
+          return next === attrs.marginLeft ? null : { marginLeft: next };
+        });
+        if (changed && dispatch) dispatch(tr);
+        return changed;
+      },
+      outdent: () => ({ editor, tr, state, dispatch }) => {
+        if (editor.isActive("listItem")) return editor.commands.liftListItem("listItem");
+        const changed = updateBlocks(tr, state, (attrs) => {
+          if (!attrs.marginLeft && !attrs.textIndent) return null;
+          if (!attrs.marginLeft) return { textIndent: null };
+          const next = Math.max(attrs.marginLeft - INDENT_STEP_PX, 0);
+          return { marginLeft: next || null };
+        });
+        if (changed && dispatch) dispatch(tr);
+        return changed;
+      },
+      setLineHeight: (lineHeight) => ({ tr, state, dispatch }) => {
+        const value = parseLineHeight(lineHeight);
+        const changed = updateBlocks(tr, state, () => ({ lineHeight: value }));
+        if (changed && dispatch) dispatch(tr);
+        return changed;
+      },
+      setParagraphSpacing: (value) => ({ tr, state, dispatch }) => {
+        const preset = PARAGRAPH_SPACING.find((p) => p.value === value);
+        if (!preset) return false;
+        const changed = updateBlocks(tr, state, () => spacingAttrs(preset));
+        if (changed && dispatch) dispatch(tr);
+        return changed;
+      },
+      unsetParagraphFormat: () => ({ tr, state, dispatch }) => {
+        const changed = updateBlocks(tr, state, () => ({
+          marginLeft: null,
+          textIndent: null,
+          marginTop: null,
+          marginBottom: null,
+          lineHeight: null
+        }));
+        if (changed && dispatch) dispatch(tr);
+        return changed;
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Tab: () => {
+        if (this.editor.isActive("table")) return false;
+        this.editor.commands.indent();
+        return true;
+      },
+      "Shift-Tab": () => {
+        if (this.editor.isActive("table")) return false;
+        this.editor.commands.outdent();
+        return true;
+      }
+    };
+  }
+});
+
+// src/extensions/tableCells.js
+import { TableCell, TableHeader } from "@tiptap/extension-table";
+
+// src/utils/borders.js
+var SIDES = ["top", "right", "bottom", "left"];
+var STYLES = ["none", "hidden", "solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset"];
+var WIDTH_WORDS = { thin: "1px", medium: "3px", thick: "5px" };
+var splitTokens = (value) => value.match(/(rgba?\([^)]*\)|[^\s]+)/g) || [];
+var expandBox = (values) => {
+  const [a, b = a, c = a, d = b] = values;
+  return [a, b, c, d];
+};
+var parseShorthand = (value) => {
+  const out = {};
+  splitTokens(value.trim()).forEach((token) => {
+    const t = token.toLowerCase();
+    if (STYLES.includes(t)) out.style = t;
+    else if (WIDTH_WORDS[t] || toPx(t) !== null) out.width = WIDTH_WORDS[t] || t;
+    else out.color = token;
+  });
+  return out;
+};
+var parseBorders = (styleAttr) => {
+  const sides = Object.fromEntries(SIDES.map((s) => [s, null]));
+  const set = (side, part) => {
+    sides[side] = { ...sides[side] || {}, ...part };
+  };
+  (styleAttr || "").split(";").forEach((decl) => {
+    const idx = decl.indexOf(":");
+    if (idx < 1) return;
+    const prop = decl.slice(0, idx).trim().toLowerCase();
+    const value = decl.slice(idx + 1).trim().replace(/\s*!important$/i, "");
+    if (!prop.startsWith("border") || !value) return;
+    if (prop === "border") {
+      const part = parseShorthand(value);
+      SIDES.forEach((s) => {
+        sides[s] = { width: "3px", style: "none", color: "currentcolor", ...part };
+      });
+      return;
+    }
+    const m = prop.match(/^border-(top|right|bottom|left)(?:-(width|style|color))?$/);
+    if (m) {
+      if (!m[2]) {
+        sides[m[1]] = { width: "3px", style: "none", color: "currentcolor", ...parseShorthand(value) };
+      } else set(m[1], { [m[2]]: value });
+      return;
+    }
+    const all = prop.match(/^border-(width|style|color)$/);
+    if (all) {
+      expandBox(splitTokens(value)).forEach((v, i) => set(SIDES[i], { [all[1]]: v }));
+    }
+  });
+  return sides;
+};
+var formatBorder = (side) => {
+  if (!side) return null;
+  const style = (side.style || "none").toLowerCase();
+  if (style === "none" || style === "hidden") return "none";
+  const px = toPx(WIDTH_WORDS[side.width] || side.width || "1px");
+  if (px === 0) return "none";
+  const w = px === null ? 1 : Math.max(round(px), 0.5);
+  const color = !side.color || side.color === "currentcolor" ? "#000000" : side.color;
+  return `${w}px ${style} ${color}`;
+};
+
+// src/extensions/tableCells.js
+var SIDES2 = ["Top", "Right", "Bottom", "Left"];
+var DEFAULT_BORDER = "1px solid #000000";
+var rgbToHex = (color) => {
+  const m = String(color || "").match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)$/i);
+  if (!m) return color;
+  if (m[4] !== void 0 && parseFloat(m[4]) === 0) return "transparent";
+  return `#${[m[1], m[2], m[3]].map((n) => Number(n).toString(16).padStart(2, "0")).join("")}`;
+};
+var parseBorderSide = (el, side) => formatBorder(parseBorders(el.getAttribute("style"))[side.toLowerCase()]);
+var parseColwidth = (el) => {
+  var _a;
+  const attr = el.getAttribute("colwidth");
+  if (attr) return attr.split(",").map((w) => parseInt(w, 10));
+  const raw = el.getAttribute("data-width") || ((_a = el.style) == null ? void 0 : _a.width) || el.getAttribute("width");
+  const px = toPx(raw && /^\d+(\.\d+)?$/.test(raw) ? `${raw}px` : raw);
+  if (!px) return null;
+  const span = parseInt(el.getAttribute("colspan") || "1", 10) || 1;
+  return Array.from({ length: span }, () => Math.max(Math.round(px / span), 20));
+};
+var cellAttributes = (parent) => ({
+  ...parent,
+  colwidth: {
+    default: null,
+    parseHTML: parseColwidth,
+    renderHTML: (attrs) => attrs.colwidth ? { colwidth: attrs.colwidth.join(",") } : {}
+  },
+  backgroundColor: {
+    default: null,
+    parseHTML: (el) => {
+      var _a;
+      const bg = ((_a = el.style) == null ? void 0 : _a.backgroundColor) || el.getAttribute("bgcolor");
+      const hex = bg ? rgbToHex(bg) : null;
+      return hex && hex !== "transparent" ? hex : null;
+    },
+    renderHTML: (attrs) => attrs.backgroundColor ? { style: `background-color: ${attrs.backgroundColor}` } : {}
+  },
+  verticalAlign: {
+    default: null,
+    parseHTML: (el) => {
+      var _a;
+      const v = (((_a = el.style) == null ? void 0 : _a.verticalAlign) || el.getAttribute("valign") || "").toLowerCase();
+      return ["top", "middle", "bottom"].includes(v) ? v : null;
+    },
+    renderHTML: (attrs) => attrs.verticalAlign ? { style: `vertical-align: ${attrs.verticalAlign}` } : {}
+  },
+  ...Object.fromEntries(
+    SIDES2.map((side) => [
+      `border${side}`,
+      {
+        default: null,
+        parseHTML: (el) => parseBorderSide(el, side),
+        renderHTML: (attrs) => {
+          const value = attrs[`border${side}`];
+          return value ? { style: `border-${side.toLowerCase()}: ${value}` } : {};
+        }
+      }
+    ])
+  )
+});
+var RichTableCell = TableCell.extend({
+  addAttributes() {
+    var _a;
+    return cellAttributes((_a = this.parent) == null ? void 0 : _a.call(this));
+  }
+});
+var RichTableHeader = TableHeader.extend({
+  addAttributes() {
+    var _a;
+    return cellAttributes((_a = this.parent) == null ? void 0 : _a.call(this));
+  }
+});
+
+// src/extensions/nodeIds.js
+import { Extension as Extension2 } from "@tiptap/core";
+
+// src/utils/meta.js
+var SILENT_META = "flabsEditorSilent";
+
+// src/extensions/nodeIds.js
+var NODE_ID_ATTRIBUTE = "data-node-id";
+var NODE_ID_TYPES = [
+  "paragraph",
+  "heading",
+  "listItem",
+  "bulletList",
+  "orderedList",
+  "table",
+  "image",
+  "horizontalRule",
+  "blockquote"
+];
+var newId = () => typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `n-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+var ensureNodeIds = (editor) => {
+  var _a, _b;
+  if (!editor || editor.isDestroyed || !((_b = (_a = editor.view) == null ? void 0 : _a.dom) == null ? void 0 : _b.isConnected)) return false;
+  const { state } = editor;
+  const seen = /* @__PURE__ */ new Set();
+  const tr = state.tr;
+  state.doc.descendants((node, pos) => {
+    if (!NODE_ID_TYPES.includes(node.type.name)) return true;
+    const id = node.attrs.nodeId;
+    if (!id || seen.has(id)) {
+      const fresh = newId();
+      seen.add(fresh);
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, nodeId: fresh });
+    } else {
+      seen.add(id);
+    }
+    return true;
+  });
+  if (!tr.docChanged) return false;
+  tr.setMeta("addToHistory", false);
+  tr.setMeta(SILENT_META, true);
+  editor.view.dispatch(tr);
+  return true;
+};
+var NodeIds = Extension2.create({
+  name: "nodeIds",
+  addGlobalAttributes() {
+    return [
+      {
+        types: NODE_ID_TYPES,
+        attributes: {
+          nodeId: {
+            default: null,
+            keepOnSplit: false,
+            parseHTML: (el) => el.getAttribute(NODE_ID_ATTRIBUTE),
+            renderHTML: (attrs) => attrs.nodeId ? { [NODE_ID_ATTRIBUTE]: attrs.nodeId } : {}
+          }
+        }
+      }
+    ];
+  },
+  onBlur() {
+    ensureNodeIds(this.editor);
+  }
+});
+
+// src/extensions/index.js
+import StarterKit from "@tiptap/starter-kit";
+import { Table, TableRow } from "@tiptap/extension-table";
+import {
+  BackgroundColor,
+  Color,
+  FontFamily,
+  FontSize,
+  TextStyle
+} from "@tiptap/extension-text-style";
+import TextAlign from "@tiptap/extension-text-align";
+import Image from "@tiptap/extension-image";
+import Subscript from "@tiptap/extension-subscript";
+import Superscript from "@tiptap/extension-superscript";
+import { Placeholder } from "@tiptap/extensions";
+
+// src/extensions/imageUpload.js
+import { Extension as Extension3 } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+var readAsDataUrl = (file) => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.onload = () => resolve(reader.result);
+  reader.onerror = () => reject(new Error("Could not read the image"));
+  reader.readAsDataURL(file);
+});
+var imageFiles = (list) => Array.from(list || []).filter((f) => {
+  var _a;
+  return (_a = f == null ? void 0 : f.type) == null ? void 0 : _a.startsWith("image/");
+});
+var uploadImage = async (file, { onImageUpload, maxImageSize }) => {
+  if (maxImageSize && file.size > maxImageSize) {
+    const mb = Math.round(maxImageSize / 1024 / 1024 * 10) / 10;
+    throw new Error(`Image size must be less than or equal to ${mb}MB`);
+  }
+  if (onImageUpload) return onImageUpload(file);
+  return readAsDataUrl(file);
+};
+var insertImages = async (editor, files, options, pos) => {
+  var _a;
+  for (const file of files) {
+    try {
+      const src = await uploadImage(file, options);
+      if (!src || editor.isDestroyed) continue;
+      const chain = editor.chain().focus();
+      if (typeof pos === "number") chain.insertContentAt(pos, { type: "image", attrs: { src } });
+      else chain.setImage({ src });
+      chain.run();
+    } catch (err) {
+      (_a = options.onError) == null ? void 0 : _a.call(options, err);
+    }
+  }
+};
+var ImageUpload = Extension3.create({
+  name: "imageUpload",
+  addOptions() {
+    return { onImageUpload: null, maxImageSize: null, onError: null };
+  },
+  addProseMirrorPlugins() {
+    const { editor, options } = this;
+    return [
+      new Plugin({
+        key: new PluginKey("flabsImageUpload"),
+        props: {
+          handlePaste: (view, event) => {
+            var _a;
+            const data = event.clipboardData;
+            const files = imageFiles(data == null ? void 0 : data.files);
+            if (!files.length) return false;
+            const html = data.getData("text/html");
+            if (html && /<(p|table|span|div|li|h\d)[\s>]/i.test(html)) return false;
+            if ((_a = data.getData("text/plain")) == null ? void 0 : _a.trim()) return false;
+            insertImages(editor, files, options);
+            return true;
+          },
+          handleDrop: (view, event) => {
+            var _a;
+            const files = imageFiles((_a = event.dataTransfer) == null ? void 0 : _a.files);
+            if (!files.length) return false;
+            event.preventDefault();
+            const coords = view.posAtCoords({ left: event.clientX, top: event.clientY });
+            insertImages(editor, files, options, coords == null ? void 0 : coords.pos);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/textCase.js
+import { Extension as Extension4 } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+
+// src/utils/textCase.js
+var LETTER = /\p{L}/u;
+var WORD_CHAR = /[\p{L}\p{N}'’]/u;
+var SENTENCE_END = /[.!?]/;
+var swapCase = (ch) => {
+  const upper = ch.toUpperCase();
+  return upper === ch ? ch.toLowerCase() : upper;
+};
+var createCaser = (mode, before = "") => {
+  let sentenceStart = true;
+  let afterEnd = false;
+  let inWord = false;
+  const step = (ch) => {
+    let out = ch;
+    if (mode === "lower") out = ch.toLowerCase();
+    else if (mode === "upper") out = ch.toUpperCase();
+    else if (mode === "toggle") out = swapCase(ch);
+    else if (mode === "capitalize") {
+      if (LETTER.test(ch)) out = inWord ? ch.toLowerCase() : ch.toUpperCase();
+    } else if (mode === "sentence" && LETTER.test(ch)) {
+      out = sentenceStart ? ch.toUpperCase() : ch.toLowerCase();
+    }
+    inWord = WORD_CHAR.test(ch);
+    if (LETTER.test(ch) || /\p{N}/u.test(ch)) {
+      sentenceStart = false;
+      afterEnd = false;
+    } else if (SENTENCE_END.test(ch)) afterEnd = true;
+    else if (/\s/.test(ch)) {
+      if (afterEnd) sentenceStart = true;
+    } else afterEnd = false;
+    return out;
+  };
+  Array.from(before).forEach(step);
+  return (text) => Array.from(text).map(step).join("");
+};
+var TEXT_CASE_MODES = ["sentence", "lower", "upper", "capitalize", "toggle"];
+
+// src/extensions/textCase.js
+var WORD_CHAR2 = /[\p{L}\p{N}'’]/u;
+var LEAF = "\n";
+var wordAround = ($pos) => {
+  const { parent } = $pos;
+  if (!parent.isTextblock) return null;
+  const text = parent.textBetween(0, parent.content.size, void 0, LEAF);
+  let start = $pos.parentOffset;
+  let end = start;
+  while (start > 0 && WORD_CHAR2.test(text[start - 1])) start -= 1;
+  while (end < text.length && WORD_CHAR2.test(text[end])) end += 1;
+  if (start === end) return null;
+  const base = $pos.start();
+  return { from: base + start, to: base + end };
+};
+var collectRuns = (doc, from, to) => {
+  const blocks = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isTextblock) return true;
+    const runs = [];
+    node.forEach((child, offset) => {
+      if (!child.isText) return;
+      const start = Math.max(from, pos + 1 + offset);
+      const end = Math.min(to, pos + 1 + offset + child.nodeSize);
+      if (start < end) runs.push({ start, end, marks: child.marks });
+    });
+    if (runs.length) {
+      const before = node.textBetween(0, runs[0].start - pos - 1, void 0, LEAF);
+      blocks.push({ before, runs });
+    }
+    return false;
+  });
+  return blocks;
+};
+var TextCase = Extension4.create({
+  name: "textCase",
+  addCommands() {
+    return {
+      setTextCase: (mode) => ({ state, tr, dispatch }) => {
+        if (!TEXT_CASE_MODES.includes(mode)) return false;
+        const { selection } = state;
+        const range = selection.empty ? wordAround(selection.$from) : { from: selection.from, to: selection.to };
+        if (!range) return false;
+        const edits = [];
+        collectRuns(state.doc, range.from, range.to).forEach(({ before, runs }) => {
+          const caser = createCaser(mode, before);
+          runs.forEach(({ start, end, marks }) => {
+            const text = state.doc.textBetween(start, end);
+            const next = caser(text);
+            if (next !== text) edits.push({ start, end, next, marks });
+          });
+        });
+        if (!edits.length) return false;
+        if (!dispatch) return true;
+        edits.reverse().forEach(({ start, end, next, marks }) => {
+          tr.replaceWith(start, end, state.schema.text(next, marks));
+        });
+        const sameSize = tr.doc.content.size === state.doc.content.size;
+        if (selection instanceof TextSelection) {
+          const from = sameSize ? selection.from : tr.mapping.map(selection.from, -1);
+          const to = sameSize ? selection.to : tr.mapping.map(selection.to, 1);
+          tr.setSelection(TextSelection.create(tr.doc, from, to));
+        } else tr.setSelection(selection.map(tr.doc, tr.mapping));
+        dispatch(tr);
+        return true;
+      }
+    };
+  }
+});
+
+// src/extensions/tableBorders.js
+import { Extension as Extension5 } from "@tiptap/core";
+import { isInTable, selectedRect } from "@tiptap/pm/tables";
+var KINDS = ["top", "bottom", "left", "right", "insideH", "insideV"];
+var BORDER_MODES = {
+  top: ["top"],
+  bottom: ["bottom"],
+  left: ["left"],
+  right: ["right"],
+  insideH: ["insideH"],
+  insideV: ["insideV"],
+  outside: ["top", "bottom", "left", "right"],
+  inside: ["insideH", "insideV"],
+  all: KINDS,
+  none: KINDS
+};
+var APPLY_ONLY = ["all", "none"];
+var collectEdges = (state) => {
+  if (!isInTable(state)) return null;
+  const rect = selectedRect(state);
+  const { map, tableStart } = rect;
+  const at = (row, col) => row < 0 || col < 0 || row >= map.height || col >= map.width ? null : tableStart + map.map[row * map.width + col];
+  const edges = Object.fromEntries(KINDS.map((k) => [k, []]));
+  const add = (kind, pairs) => {
+    const members = pairs.filter(([pos]) => pos !== null).map(([pos, attr]) => ({ pos, attr }));
+    if (members.length) edges[kind].push(members);
+  };
+  for (let row = rect.top; row <= rect.bottom; row += 1) {
+    for (let col = rect.left; col < rect.right; col += 1) {
+      const above = at(row - 1, col);
+      const below = at(row, col);
+      if (above !== null && above === below) continue;
+      const kind = row === rect.top ? "top" : row === rect.bottom ? "bottom" : "insideH";
+      add(kind, [[above, "borderBottom"], [below, "borderTop"]]);
+    }
+  }
+  for (let col = rect.left; col <= rect.right; col += 1) {
+    for (let row = rect.top; row < rect.bottom; row += 1) {
+      const left = at(row, col - 1);
+      const right = at(row, col);
+      if (left !== null && left === right) continue;
+      const kind = col === rect.left ? "left" : col === rect.right ? "right" : "insideV";
+      add(kind, [[left, "borderRight"], [right, "borderLeft"]]);
+    }
+  }
+  return edges;
+};
+var sideOf = (doc, { pos, attr }) => {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = doc.nodeAt(pos)) == null ? void 0 : _a.attrs) == null ? void 0 : _b[attr]) != null ? _c : null;
+};
+var isVisible = (doc, members) => members.some((m) => sideOf(doc, m) !== "none");
+var kindOn = (doc, list) => list.length > 0 && list.every((members) => isVisible(doc, members));
+var getTableBorderState = (state) => {
+  const edges = collectEdges(state);
+  if (!edges) return null;
+  const on = Object.fromEntries(KINDS.map((k) => [k, kindOn(state.doc, edges[k])]));
+  const exists = Object.fromEntries(KINDS.map((k) => [k, edges[k].length > 0]));
+  const present = KINDS.filter((k) => exists[k]);
+  const allOff = KINDS.every((k) => edges[k].every((members) => !isVisible(state.doc, members)));
+  const modeOn = (mode) => {
+    if (mode === "none") return allOff;
+    const kinds = BORDER_MODES[mode].filter((k) => exists[k]);
+    return kinds.length > 0 && kinds.every((k) => on[k]);
+  };
+  return {
+    ...Object.fromEntries(Object.keys(BORDER_MODES).map((m) => [m, modeOn(m)])),
+    exists,
+    hasInside: present.includes("insideH") || present.includes("insideV")
+  };
+};
+var edgeStyle = (doc, members) => {
+  const explicit = members.map((m) => sideOf(doc, m)).find((v) => v && v !== "none");
+  return explicit || DEFAULT_BORDER;
+};
+var TableBorders = Extension5.create({
+  name: "tableBorders",
+  addCommands() {
+    return {
+      setTableBorders: (mode) => ({ state, tr, dispatch }) => {
+        if (!BORDER_MODES[mode]) return false;
+        const edges = collectEdges(state);
+        if (!edges) return false;
+        const kinds = BORDER_MODES[mode].filter((k) => edges[k].length);
+        if (!kinds.length) return false;
+        const lists = kinds.flatMap((k) => edges[k]);
+        const turnOn = mode === "none" ? false : APPLY_ONLY.includes(mode) || !kinds.every((k) => kindOn(state.doc, edges[k]));
+        const updates = /* @__PURE__ */ new Map();
+        lists.forEach((members) => {
+          const value = turnOn ? edgeStyle(state.doc, members) : "none";
+          members.forEach(({ pos, attr }) => {
+            updates.set(pos, { ...updates.get(pos) || {}, [attr]: value });
+          });
+        });
+        if (!dispatch) return true;
+        updates.forEach((attrs, pos) => {
+          const node = tr.doc.nodeAt(pos);
+          if (node) tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...attrs });
+        });
+        dispatch(tr);
+        return true;
+      }
+    };
+  }
+});
+
+// src/extensions/index.js
+var sizeAttr = (key) => ({
+  default: null,
+  parseHTML: (el) => {
+    var _a;
+    const raw = el.getAttribute(key) || ((_a = el.style) == null ? void 0 : _a[key]);
+    const px = toPx(raw && /^\d+(\.\d+)?$/.test(raw) ? `${raw}px` : raw);
+    return px ? Math.round(px) : null;
+  },
+  renderHTML: (attrs) => attrs[key] ? { [key]: attrs[key] } : {}
+});
+var RichImage = Image.extend({
+  addAttributes() {
+    var _a;
+    return {
+      ...(_a = this.parent) == null ? void 0 : _a.call(this),
+      width: sizeAttr("width"),
+      height: sizeAttr("height")
+    };
+  }
+});
+var buildSchemaExtensions = ({ nodeIds = false } = {}) => {
+  const list = [
+    StarterKit.configure({
+      codeBlock: false,
+      heading: { levels: [1, 2, 3, 4] },
+      link: { openOnClick: false, autolink: true, defaultProtocol: "https" },
+      undoRedo: { depth: 200 }
+    }),
+    TextStyle,
+    Color,
+    BackgroundColor,
+    FontFamily,
+    FontSize,
+    TextAlign.configure({ types: ["heading", "paragraph"] }),
+    Subscript,
+    Superscript,
+    RichImage.configure({ allowBase64: true, inline: false }),
+    Table.configure({ resizable: true, allowTableNodeSelection: true }),
+    TableRow,
+    RichTableHeader,
+    RichTableCell,
+    ParagraphFormat
+  ];
+  if (nodeIds) list.push(NodeIds);
+  return list;
+};
+var buildEditorExtensions = ({
+  nodeIds,
+  placeholder,
+  onImageUpload,
+  maxImageSize,
+  onError
+} = {}) => [
+  ...buildSchemaExtensions({ nodeIds }),
+  ImageUpload.configure({ onImageUpload, maxImageSize, onError }),
+  TextCase,
+  TableBorders,
+  ...placeholder ? [Placeholder.configure({ placeholder })] : []
+];
+
+// src/paste/styleSheet.js
+var RULE_RE = /([^{}@]+)\{([^{}]*)\}/g;
+var stripComments = (css) => css.replace(/\/\*[\s\S]*?\*\//g, "");
+var removeAtRules = (css) => {
+  let out = "";
+  let i = 0;
+  while (i < css.length) {
+    const at = css.indexOf("@", i);
+    if (at < 0) {
+      out += css.slice(i);
+      break;
+    }
+    out += css.slice(i, at);
+    let depth = 0;
+    let j = at;
+    for (; j < css.length; j += 1) {
+      const ch = css[j];
+      if (ch === ";" && depth === 0) break;
+      if (ch === "{") depth += 1;
+      if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) break;
+      }
+    }
+    i = j + 1;
+  }
+  return out;
+};
+var parseStyleRules = (cssText) => {
+  const css = removeAtRules(stripComments(cssText || "").replace(/<!--|-->/g, ""));
+  const rules = [];
+  let match;
+  RULE_RE.lastIndex = 0;
+  while (match = RULE_RE.exec(css)) {
+    const declarations = match[2].trim();
+    if (!declarations) continue;
+    match[1].split(",").map((s) => s.trim()).filter(Boolean).forEach((selector) => rules.push({ selector, declarations }));
+  }
+  return rules;
+};
+var inlineStyleRules = (doc) => {
+  const styleEls = Array.from(doc.querySelectorAll("style"));
+  if (!styleEls.length) return;
+  const rules = styleEls.flatMap((el) => parseStyleRules(el.textContent));
+  const collected = /* @__PURE__ */ new Map();
+  rules.forEach(({ selector, declarations }) => {
+    if (/[:]{1,2}[a-z-]+/i.test(selector.replace(/\\:/g, ""))) return;
+    let nodes;
+    try {
+      nodes = doc.body.querySelectorAll(selector);
+    } catch (e) {
+      return;
+    }
+    nodes.forEach((node) => {
+      collected.set(node, `${collected.get(node) || ""}${declarations};`);
+    });
+  });
+  collected.forEach((declarations, node) => {
+    const own = node.getAttribute("style") || "";
+    node.setAttribute("style", `${declarations}${own}`);
+  });
+  styleEls.forEach((el) => el.remove());
+};
+
+// src/paste/wordLists.js
+var MSO_LIST_RE = /mso-list\s*:\s*(l\d+)\s+level(\d+)/i;
+var ORDERED_MARKER_RE = /^\(?([0-9]+|[a-z]|[ivxlcdm]+)[.)]$/i;
+var getStyleAttr = (el) => el.getAttribute("style") || "";
+var isIgnoreSpan = (el) => el.nodeType === 1 && /mso-list\s*:\s*ignore/i.test(getStyleAttr(el));
+var takeMarker = (p) => {
+  const ignore = Array.from(p.querySelectorAll("span")).find(isIgnoreSpan);
+  if (!ignore) return "";
+  const text = (ignore.textContent || "").replace(/ /g, " ").trim();
+  let target = ignore;
+  while (target.parentElement && target.parentElement !== p && (target.parentElement.textContent || "").trim() === (ignore.textContent || "").trim()) {
+    target = target.parentElement;
+  }
+  target.remove();
+  return text;
+};
+var listTypeFor = (marker) => {
+  const m = marker.match(ORDERED_MARKER_RE);
+  if (!m) return { tag: "ul" };
+  const token = m[1];
+  if (/^\d+$/.test(token)) return { tag: "ol", type: "1", start: parseInt(token, 10) };
+  if (/^[ivxlcdm]+$/.test(token) && token.length > 1) {
+    return { tag: "ol", type: token === token.toLowerCase() ? "i" : "I" };
+  }
+  if (/^[a-z]$/.test(token)) return { tag: "ol", type: "a", start: token.charCodeAt(0) - 96 };
+  return { tag: "ol", type: "A", start: token.charCodeAt(0) - 64 };
+};
+var LIST_STYLE_PROPS = ["margin-left", "text-indent", "margin"];
+var cleanListParagraphStyle = (p) => {
+  const kept = getStyleAttr(p).split(";").filter((decl) => {
+    var _a;
+    const prop = (_a = decl.split(":")[0]) == null ? void 0 : _a.trim().toLowerCase();
+    return prop && !LIST_STYLE_PROPS.includes(prop) && !prop.startsWith("mso-");
+  });
+  if (kept.length) p.setAttribute("style", kept.join(";"));
+  else p.removeAttribute("style");
+};
+var isListParagraph = (el) => (el == null ? void 0 : el.nodeType) === 1 && el.tagName === "P" && MSO_LIST_RE.test(getStyleAttr(el));
+var buildList = (doc, items) => {
+  const root = { level: 0, el: null, children: [] };
+  const stack = [];
+  items.forEach(({ level, info, p }) => {
+    while (stack.length && stack[stack.length - 1].level > level) stack.pop();
+    let current = stack[stack.length - 1];
+    if (!current || current.level < level) {
+      const listEl = doc.createElement(info.tag);
+      if (info.type && info.type !== "1") listEl.setAttribute("type", info.type);
+      if (info.start && info.start !== 1) listEl.setAttribute("start", String(info.start));
+      const parentLi = current == null ? void 0 : current.lastLi;
+      if (parentLi) parentLi.appendChild(listEl);
+      else root.children.push(listEl);
+      current = { level, el: listEl, lastLi: null };
+      stack.push(current);
+    }
+    const li = doc.createElement("li");
+    cleanListParagraphStyle(p);
+    li.appendChild(p);
+    current.el.appendChild(li);
+    current.lastLi = li;
+  });
+  return root.children;
+};
+var convertWordLists = (doc, container = doc.body) => {
+  var _a;
+  const children = Array.from(container.children);
+  let i = 0;
+  while (i < children.length) {
+    const el = children[i];
+    if (!isListParagraph(el)) {
+      if (((_a = el.children) == null ? void 0 : _a.length) && !["P", "UL", "OL"].includes(el.tagName)) {
+        convertWordLists(doc, el);
+      }
+      i += 1;
+      continue;
+    }
+    const items = [];
+    const anchor = el;
+    let j = i;
+    let listId = null;
+    while (j < children.length && isListParagraph(children[j])) {
+      const p = children[j];
+      const [, id, levelStr] = getStyleAttr(p).match(MSO_LIST_RE);
+      if (listId && id !== listId && parseInt(levelStr, 10) === 1) break;
+      listId = listId || id;
+      const marker = takeMarker(p);
+      items.push({ level: parseInt(levelStr, 10), info: listTypeFor(marker), p });
+      j += 1;
+    }
+    const placeholder = doc.createElement("span");
+    container.insertBefore(placeholder, anchor);
+    buildList(doc, items).forEach((list) => container.insertBefore(list, placeholder));
+    placeholder.remove();
+    i = j;
+  }
+};
+
+// src/paste/cleanHtml.js
+var REMOVE_TAGS = ["meta", "link", "script", "title", "xml", "head", "object", "embed", "iframe"];
+var DROP_STYLE_PROPS = [
+  "tab-stops",
+  "layout-grid-mode",
+  "text-autospace",
+  "text-justify",
+  "punctuation-wrap",
+  "word-break",
+  "page-break-before",
+  "page-break-after",
+  "page-break-inside",
+  "break-before",
+  "break-after",
+  "font-variant-ligatures",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-numeric",
+  "orphans",
+  "widows",
+  "white-space",
+  "caret-color",
+  "text-decoration-thickness",
+  "text-decoration-style",
+  "text-decoration-color",
+  "-webkit-text-stroke-width",
+  "letter-spacing",
+  "word-spacing"
+];
+var CELL_TEXT_PROPS = ["color", "font-weight", "font-style", "font-size", "font-family", "text-decoration"];
+var isWordHtml = (html) => /urn:schemas-microsoft-com:office|class="?Mso|mso-[a-z-]+\s*:|<o:p>|ProgId"? content="?(Word|Excel)/i.test(
+  html || ""
+);
+var filterDeclarations = (style) => style.split(";").map((d) => d.trim()).filter(Boolean).filter((decl) => {
+  const idx = decl.indexOf(":");
+  if (idx < 1) return false;
+  const prop = decl.slice(0, idx).trim().toLowerCase();
+  if (prop.startsWith("mso-") || prop.startsWith("-ms-")) return false;
+  return !DROP_STYLE_PROPS.includes(prop);
+}).map(
+  (decl) => decl.replace(/\bwindowtext\b/gi, "#000000").replace(/(\d)\.0+(?=[a-z%])/gi, "$1").replace(/\bauto\b(?=\s*$)/i, "")
+).filter((decl) => !/:\s*$/.test(decl));
+var cleanStyleAttr = (el) => {
+  const style = el.getAttribute("style");
+  if (style === null) return;
+  const kept = filterDeclarations(style);
+  if (kept.length) el.setAttribute("style", kept.join("; "));
+  else el.removeAttribute("style");
+};
+var unwrap = (el) => {
+  const parent = el.parentNode;
+  if (!parent) return;
+  while (el.firstChild) parent.insertBefore(el.firstChild, el);
+  parent.removeChild(el);
+};
+var removeComments = (root) => {
+  const walker = root.ownerDocument.createTreeWalker(root, 128);
+  const comments = [];
+  while (walker.nextNode()) comments.push(walker.currentNode);
+  comments.forEach((c) => c.remove());
+};
+var isNamespaced = (el) => el.tagName.includes(":");
+var appendStyle = (el, decl) => {
+  const own = el.getAttribute("style");
+  el.setAttribute("style", own ? `${own.replace(/;?\s*$/, "")}; ${decl}` : decl);
+};
+var moveAlignAttr = (el) => {
+  const align = el.getAttribute("align");
+  if (!align) return;
+  if (!/text-align/i.test(el.getAttribute("style") || "")) {
+    appendStyle(el, `text-align: ${align.toLowerCase()}`);
+  }
+  el.removeAttribute("align");
+};
+var convertFontTag = (doc, el) => {
+  const span = doc.createElement("span");
+  const decls = [];
+  if (el.getAttribute("color")) decls.push(`color: ${el.getAttribute("color")}`);
+  if (el.getAttribute("face")) decls.push(`font-family: ${el.getAttribute("face")}`);
+  const own = el.getAttribute("style");
+  if (own) decls.push(own);
+  if (decls.length) span.setAttribute("style", decls.join("; "));
+  while (el.firstChild) span.appendChild(el.firstChild);
+  el.replaceWith(span);
+};
+var wrapCellText = (doc, cell) => {
+  const style = cell.getAttribute("style") || "";
+  const moved = [];
+  const kept = [];
+  style.split(";").map((d) => d.trim()).filter(Boolean).forEach((decl) => {
+    const prop = decl.split(":")[0].trim().toLowerCase();
+    (CELL_TEXT_PROPS.includes(prop) ? moved : kept).push(decl);
+  });
+  if (!moved.length) return;
+  const span = doc.createElement("span");
+  span.setAttribute("style", moved.join("; "));
+  const blocks = cell.querySelectorAll("p, div, h1, h2, h3, h4, h5, h6, li");
+  if (blocks.length) {
+    blocks.forEach((block) => {
+      const inner = span.cloneNode(false);
+      while (block.firstChild) inner.appendChild(block.firstChild);
+      block.appendChild(inner);
+    });
+  } else {
+    while (cell.firstChild) span.appendChild(cell.firstChild);
+    cell.appendChild(span);
+  }
+  if (kept.length) cell.setAttribute("style", kept.join("; "));
+  else cell.removeAttribute("style");
+};
+var cellWidthFromStyle = (cell) => {
+  var _a;
+  if (cell.getAttribute("colwidth")) return;
+  const width = cell.getAttribute("width");
+  const styleWidth = (_a = (cell.getAttribute("style") || "").match(/(?:^|;)\s*width\s*:\s*([^;]+)/i)) == null ? void 0 : _a[1];
+  const value = styleWidth || (width && /^\d+(\.\d+)?$/.test(width) ? `${width}px` : null);
+  if (value) cell.setAttribute("data-width", value.trim());
+};
+var isEmptyInline = (el) => !el.attributes.length || el.attributes.length === 1 && el.hasAttribute("lang");
+var cleanElement = (doc, el, word) => {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "font") return convertFontTag(doc, el);
+  if (isNamespaced(el)) {
+    if (tag === "o:p" && !el.textContent) return el.remove();
+    return unwrap(el);
+  }
+  if (tag === "img") {
+    const src = el.getAttribute("src") || "";
+    if (/^(file|cid|blob):/i.test(src) || !src) return el.remove();
+  }
+  if (word && el.hasAttribute("v:shapes")) el.removeAttribute("v:shapes");
+  ["p", "div", "td", "th", "h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) && moveAlignAttr(el);
+  if (tag === "td" || tag === "th") cellWidthFromStyle(el);
+  cleanStyleAttr(el);
+  if (tag === "td" || tag === "th") wrapCellText(doc, el);
+  if (word) {
+    el.removeAttribute("class");
+    el.removeAttribute("lang");
+  }
+  if (tag === "b" && /docs-internal-guid/.test(el.id || "")) return unwrap(el);
+  if (tag === "span" && isEmptyInline(el)) return unwrap(el);
+  return void 0;
+};
+var walk = (doc, root, word) => {
+  Array.from(root.children).forEach((child) => {
+    walk(doc, child, word);
+    cleanElement(doc, child, word);
+  });
+};
+var applyBorderlessTables = (doc) => {
+  doc.body.querySelectorAll("table").forEach((table) => {
+    const attr = table.getAttribute("border");
+    const style = (table.getAttribute("style") || "").toLowerCase();
+    const noBorder = attr === "0" || /(^|;)\s*border\s*:\s*(none|0(px)?)\s*(;|$)/.test(style);
+    if (!noBorder) return;
+    Array.from(table.rows || []).forEach(
+      (row) => Array.from(row.cells || []).forEach((cell) => {
+        if (!/border/i.test(cell.getAttribute("style") || "")) appendStyle(cell, "border: none");
+      })
+    );
+  });
+};
+var parse = (html) => new DOMParser().parseFromString(html, "text/html");
+var cleanHtml = (html) => {
+  if (!html || typeof html !== "string") return html || "";
+  if (typeof DOMParser === "undefined") return html;
+  const word = isWordHtml(html);
+  const fragmentMatch = html.match(/<!--StartFragment-->([\s\S]*?)<!--EndFragment-->/);
+  const doc = parse(html);
+  if (fragmentMatch && doc.querySelectorAll("style").length === 0) {
+    doc.body.innerHTML = fragmentMatch[1];
+  }
+  inlineStyleRules(doc);
+  if (!word) applyBorderlessTables(doc);
+  if (word) convertWordLists(doc);
+  removeComments(doc.body);
+  REMOVE_TAGS.forEach((t) => doc.body.querySelectorAll(t).forEach((el) => el.remove()));
+  walk(doc, doc.body, word);
+  return doc.body.innerHTML;
+};
+
+// src/utils/listMarkers.js
+var BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+var toAlpha = (n) => {
+  let s = "";
+  let x = n;
+  while (x > 0) {
+    const r = (x - 1) % 26;
+    s = String.fromCharCode(97 + r) + s;
+    x = Math.floor((x - 1) / 26);
+  }
+  return s;
+};
+var ROMAN = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+var toRoman = (n) => {
+  let x = n;
+  return ROMAN.reduce((acc, [v, s]) => {
+    let out = acc;
+    while (x >= v) {
+      out += s;
+      x -= v;
+    }
+    return out;
+  }, "");
+};
+var formatNumber = (n, type) => {
+  switch (type) {
+    case "a":
+      return toAlpha(n);
+    case "A":
+      return toAlpha(n).toUpperCase();
+    case "i":
+      return toRoman(n);
+    case "I":
+      return toRoman(n).toUpperCase();
+    default:
+      return String(n);
+  }
+};
+var listMarker = (listNode, index, depth = 0, bullets = BULLETS) => {
+  var _a, _b, _c;
+  if (listNode.type === "orderedList") {
+    const start = (_b = (_a = listNode.attrs) == null ? void 0 : _a.start) != null ? _b : 1;
+    return `${formatNumber(start + index, (_c = listNode.attrs) == null ? void 0 : _c.type)}.`;
+  }
+  return bullets[depth % bullets.length];
+};
+
+// src/output/text.js
+var inlineText = (node) => {
+  if (node.type === "text") return node.text || "";
+  if (node.type === "hardBreak") return "\n";
+  return (node.content || []).map(inlineText).join("");
+};
+var blockToLines = (node, depth = 0) => {
+  const pad = "  ".repeat(depth);
+  switch (node.type) {
+    case "paragraph":
+    case "heading":
+      return [inlineText(node)];
+    case "bulletList":
+    case "orderedList":
+      return (node.content || []).flatMap((item, index) => {
+        const marker = listMarker(node, index, depth);
+        const [first = "", ...rest] = (item.content || []).flatMap(
+          (child) => blockToLines(child, child.type.endsWith("List") ? depth + 1 : depth)
+        );
+        return [`${pad}${marker} ${first}`, ...rest];
+      });
+    case "table":
+      return (node.content || []).map(
+        (row) => (row.content || []).map(
+          (cell) => (cell.content || []).flatMap((c) => blockToLines(c, 0)).join(" ").trim()
+        ).join("	")
+      );
+    case "blockquote":
+      return (node.content || []).flatMap((c) => blockToLines(c, depth));
+    case "horizontalRule":
+      return ["---"];
+    case "image":
+      return [];
+    default:
+      return node.content ? node.content.flatMap((c) => blockToLines(c, depth)) : [];
+  }
+};
+var jsonToText = (json) => ((json == null ? void 0 : json.content) || []).flatMap((node) => blockToLines(node)).join("\n").replace(/ /g, " ");
+
+// src/pdf/options.js
+var STANDARD_FONTS = [
+  "Helvetica",
+  "Helvetica-Bold",
+  "Helvetica-Oblique",
+  "Helvetica-BoldOblique",
+  "Times-Roman",
+  "Times-Bold",
+  "Times-Italic",
+  "Times-BoldItalic",
+  "Courier",
+  "Courier-Bold",
+  "Courier-Oblique",
+  "Courier-BoldOblique"
+];
+var DEFAULT_PDF_OPTIONS = {
+  // Base text size in pt; headings scale from it. Only set on the output
+  // when passed explicitly, otherwise the surrounding react-pdf font size wins.
+  fontSize: 10,
+  // Drop font sizes stored in the content (like the old removeFontSize helper).
+  ignoreFontSizes: false,
+  fontFamily: null,
+  color: null,
+  lineHeight: null,
+  // react-pdf throws on fonts that are not registered, so a CSS font-family
+  // is only kept when it is in `fonts` (registered names) or `fontMap`.
+  fonts: [],
+  fontMap: {},
+  // Unknown families fall back to inheriting the surrounding font.
+  monospaceFont: "Courier",
+  paragraphSpacing: 4,
+  listItemSpacing: 1,
+  headingScale: { 1: 2, 2: 1.6, 3: 1.3, 4: 1.15 },
+  headingSpacing: { top: 6, bottom: 4 },
+  listIndent: 14,
+  bullets: ["\u2022", "\u2022", "\u2022"],
+  tableBorder: "0.75pt solid #000000",
+  cellPadding: { vertical: 2, horizontal: 4 },
+  linkColor: "#2d5cf2",
+  // Keep table rows on one page.
+  keepRowsTogether: true,
+  // Per-node style overrides merged last, e.g. { paragraph: { color: '#333' } }.
+  styles: {}
+};
+var resolveOptions = (options = {}) => ({
+  ...DEFAULT_PDF_OPTIONS,
+  ...options,
+  explicitFontSize: options.fontSize !== void 0 && options.fontSize !== null,
+  headingScale: { ...DEFAULT_PDF_OPTIONS.headingScale, ...options.headingScale || {} },
+  headingSpacing: { ...DEFAULT_PDF_OPTIONS.headingSpacing, ...options.headingSpacing || {} },
+  cellPadding: { ...DEFAULT_PDF_OPTIONS.cellPadding, ...options.cellPadding || {} },
+  styles: options.styles || {}
+});
+var cleanFamily = (name) => name.trim().replace(/^["']|["']$/g, "").trim();
+var resolveFontFamily = (cssValue, opts) => {
+  if (!cssValue) return null;
+  const allowed = new Map(
+    [...opts.fonts || [], ...STANDARD_FONTS].map((f) => [f.toLowerCase(), f])
+  );
+  const map = Object.fromEntries(
+    Object.entries(opts.fontMap || {}).map(([k, v]) => [k.toLowerCase(), v])
+  );
+  const candidates = String(cssValue).split(",").map(cleanFamily).filter(Boolean);
+  for (const name of candidates) {
+    const key = name.toLowerCase();
+    if (map[key]) return map[key];
+    if (allowed.has(key)) return allowed.get(key);
+  }
+  return null;
+};
+
+// src/utils/colors.js
+var NAMED = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  gray: "#808080",
+  grey: "#808080",
+  silver: "#c0c0c0",
+  maroon: "#800000",
+  navy: "#000080",
+  teal: "#008080",
+  olive: "#808000",
+  purple: "#800080",
+  orange: "#ffa500",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  cyan: "#00ffff",
+  fuchsia: "#ff00ff",
+  magenta: "#ff00ff"
+};
+var hex2 = (n) => Math.max(0, Math.min(255, Math.round(Number(n)))).toString(16).padStart(2, "0");
+var toHexColor = (value) => {
+  if (!value) return null;
+  const str = String(value).trim().toLowerCase();
+  if (!str || str === "transparent" || str === "inherit" || str === "initial" || str === "auto") return null;
+  if (/^#[0-9a-f]{6}$/.test(str)) return str;
+  if (/^#[0-9a-f]{3}$/.test(str)) return `#${str[1]}${str[1]}${str[2]}${str[2]}${str[3]}${str[3]}`;
+  if (/^#[0-9a-f]{8}$/.test(str)) return str.slice(0, 7);
+  const m = str.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.]+%?))?\s*\)$/);
+  if (m) {
+    if (m[4] !== void 0 && parseFloat(m[4]) === 0) return null;
+    return `#${hex2(m[1])}${hex2(m[2])}${hex2(m[3])}`;
+  }
+  if (str === "windowtext" || str === "currentcolor") return "#000000";
+  return NAMED[str] || null;
+};
+
+// src/pdf/inline.js
+var SCRIPT_RATIO = 0.7;
+var decorations = (marks) => {
+  const parts = [];
+  if (marks.some((m) => m.type === "underline" || m.type === "link")) parts.push("underline");
+  if (marks.some((m) => m.type === "strike")) parts.push("line-through");
+  return parts.length ? parts.join(" ") : null;
+};
+var markStyle = (marks = [], ctx, opts) => {
+  const style = {};
+  let fontSize = null;
+  marks.forEach((mark) => {
+    const a = mark.attrs || {};
+    switch (mark.type) {
+      case "bold":
+        style.fontWeight = "bold";
+        break;
+      case "italic":
+        style.fontStyle = "italic";
+        break;
+      case "code":
+        style.fontFamily = opts.monospaceFont;
+        break;
+      case "link":
+        style.color = opts.linkColor;
+        break;
+      case "textStyle": {
+        const color = toHexColor(a.color);
+        if (color) style.color = color;
+        const bg = toHexColor(a.backgroundColor);
+        if (bg) style.backgroundColor = bg;
+        const pt = toPt(a.fontSize, ctx.fontSize * 4 / 3);
+        if (pt && !opts.ignoreFontSizes) fontSize = pt;
+        const family = resolveFontFamily(a.fontFamily, opts);
+        if (family) style.fontFamily = family;
+        break;
+      }
+      default:
+        break;
+    }
+  });
+  const textDecoration = decorations(marks);
+  if (textDecoration) style.textDecoration = textDecoration;
+  const script = marks.find((m) => m.type === "subscript" || m.type === "superscript");
+  if (script) {
+    style.verticalAlign = script.type === "subscript" ? "sub" : "super";
+    fontSize = (fontSize || ctx.fontSize) * SCRIPT_RATIO;
+  }
+  if (fontSize) style.fontSize = Math.round(fontSize * 100) / 100;
+  return style;
+};
+var isEmptyStyle = (style) => !Object.keys(style).length;
+var convertInline = (nodes = [], ctx, opts) => {
+  const out = [];
+  nodes.forEach((node) => {
+    var _a, _b;
+    if (node.type === "hardBreak") {
+      out.push("\n");
+      return;
+    }
+    if (node.type !== "text" || !node.text) return;
+    const style = markStyle(node.marks, ctx, opts);
+    const textNode = isEmptyStyle(style) ? node.text : { type: "text", style: { ...style, ...opts.styles.text || {} }, children: [node.text] };
+    const link = (_a = node.marks) == null ? void 0 : _a.find((m) => m.type === "link");
+    if ((_b = link == null ? void 0 : link.attrs) == null ? void 0 : _b.href) {
+      out.push({
+        type: "link",
+        src: link.attrs.href,
+        style: { ...opts.styles.link || {} },
+        children: [textNode]
+      });
+    } else {
+      out.push(textNode);
+    }
+  });
+  return out;
+};
+
+// src/pdf/table.js
+var PDF_BORDER_STYLES = ["solid", "dashed", "dotted"];
+var borderToPdf = (value) => {
+  if (!value || value === "none") return null;
+  const side = parseBorders(`border-top: ${value}`).top;
+  const formatted = formatBorder(side);
+  if (!formatted || formatted === "none") return null;
+  const [width, style] = formatted.split(" ");
+  const pt = Math.max(pxToPt(toPx(width) || 1), 0.25);
+  const color = toHexColor(side.color) || "#000000";
+  return `${pt}pt ${PDF_BORDER_STYLES.includes(style) ? style : "solid"} ${color}`;
+};
+var buildGrid = (rows) => {
+  const occupied = [];
+  const placements = [];
+  let numCols = 0;
+  rows.forEach((row, r) => {
+    occupied[r] = occupied[r] || [];
+    let c = 0;
+    (row.content || []).forEach((cell) => {
+      var _a, _b;
+      while (occupied[r][c]) c += 1;
+      const colspan = ((_a = cell.attrs) == null ? void 0 : _a.colspan) || 1;
+      const rowspan = ((_b = cell.attrs) == null ? void 0 : _b.rowspan) || 1;
+      const placement = { cell, r, c, colspan, rowspan };
+      placements.push(placement);
+      for (let dr = 0; dr < rowspan; dr += 1) {
+        occupied[r + dr] = occupied[r + dr] || [];
+        for (let dc = 0; dc < colspan; dc += 1) occupied[r + dr][c + dc] = placement;
+      }
+      c += colspan;
+      numCols = Math.max(numCols, c);
+    });
+  });
+  return { occupied: occupied.slice(0, rows.length), placements, numCols };
+};
+var columnWidths = (placements, numCols) => {
+  const widths = Array(numCols).fill(null);
+  placements.forEach(({ cell, c, colspan }) => {
+    var _a;
+    const cw = (_a = cell.attrs) == null ? void 0 : _a.colwidth;
+    if (!Array.isArray(cw)) return;
+    for (let i = 0; i < colspan; i += 1) {
+      if (widths[c + i] === null && cw[i]) widths[c + i] = cw[i];
+    }
+  });
+  const known = widths.filter((w) => w !== null);
+  const complete = known.length === numCols;
+  const fallback = known.length ? known.reduce((a, b) => a + b, 0) / known.length : 100;
+  const filled = widths.map((w) => w === null ? fallback : w);
+  const total = filled.reduce((a, b) => a + b, 0) || 1;
+  return {
+    percents: filled.map((w) => w / total * 100),
+    totalPt: complete ? pxToPt(total) : null
+  };
+};
+var VALIGN = { middle: "center", bottom: "flex-end", top: "flex-start" };
+var resolveEdge = (own, other, hasNeighbour, opts) => {
+  const visible = [own, other].find((v) => v && v !== "none");
+  if (visible) return borderToPdf(visible);
+  if (!own || hasNeighbour && !other) return opts.tableBorder;
+  return null;
+};
+var cellBorders = (p, r, c, occupied, opts) => {
+  var _a, _b, _c, _d;
+  const attrs = p.cell.attrs || {};
+  const right = (_a = occupied[r]) == null ? void 0 : _a[c + p.colspan];
+  const below = (_b = occupied[p.r + p.rowspan]) == null ? void 0 : _b[c];
+  const style = {
+    borderTop: p.r === 0 ? resolveEdge(attrs.borderTop, null, false, opts) : null,
+    borderLeft: c === 0 ? resolveEdge(attrs.borderLeft, null, false, opts) : null,
+    borderRight: resolveEdge(attrs.borderRight, (_c = right == null ? void 0 : right.cell.attrs) == null ? void 0 : _c.borderLeft, !!right, opts),
+    borderBottom: resolveEdge(attrs.borderBottom, (_d = below == null ? void 0 : below.cell.attrs) == null ? void 0 : _d.borderTop, !!below, opts)
+  };
+  return Object.fromEntries(Object.entries(style).filter(([, v]) => v));
+};
+var pct = (n) => `${round(n, 4)}%`;
+var convertTable = (node, ctx, opts, convertBlocks) => {
+  const rows = node.content || [];
+  if (!rows.length) return null;
+  const { occupied, numCols, placements } = buildGrid(rows);
+  const { percents, totalPt } = columnWidths(placements, numCols);
+  const { vertical, horizontal } = opts.cellPadding;
+  const rowNodes = occupied.map((slots, r) => {
+    const children = [];
+    for (let c = 0; c < numCols; c += 1) {
+      const p = slots == null ? void 0 : slots[c];
+      if (!p) {
+        children.push({ type: "view", style: { width: pct(percents[c]) }, children: [] });
+        continue;
+      }
+      if (p.c !== c) continue;
+      const width = pct(percents.slice(c, c + p.colspan).reduce((a, b) => a + b, 0));
+      const attrs = p.cell.attrs || {};
+      const borders = cellBorders(p, r, c, occupied, opts);
+      const bg = toHexColor(attrs.backgroundColor);
+      const isStart = p.r === r;
+      const isEnd = p.r + p.rowspan - 1 === r;
+      const style = {
+        width,
+        paddingTop: isStart ? vertical : 0,
+        paddingBottom: isEnd ? vertical : 0,
+        paddingLeft: horizontal,
+        paddingRight: horizontal,
+        ...bg ? { backgroundColor: bg } : {},
+        ...borders.borderLeft ? { borderLeft: borders.borderLeft } : {},
+        ...borders.borderRight ? { borderRight: borders.borderRight } : {},
+        ...isStart && borders.borderTop ? { borderTop: borders.borderTop } : {},
+        ...isEnd && borders.borderBottom ? { borderBottom: borders.borderBottom } : {},
+        justifyContent: VALIGN[attrs.verticalAlign] || "flex-start",
+        ...opts.styles[p.cell.type] || {}
+      };
+      const content = isStart ? convertBlocks(p.cell.content || [], {
+        ...ctx,
+        inCell: true,
+        align: attrs.align || null,
+        bold: p.cell.type === "tableHeader"
+      }) : [];
+      children.push({ type: "view", style, children: content });
+    }
+    return {
+      type: "view",
+      style: { flexDirection: "row", ...opts.styles.tableRow || {} },
+      props: opts.keepRowsTogether ? { wrap: false } : void 0,
+      children
+    };
+  });
+  return {
+    type: "view",
+    style: {
+      flexDirection: "column",
+      width: totalPt ? `${totalPt}pt` : "100%",
+      maxWidth: "100%",
+      marginBottom: ctx.inCell ? 2 : opts.paragraphSpacing,
+      ...opts.styles.table || {}
+    },
+    children: rowNodes
+  };
+};
+
+// src/pdf/tree.js
+var PDF_TREE_VERSION = 1;
+var paragraphStyle = (attrs = {}, ctx, opts, base = {}) => {
+  const style = { ...base };
+  const align = attrs.textAlign || ctx.align;
+  if (align && align !== "left") style.textAlign = align;
+  if (attrs.marginLeft) style.marginLeft = pxToPt(attrs.marginLeft);
+  if (attrs.textIndent) {
+    const indent = pxToPt(attrs.textIndent);
+    style.textIndent = Math.max(indent, -(style.marginLeft || 0));
+  }
+  if (attrs.marginTop) style.marginTop = pxToPt(attrs.marginTop);
+  if (attrs.marginBottom !== null && attrs.marginBottom !== void 0) {
+    style.marginBottom = pxToPt(attrs.marginBottom);
+  }
+  const lineHeight = attrs.lineHeight || opts.lineHeight;
+  if (lineHeight) style.lineHeight = lineHeight;
+  if (ctx.bold) style.fontWeight = "bold";
+  return style;
+};
+var textBlock = (node, ctx, opts, base) => {
+  const children = convertInline(node.content, ctx, opts);
+  return {
+    type: "text",
+    style: paragraphStyle(node.attrs, ctx, opts, base),
+    children: children.length ? children : [" "]
+  };
+};
+var defaultSpacing = (ctx, opts) => {
+  if (ctx.inCell) return 0;
+  if (ctx.inList) return opts.listItemSpacing;
+  return opts.paragraphSpacing;
+};
+var convertList = (node, ctx, opts, convertBlocks) => {
+  const depth = ctx.listDepth || 0;
+  const items = (node.content || []).map((item, index) => {
+    const marker = listMarker(node, index, depth, opts.bullets);
+    return {
+      type: "view",
+      style: { flexDirection: "row", ...opts.styles.listItem || {} },
+      children: [
+        {
+          type: "text",
+          style: { width: opts.listIndent, ...opts.styles.listMarker || {} },
+          children: [marker]
+        },
+        {
+          type: "view",
+          style: { flex: 1 },
+          children: convertBlocks(item.content || [], {
+            ...ctx,
+            inList: true,
+            listDepth: depth + 1
+          })
+        }
+      ]
+    };
+  });
+  return {
+    type: "view",
+    style: {
+      marginBottom: depth ? 0 : defaultSpacing({ ...ctx, inList: false }, opts),
+      ...opts.styles.list || {}
+    },
+    children: items
+  };
+};
+var convertBlock = (node, ctx, opts, convertBlocks) => {
+  var _a;
+  switch (node.type) {
+    case "paragraph":
+      return textBlock(node, ctx, opts, {
+        marginBottom: defaultSpacing(ctx, opts),
+        ...opts.styles.paragraph || {}
+      });
+    case "heading": {
+      const level = ((_a = node.attrs) == null ? void 0 : _a.level) || 1;
+      const fontSize = Math.round(opts.fontSize * (opts.headingScale[level] || 1) * 100) / 100;
+      return textBlock(node, { ...ctx, fontSize }, opts, {
+        fontSize,
+        fontWeight: "bold",
+        marginTop: ctx.inCell ? 0 : opts.headingSpacing.top,
+        marginBottom: ctx.inCell ? 0 : opts.headingSpacing.bottom,
+        ...opts.styles.heading || {},
+        ...opts.styles[`heading${level}`] || {}
+      });
+    }
+    case "bulletList":
+    case "orderedList":
+      return convertList(node, ctx, opts, convertBlocks);
+    case "table":
+      return convertTable(node, ctx, opts, convertBlocks);
+    case "blockquote":
+      return {
+        type: "view",
+        style: {
+          borderLeft: "2pt solid #cccccc",
+          paddingLeft: 8,
+          marginBottom: defaultSpacing(ctx, opts),
+          ...opts.styles.blockquote || {}
+        },
+        children: convertBlocks(node.content || [], ctx)
+      };
+    case "horizontalRule":
+      return {
+        type: "view",
+        style: {
+          borderBottom: "0.75pt solid #999999",
+          marginVertical: 4,
+          ...opts.styles.horizontalRule || {}
+        },
+        children: []
+      };
+    case "image": {
+      const { src, width, height } = node.attrs || {};
+      if (!src) return null;
+      const style = { maxWidth: "100%", marginBottom: defaultSpacing(ctx, opts) };
+      if (width) style.width = pxToPt(width);
+      if (height) style.height = pxToPt(height);
+      return { type: "image", src, style: { ...style, ...opts.styles.image || {} } };
+    }
+    default:
+      return node.content ? { type: "view", style: {}, children: convertBlocks(node.content, ctx) } : null;
+  }
+};
+var jsonToPdfTree = (json, options) => {
+  const opts = resolveOptions(options);
+  const ctx = { fontSize: opts.fontSize };
+  const convertBlocks = (nodes, c) => (nodes || []).map((n) => convertBlock(n, c, opts, convertBlocks)).filter(Boolean);
+  const rootStyle = opts.explicitFontSize ? { fontSize: opts.fontSize } : {};
+  if (opts.fontFamily) rootStyle.fontFamily = opts.fontFamily;
+  if (opts.color) rootStyle.color = opts.color;
+  return {
+    type: "root",
+    version: PDF_TREE_VERSION,
+    style: { ...rootStyle, ...opts.styles.root || {} },
+    children: convertBlocks((json == null ? void 0 : json.content) || [], ctx)
+  };
+};
+var isPdfTree = (value) => !!value && typeof value === "object" && value.type === "root" && Array.isArray(value.children);
+
+// src/output/convert.js
+import { getSchema } from "@tiptap/core";
+import { DOMParser as PMDOMParser, DOMSerializer, Node as PMNode } from "@tiptap/pm/model";
+var cachedSchema = null;
+var getEditorSchema = () => {
+  if (!cachedSchema) cachedSchema = getSchema(buildSchemaExtensions({ nodeIds: true }));
+  return cachedSchema;
+};
+var EMPTY_DOC = { type: "doc", content: [{ type: "paragraph" }] };
+var isDocJson = (value) => !!value && typeof value === "object" && value.type === "doc";
+var looksLikeHtml = (str) => /<\/?[a-z][\s\S]*>/i.test(str);
+var escapeHtml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var textToHtml = (text) => String(text).split(/\r?\n/).map((line) => `<p>${escapeHtml(line)}</p>`).join("");
+var normalizeHtmlInput = (value) => {
+  if (value === null || value === void 0) return "";
+  const str = String(value);
+  if (!str.trim()) return "";
+  return looksLikeHtml(str) ? cleanHtml(str) : textToHtml(str);
+};
+var htmlToJSON = (html) => {
+  const schema = getEditorSchema();
+  const clean = normalizeHtmlInput(html);
+  if (!clean) return EMPTY_DOC;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("htmlToJSON needs a DOM (browser, jsdom or happy-dom)");
+  }
+  const container = document.createElement("div");
+  container.innerHTML = clean;
+  return PMDOMParser.fromSchema(schema).parse(container).toJSON();
+};
+var toDocJson = (value) => {
+  if (isDocJson(value)) return value;
+  return htmlToJSON(value);
+};
+var jsonToHTML = (json) => {
+  const schema = getEditorSchema();
+  const node = PMNode.fromJSON(schema, isDocJson(json) ? json : EMPTY_DOC);
+  const fragment = DOMSerializer.fromSchema(schema).serializeFragment(node.content);
+  const container = document.createElement("div");
+  container.appendChild(fragment);
+  return container.innerHTML;
+};
+var htmlToText = (html) => jsonToText(htmlToJSON(html));
+
+export {
+  BLOCK_TYPES,
+  DEFAULT_FONT_FAMILIES,
+  DEFAULT_FONT_SIZES,
+  LINE_HEIGHTS,
+  COLOR_SWATCHES,
+  DEFAULT_TOOLBAR,
+  TABLE_PICKER_SIZE,
+  PARAGRAPH_SPACING,
+  TEXT_CASES,
+  TABLE_BORDER_OPTIONS,
+  INDENT_STEP_PX,
+  matchSpacingPreset,
+  ParagraphFormat,
+  RichTableCell,
+  RichTableHeader,
+  SILENT_META,
+  NODE_ID_ATTRIBUTE,
+  NODE_ID_TYPES,
+  ensureNodeIds,
+  NodeIds,
+  readAsDataUrl,
+  insertImages,
+  getTableBorderState,
+  buildSchemaExtensions,
+  buildEditorExtensions,
+  isWordHtml,
+  cleanHtml,
+  jsonToText,
+  STANDARD_FONTS,
+  DEFAULT_PDF_OPTIONS,
+  PDF_TREE_VERSION,
+  jsonToPdfTree,
+  isPdfTree,
+  getEditorSchema,
+  EMPTY_DOC,
+  isDocJson,
+  textToHtml,
+  normalizeHtmlInput,
+  htmlToJSON,
+  toDocJson,
+  jsonToHTML,
+  htmlToText
+};
+//# sourceMappingURL=chunk-JQEG2JQ7.js.map