react-next-editor-js 0.1.0

package/dist/chunk-DBSFCCBG.cjs

@@ -0,0 +1,1712 @@
+'use strict';
+
+var chunkTXPLBAH5_cjs = require('./chunk-TXPLBAH5.cjs');
+var chunk5F6SPYCN_cjs = require('./chunk-5F6SPYCN.cjs');
+var chunkU3O54IYI_cjs = require('./chunk-U3O54IYI.cjs');
+var chunkQ7SFCCGT_cjs = require('./chunk-Q7SFCCGT.cjs');
+var prosemirrorModel = require('prosemirror-model');
+var prosemirrorTables = require('prosemirror-tables');
+var prosemirrorHistory = require('prosemirror-history');
+var prosemirrorCommands = require('prosemirror-commands');
+var prosemirrorSchemaList = require('prosemirror-schema-list');
+var prosemirrorState = require('prosemirror-state');
+var prosemirrorDropcursor = require('prosemirror-dropcursor');
+var prosemirrorGapcursor = require('prosemirror-gapcursor');
+var prosemirrorInputrules = require('prosemirror-inputrules');
+var prosemirrorKeymap = require('prosemirror-keymap');
+var prosemirrorView = require('prosemirror-view');
+
+// src/core/schema/nodes.ts
+var nodes_exports = {};
+chunkQ7SFCCGT_cjs.__export(nodes_exports, {
+  blockquote: () => blockquote,
+  bullet_list: () => bullet_list,
+  doc: () => doc,
+  hard_break: () => hard_break,
+  heading: () => heading,
+  horizontal_rule: () => horizontal_rule,
+  image: () => image,
+  list_item: () => list_item,
+  nodeAlign: () => nodeAlign,
+  ordered_list: () => ordered_list,
+  page_break: () => page_break,
+  paragraph: () => paragraph,
+  text: () => text
+});
+
+// src/core/schema/attrs.ts
+var ALIGN_VALUES = [
+  "left",
+  "center",
+  "right",
+  "justify"
+];
+var MAX_INDENT = 12;
+var INDENT_STEP_EM = 3;
+var blockAttrs = {
+  align: { default: null },
+  indent: { default: 0 },
+  lineHeight: { default: null }
+};
+function readBlockAttrs(dom) {
+  const textAlign = dom.style.textAlign || dom.getAttribute("align") || "";
+  const align = ALIGN_VALUES.includes(textAlign) ? textAlign : null;
+  let indent = 0;
+  const marginLeft = dom.style.marginLeft;
+  if (marginLeft) {
+    const em2 = parseFloat(marginLeft);
+    if (Number.isFinite(em2) && em2 > 0) {
+      const unit = /px$/.test(marginLeft) ? em2 / 16 : em2;
+      indent = Math.min(MAX_INDENT, Math.max(0, Math.round(unit / INDENT_STEP_EM)));
+    }
+  }
+  let lineHeight = null;
+  const lh = dom.style.lineHeight;
+  if (lh) {
+    const value = parseFloat(lh);
+    if (Number.isFinite(value) && value > 0 && value <= 10) {
+      lineHeight = Math.round(value * 100) / 100;
+    }
+  }
+  return { align, indent, lineHeight };
+}
+function blockDOMAttrs(node, extra) {
+  const attrs = node.attrs;
+  const styles = [];
+  const align = chunkTXPLBAH5_cjs.cssAlign(attrs.align);
+  if (align) styles.push(`text-align: ${align}`);
+  const indent = chunkTXPLBAH5_cjs.cssInteger(attrs.indent, 0, MAX_INDENT);
+  if (indent && indent > 0) styles.push(`margin-left: ${indent * INDENT_STEP_EM}em`);
+  const lineHeight = chunkTXPLBAH5_cjs.cssNumber(attrs.lineHeight, 0.1, 10);
+  if (lineHeight) styles.push(`line-height: ${lineHeight}`);
+  const out = { ...extra };
+  if (styles.length) out.style = styles.join("; ");
+  return out;
+}
+function clampIndent(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(MAX_INDENT, Math.max(0, Math.round(value)));
+}
+function isTextAlign(value) {
+  return typeof value === "string" && ALIGN_VALUES.includes(value);
+}
+
+// src/core/schema/nodes.ts
+var doc = { content: "block+" };
+var text = { group: "inline" };
+var paragraph = {
+  group: "block",
+  content: "inline*",
+  attrs: { ...blockAttrs },
+  parseDOM: [{ tag: "p", getAttrs: (dom) => readBlockAttrs(dom) }],
+  toDOM(node) {
+    return ["p", blockDOMAttrs(node), 0];
+  }
+};
+var heading = {
+  group: "block",
+  content: "inline*",
+  defining: true,
+  attrs: { level: { default: 1 }, ...blockAttrs },
+  parseDOM: [1, 2, 3, 4, 5, 6].map((level) => ({
+    tag: `h${level}`,
+    getAttrs: (dom) => ({
+      level,
+      ...readBlockAttrs(dom)
+    })
+  })),
+  toDOM(node) {
+    const level = node.attrs.level || 1;
+    return [`h${Math.min(6, Math.max(1, level))}`, blockDOMAttrs(node), 0];
+  }
+};
+var blockquote = {
+  group: "block",
+  content: "block+",
+  defining: true,
+  parseDOM: [{ tag: "blockquote" }],
+  toDOM() {
+    return ["blockquote", { class: "rne-blockquote" }, 0];
+  }
+};
+var horizontal_rule = {
+  group: "block",
+  parseDOM: [{ tag: "hr" }],
+  toDOM() {
+    return ["hr", { class: "rne-hr" }];
+  }
+};
+var page_break = {
+  group: "block",
+  atom: true,
+  selectable: true,
+  parseDOM: [{ tag: "div[data-page-break]" }, { tag: "div.rne-page-break" }],
+  toDOM() {
+    return [
+      "div",
+      { "data-page-break": "true", class: "rne-page-break", contenteditable: "false" }
+    ];
+  }
+};
+var hard_break = {
+  inline: true,
+  group: "inline",
+  selectable: false,
+  parseDOM: [{ tag: "br" }],
+  toDOM() {
+    return ["br"];
+  }
+};
+var MAX_IMAGE_WIDTH = 2e3;
+var image = {
+  inline: true,
+  group: "inline",
+  draggable: true,
+  attrs: {
+    src: {},
+    alt: { default: null },
+    title: { default: null },
+    width: { default: null }
+  },
+  parseDOM: [
+    {
+      tag: "img[src]",
+      getAttrs(dom) {
+        const el = dom;
+        const src = chunk5F6SPYCN_cjs.sanitizeImageSrc(el.getAttribute("src"));
+        if (!src) return false;
+        const widthAttr = el.getAttribute("width") ?? el.style.width;
+        let width = null;
+        if (widthAttr) {
+          const num = parseInt(widthAttr, 10);
+          if (Number.isFinite(num) && num > 0) width = Math.min(MAX_IMAGE_WIDTH, num);
+        }
+        return {
+          src,
+          alt: el.getAttribute("alt"),
+          title: el.getAttribute("title"),
+          width
+        };
+      }
+    }
+  ],
+  toDOM(node) {
+    const { src, alt, title, width } = node.attrs;
+    const safeSrc = chunk5F6SPYCN_cjs.sanitizeImageSrc(src) ?? "";
+    const attrs = { src: safeSrc, class: "rne-image" };
+    if (alt) attrs.alt = alt;
+    if (title) attrs.title = title;
+    const safeWidth = chunkTXPLBAH5_cjs.cssInteger(width, 1, MAX_IMAGE_WIDTH);
+    if (safeWidth) attrs.style = `width: ${safeWidth}px`;
+    return ["img", attrs];
+  }
+};
+var list_item = {
+  content: "paragraph block*",
+  defining: true,
+  attrs: { checked: { default: null } },
+  parseDOM: [
+    {
+      tag: "li",
+      getAttrs(dom) {
+        const el = dom;
+        const dc = el.getAttribute("data-checked");
+        if (dc === "true") return { checked: true };
+        if (dc === "false") return { checked: false };
+        return { checked: null };
+      }
+    }
+  ],
+  toDOM(node) {
+    const checked = node.attrs.checked;
+    if (checked === null) return ["li", 0];
+    return [
+      "li",
+      { "data-checked": String(checked), class: "rne-task-item" },
+      ["span", { class: "rne-task-checkbox", contenteditable: "false" }],
+      ["div", { class: "rne-task-content" }, 0]
+    ];
+  }
+};
+var bullet_list = {
+  group: "block",
+  content: "list_item+",
+  attrs: { kind: { default: "bullet" } },
+  parseDOM: [
+    {
+      tag: "ul",
+      getAttrs(dom) {
+        const el = dom;
+        const isTask = el.getAttribute("data-type") === "task" || el.classList.contains("rne-task-list") || !!el.querySelector("li[data-checked]");
+        return { kind: isTask ? "task" : "bullet" };
+      }
+    }
+  ],
+  toDOM(node) {
+    const kind = node.attrs.kind;
+    return kind === "task" ? ["ul", { "data-type": "task", class: "rne-task-list" }, 0] : ["ul", { class: "rne-bullet-list" }, 0];
+  }
+};
+var ordered_list = {
+  group: "block",
+  content: "list_item+",
+  attrs: { order: { default: 1 } },
+  parseDOM: [
+    {
+      tag: "ol",
+      getAttrs(dom) {
+        const el = dom;
+        const start = el.getAttribute("start");
+        const order = start ? parseInt(start, 10) : 1;
+        return { order: Number.isFinite(order) && order > 0 ? order : 1 };
+      }
+    }
+  ],
+  toDOM(node) {
+    const order = node.attrs.order || 1;
+    return order === 1 ? ["ol", { class: "rne-ordered-list" }, 0] : ["ol", { order, start: order, class: "rne-ordered-list" }, 0];
+  }
+};
+function nodeAlign(node) {
+  return node.attrs?.align ?? null;
+}
+
+// src/core/schema/marks.ts
+var marks_exports = {};
+chunkQ7SFCCGT_cjs.__export(marks_exports, {
+  code: () => code,
+  em: () => em,
+  fontFamily: () => fontFamily,
+  fontSize: () => fontSize,
+  highlight: () => highlight,
+  link: () => link,
+  strikethrough: () => strikethrough,
+  strong: () => strong,
+  subscript: () => subscript,
+  superscript: () => superscript,
+  textColor: () => textColor,
+  underline: () => underline
+});
+var strong = {
+  parseDOM: [
+    { tag: "strong" },
+    { tag: "b", getAttrs: (node) => node.style.fontWeight !== "normal" && null },
+    { style: "font-weight=400", clearMark: (m) => m.type.name === "strong" },
+    {
+      style: "font-weight",
+      getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
+    }
+  ],
+  toDOM() {
+    return ["strong", 0];
+  }
+};
+var em = {
+  parseDOM: [
+    { tag: "i" },
+    { tag: "em" },
+    { style: "font-style=italic" },
+    { style: "font-style=normal", clearMark: (m) => m.type.name === "em" }
+  ],
+  toDOM() {
+    return ["em", 0];
+  }
+};
+var underline = {
+  parseDOM: [
+    { tag: "u" },
+    {
+      style: "text-decoration",
+      getAttrs: (value) => value.includes("underline") && null
+    },
+    {
+      style: "text-decoration-line",
+      getAttrs: (value) => value.includes("underline") && null
+    }
+  ],
+  toDOM() {
+    return ["u", 0];
+  }
+};
+var strikethrough = {
+  parseDOM: [
+    { tag: "s" },
+    { tag: "del" },
+    { tag: "strike" },
+    {
+      style: "text-decoration",
+      getAttrs: (value) => value.includes("line-through") && null
+    }
+  ],
+  toDOM() {
+    return ["s", 0];
+  }
+};
+var superscript = {
+  excludes: "subscript",
+  parseDOM: [{ tag: "sup" }, { style: "vertical-align=super" }],
+  toDOM() {
+    return ["sup", 0];
+  }
+};
+var subscript = {
+  excludes: "superscript",
+  parseDOM: [{ tag: "sub" }, { style: "vertical-align=sub" }],
+  toDOM() {
+    return ["sub", 0];
+  }
+};
+var code = {
+  parseDOM: [{ tag: "code" }],
+  toDOM() {
+    return ["code", { class: "rne-inline-code" }, 0];
+  }
+};
+var link = {
+  attrs: {
+    href: {},
+    title: { default: null },
+    target: { default: "_blank" }
+  },
+  inclusive: false,
+  parseDOM: [
+    {
+      tag: "a[href]",
+      getAttrs(dom) {
+        const el = dom;
+        const rawHref = el.getAttribute("href");
+        const href = chunk5F6SPYCN_cjs.sanitizeUrl(rawHref);
+        if (!href) return false;
+        return {
+          href,
+          title: el.getAttribute("title"),
+          target: el.getAttribute("target") ?? "_blank"
+        };
+      }
+    }
+  ],
+  toDOM(mark) {
+    const href = chunk5F6SPYCN_cjs.sanitizeUrl(mark.attrs.href) ?? "";
+    const target = mark.attrs.target || "_blank";
+    return [
+      "a",
+      {
+        href,
+        title: mark.attrs.title ?? null,
+        target,
+        rel: "noopener noreferrer nofollow"
+      },
+      0
+    ];
+  }
+};
+var fontFamily = {
+  attrs: { family: {} },
+  parseDOM: [
+    {
+      style: "font-family",
+      getAttrs: (value) => {
+        const family = chunkTXPLBAH5_cjs.cssFontFamily(value);
+        return family ? { family } : false;
+      }
+    }
+  ],
+  toDOM(mark) {
+    const family = chunkTXPLBAH5_cjs.cssFontFamily(mark.attrs.family);
+    return family ? ["span", { style: `font-family: ${family}` }, 0] : ["span", 0];
+  }
+};
+var fontSize = {
+  attrs: { size: {} },
+  parseDOM: [
+    {
+      style: "font-size",
+      getAttrs: (value) => {
+        const size = parseFontSize(value);
+        return size ? { size } : false;
+      }
+    }
+  ],
+  toDOM(mark) {
+    const size = chunkTXPLBAH5_cjs.cssNumber(mark.attrs.size, 1, 1638);
+    return size ? ["span", { style: `font-size: ${size}pt` }, 0] : ["span", 0];
+  }
+};
+var textColor = {
+  attrs: { color: {} },
+  parseDOM: [
+    {
+      style: "color",
+      getAttrs: (value) => {
+        const color = chunkTXPLBAH5_cjs.normalizeCssColor(value);
+        return color ? { color } : false;
+      }
+    }
+  ],
+  toDOM(mark) {
+    const color = chunkTXPLBAH5_cjs.normalizeCssColor(mark.attrs.color);
+    return color ? ["span", { style: `color: ${color}` }, 0] : ["span", 0];
+  }
+};
+var highlight = {
+  attrs: { color: { default: "#fff2a8" } },
+  parseDOM: [
+    { tag: "mark" },
+    {
+      style: "background-color",
+      getAttrs: (value) => {
+        const color = chunkTXPLBAH5_cjs.normalizeCssColor(value);
+        return color ? { color } : false;
+      }
+    }
+  ],
+  toDOM(mark) {
+    const color = chunkTXPLBAH5_cjs.normalizeCssColor(mark.attrs.color) ?? "#fff2a8";
+    return ["mark", { style: `background-color: ${color}` }, 0];
+  }
+};
+function parseFontSize(value) {
+  const match = /(\d+(?:\.\d+)?)\s*(pt|px)?/.exec(value);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  if (!Number.isFinite(num) || num <= 0) return null;
+  const pt = (match[2] ?? "pt") === "px" ? num * 0.75 : num;
+  return chunkTXPLBAH5_cjs.cssNumber(Math.round(pt * 100) / 100, 1, 1638);
+}
+
+// src/core/schema/schema.ts
+function buildSchema(features = {}) {
+  const f = { ...chunkU3O54IYI_cjs.DEFAULT_FEATURES, ...features };
+  const nodes = {
+    doc,
+    paragraph
+  };
+  if (f.headings) nodes.heading = heading;
+  if (f.blockquote) nodes.blockquote = blockquote;
+  if (f.horizontalRule) nodes.horizontal_rule = horizontal_rule;
+  if (f.bulletList || f.orderedList || f.taskList) {
+    nodes.list_item = list_item;
+    if (f.bulletList || f.taskList) nodes.bullet_list = bullet_list;
+    if (f.orderedList) nodes.ordered_list = ordered_list;
+  }
+  if (f.table) {
+    const tnodes = prosemirrorTables.tableNodes({
+      tableGroup: "block",
+      cellContent: "block+",
+      cellAttributes: {
+        background: {
+          default: null,
+          getFromDOM(dom) {
+            return dom.style.backgroundColor || null;
+          },
+          setDOMAttr(value, attrs) {
+            const color = chunkTXPLBAH5_cjs.normalizeCssColor(value);
+            if (color) {
+              attrs.style = `${attrs.style || ""}background-color: ${color};`;
+            }
+          }
+        },
+        align: {
+          default: null,
+          getFromDOM(dom) {
+            return dom.style.textAlign || null;
+          },
+          setDOMAttr(value, attrs) {
+            const align = chunkTXPLBAH5_cjs.cssAlign(value);
+            if (align) {
+              attrs.style = `${attrs.style || ""}text-align: ${align};`;
+            }
+          }
+        }
+      }
+    });
+    Object.assign(nodes, tnodes);
+  }
+  if (f.image) nodes.image = image;
+  if (f.pageBreak) nodes.page_break = page_break;
+  nodes.text = text;
+  nodes.hard_break = hard_break;
+  const marks = {};
+  if (f.link) marks.link = link;
+  if (f.bold) marks.strong = strong;
+  if (f.italic) marks.em = em;
+  if (f.underline) marks.underline = underline;
+  if (f.strikethrough) marks.strikethrough = strikethrough;
+  if (f.superscript) marks.superscript = superscript;
+  if (f.subscript) marks.subscript = subscript;
+  if (f.code) marks.code = code;
+  if (f.fontFamily) marks.fontFamily = fontFamily;
+  if (f.fontSize) marks.fontSize = fontSize;
+  if (f.textColor) marks.textColor = textColor;
+  if (f.highlight) marks.highlight = highlight;
+  return new prosemirrorModel.Schema({ nodes, marks });
+}
+var defaultSchema = buildSchema();
+
+// src/core/commands/helpers.ts
+function isMarkActive(state, type) {
+  const { from, $from, to, empty } = state.selection;
+  if (empty) {
+    return !!type.isInSet(state.storedMarks || $from.marks());
+  }
+  return state.doc.rangeHasMark(from, to, type);
+}
+function getActiveMarkAttrs(state, type) {
+  const { $from, empty } = state.selection;
+  if (empty) {
+    const mark = type.isInSet(state.storedMarks || $from.marks());
+    return mark ? mark.attrs : null;
+  }
+  const { from, to } = state.selection;
+  let attrs = null;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (attrs) return false;
+    const mark = node.marks.find((m) => m.type === type);
+    if (mark) attrs = mark.attrs;
+    return true;
+  });
+  return attrs;
+}
+function isBlockActive(state, type, attrs) {
+  const { from, to } = state.selection;
+  let found = false;
+  let allMatch = true;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (node.type.isTextblock || node.type === type) {
+      if (node.type === type && matchAttrs(node.attrs, attrs)) {
+        found = true;
+      } else if (node.type.isTextblock) {
+        if (!(node.type === type && matchAttrs(node.attrs, attrs))) allMatch = false;
+      }
+    }
+    return true;
+  });
+  return found && allMatch;
+}
+function matchAttrs(nodeAttrs, attrs) {
+  if (!attrs) return true;
+  return Object.keys(attrs).every((key) => nodeAttrs[key] === attrs[key]);
+}
+function isInNode(state, type) {
+  const { $from } = state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    if ($from.node(depth).type === type) return true;
+  }
+  return false;
+}
+function defaultEnabled(run) {
+  return (state) => run(state, void 0, void 0);
+}
+
+// src/core/commands/marks.ts
+function setMark(type, attrs) {
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (dispatch) {
+      const tr = state.tr;
+      if (selection.empty) {
+        tr.addStoredMark(type.create(attrs));
+      } else {
+        for (const range of selection.ranges) {
+          const { $from, $to } = range;
+          tr.addMark($from.pos, $to.pos, type.create(attrs));
+        }
+        tr.scrollIntoView();
+      }
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+function unsetMark(type) {
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (dispatch) {
+      const tr = state.tr;
+      if (selection.empty) {
+        tr.removeStoredMark(type);
+      } else {
+        for (const range of selection.ranges) {
+          tr.removeMark(range.$from.pos, range.$to.pos, type);
+        }
+      }
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+function toggle(type) {
+  const run = prosemirrorCommands.toggleMark(type);
+  return {
+    run,
+    isActive: (state) => isMarkActive(state, type),
+    isEnabled: (state) => run(state, void 0, void 0)
+  };
+}
+function createMarkCommands(schema) {
+  const cmds = {};
+  const m = schema.marks;
+  if (m.strong) cmds.bold = toggle(m.strong);
+  if (m.em) cmds.italic = toggle(m.em);
+  if (m.underline) cmds.underline = toggle(m.underline);
+  if (m.strikethrough) cmds.strikethrough = toggle(m.strikethrough);
+  if (m.superscript) cmds.superscript = toggle(m.superscript);
+  if (m.subscript) cmds.subscript = toggle(m.subscript);
+  if (m.code) cmds.code = toggle(m.code);
+  return cmds;
+}
+function createParametricMarkCommands(schema) {
+  const m = schema.marks;
+  return {
+    setFontFamily: (family) => m.fontFamily ? setMark(m.fontFamily, { family }) : noop,
+    clearFontFamily: () => m.fontFamily ? unsetMark(m.fontFamily) : noop,
+    setFontSize: (size) => m.fontSize ? setMark(m.fontSize, { size }) : noop,
+    clearFontSize: () => m.fontSize ? unsetMark(m.fontSize) : noop,
+    setTextColor: (color) => m.textColor ? setMark(m.textColor, { color }) : noop,
+    clearTextColor: () => m.textColor ? unsetMark(m.textColor) : noop,
+    setHighlight: (color) => m.highlight ? setMark(m.highlight, { color }) : noop,
+    clearHighlight: () => m.highlight ? unsetMark(m.highlight) : noop,
+    getActiveFontFamily: (state) => m.fontFamily ? getActiveMarkAttrs(state, m.fontFamily)?.family ?? null : null,
+    getActiveFontSize: (state) => m.fontSize ? getActiveMarkAttrs(state, m.fontSize)?.size ?? null : null,
+    getActiveTextColor: (state) => m.textColor ? getActiveMarkAttrs(state, m.textColor)?.color ?? null : null
+  };
+}
+var noop = () => false;
+var noop2 = () => false;
+function setTextblockAttr(attr, value) {
+  return (state, dispatch) => {
+    const { from, to } = state.selection;
+    let applicable = false;
+    const tr = state.tr;
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isTextblock && attr in (node.type.spec.attrs ?? {})) {
+        applicable = true;
+        if (dispatch) tr.setNodeAttribute(pos, attr, value);
+      }
+      return true;
+    });
+    if (!applicable) return false;
+    if (dispatch) dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+function isTextblockAttrActive(state, attr, value) {
+  const { from, to } = state.selection;
+  let any = false;
+  let all = true;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (node.isTextblock && attr in (node.type.spec.attrs ?? {})) {
+      any = true;
+      if (node.attrs[attr] !== value) all = false;
+    }
+    return true;
+  });
+  return any && all;
+}
+function changeIndent(delta) {
+  return (state, dispatch) => {
+    const { from, to } = state.selection;
+    let changed = false;
+    const tr = state.tr;
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isTextblock && "indent" in (node.type.spec.attrs ?? {})) {
+        const next = clampIndent(node.attrs.indent + delta);
+        if (next !== node.attrs.indent) {
+          changed = true;
+          if (dispatch) tr.setNodeAttribute(pos, "indent", next);
+        }
+      }
+      return true;
+    });
+    if (!changed) return false;
+    if (dispatch) dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+function insertBlock(type) {
+  return (state, dispatch) => {
+    if (!type) return false;
+    if (dispatch) {
+      dispatch(state.tr.replaceSelectionWith(type.create()).scrollIntoView());
+    }
+    return true;
+  };
+}
+function createBlockCommands(schema) {
+  const n = schema.nodes;
+  const cmds = {};
+  if (n.paragraph) {
+    const run = prosemirrorCommands.setBlockType(n.paragraph);
+    cmds.paragraph = {
+      run,
+      isActive: (state) => isBlockActive(state, n.paragraph),
+      isEnabled: (state) => run(state, void 0, void 0)
+    };
+  }
+  if (schema.nodes.blockquote) {
+    const wrap = prosemirrorCommands.wrapIn(schema.nodes.blockquote);
+    cmds.blockquote = {
+      run: (state, dispatch, view) => {
+        if (isInNode(state, schema.nodes.blockquote)) return prosemirrorCommands.lift(state, dispatch);
+        return wrap(state, dispatch, view);
+      },
+      isActive: (state) => isInNode(state, schema.nodes.blockquote)
+    };
+  }
+  if (n.horizontal_rule) {
+    const run = insertBlock(n.horizontal_rule);
+    cmds.horizontalRule = { run, isEnabled: (state) => run(state, void 0, void 0) };
+  }
+  if (n.page_break) {
+    const run = insertBlock(n.page_break);
+    cmds.pageBreak = { run, isEnabled: (state) => run(state, void 0, void 0) };
+  }
+  if (n.paragraph?.spec.attrs && "align" in n.paragraph.spec.attrs) {
+    const aligns = [
+      ["alignLeft", "left"],
+      ["alignCenter", "center"],
+      ["alignRight", "right"],
+      ["alignJustify", "justify"]
+    ];
+    for (const [name, value] of aligns) {
+      const run = setTextblockAttr("align", value);
+      cmds[name] = {
+        run,
+        isActive: (state) => isTextblockAttrActive(state, "align", value),
+        isEnabled: (state) => run(state, void 0, void 0)
+      };
+    }
+    const indentRun = changeIndent(1);
+    const outdentRun = changeIndent(-1);
+    cmds.indent = { run: indentRun, isEnabled: (state) => indentRun(state, void 0, void 0) };
+    cmds.outdent = {
+      run: outdentRun,
+      isEnabled: (state) => outdentRun(state, void 0, void 0)
+    };
+  }
+  return cmds;
+}
+function createParametricBlockCommands(schema) {
+  const n = schema.nodes;
+  return {
+    setParagraph: () => n.paragraph ? prosemirrorCommands.setBlockType(n.paragraph) : noop2,
+    setHeading: (level) => n.heading ? prosemirrorCommands.setBlockType(n.heading, { level }) : noop2,
+    setAlign: (align) => setTextblockAttr("align", align),
+    setLineHeight: (lineHeight) => setTextblockAttr("lineHeight", lineHeight)
+  };
+}
+function findParentList(state, listTypes) {
+  const { $from } = state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (listTypes.includes(node.type)) {
+      return { node, pos: $from.before(depth), depth };
+    }
+  }
+  return null;
+}
+function setItemsChecked(tr, list, listPos, checked) {
+  let offset = listPos + 1;
+  list.forEach((child) => {
+    if (child.type.name === "list_item" && child.attrs.checked !== checked) {
+      tr.setNodeAttribute(offset, "checked", checked);
+    }
+    offset += child.nodeSize;
+  });
+}
+function toggleList(schema, targetType, targetAttrs) {
+  const listItem = schema.nodes.list_item;
+  const listTypes = [schema.nodes.bullet_list, schema.nodes.ordered_list].filter(
+    Boolean
+  );
+  return (state, dispatch, view) => {
+    const parent = findParentList(state, listTypes);
+    if (!parent) {
+      const wrap = prosemirrorSchemaList.wrapInList(targetType, targetAttrs);
+      if (targetAttrs.kind === "task") {
+        return wrap(
+          state,
+          (tr) => {
+            if (!dispatch) return;
+            const next = tr.doc.resolve(tr.selection.from);
+            for (let depth = next.depth; depth > 0; depth--) {
+              const node = next.node(depth);
+              if (node.type === targetType) {
+                setItemsChecked(tr, node, next.before(depth), false);
+                break;
+              }
+            }
+            dispatch(tr);
+          },
+          view
+        );
+      }
+      return wrap(state, dispatch, view);
+    }
+    const sameType = parent.node.type === targetType;
+    const sameKind = targetType.name !== "bullet_list" || parent.node.attrs.kind === targetAttrs.kind;
+    if (sameType && sameKind) {
+      return prosemirrorSchemaList.liftListItem(listItem)(state, dispatch, view);
+    }
+    if (dispatch) {
+      const tr = state.tr.setNodeMarkup(parent.pos, targetType, targetAttrs);
+      const checked = targetAttrs.kind === "task" ? false : null;
+      setItemsChecked(tr, parent.node, parent.pos, checked);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function isInList(state, type, kind) {
+  const { $from } = state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type === type && (kind === void 0 || node.attrs.kind === kind)) return true;
+  }
+  return false;
+}
+function createListCommands(schema) {
+  const n = schema.nodes;
+  const cmds = {};
+  if (!n.list_item) return cmds;
+  if (n.bullet_list) {
+    const run = toggleList(schema, n.bullet_list, { kind: "bullet" });
+    cmds.bulletList = {
+      run,
+      isActive: (state) => isInList(state, n.bullet_list, "bullet")
+    };
+  }
+  if (n.ordered_list) {
+    const run = toggleList(schema, n.ordered_list, { order: 1 });
+    cmds.orderedList = {
+      run,
+      isActive: (state) => isInList(state, n.ordered_list)
+    };
+  }
+  if (n.bullet_list) {
+    const run = toggleList(schema, n.bullet_list, { kind: "task" });
+    cmds.taskList = {
+      run,
+      isActive: (state) => isInList(state, n.bullet_list, "task")
+    };
+  }
+  const sink = prosemirrorSchemaList.sinkListItem(n.list_item);
+  const liftItem = prosemirrorSchemaList.liftListItem(n.list_item);
+  cmds.sinkListItem = { run: sink, isEnabled: (state) => sink(state, void 0, void 0) };
+  cmds.liftListItem = { run: liftItem, isEnabled: (state) => liftItem(state, void 0, void 0) };
+  return cmds;
+}
+
+// src/core/commands/format.ts
+function clearFormatting(schema) {
+  return (state, dispatch) => {
+    const { from, to, empty } = state.selection;
+    if (empty) return false;
+    if (dispatch) {
+      const tr = state.tr;
+      tr.removeMark(from, to);
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isTextblock) return true;
+        const specAttrs = node.type.spec.attrs ?? {};
+        if (schema.nodes.heading && node.type === schema.nodes.heading && schema.nodes.paragraph) {
+          tr.setNodeMarkup(pos, schema.nodes.paragraph, {
+            align: null,
+            indent: 0,
+            lineHeight: null
+          });
+        } else {
+          const attrs = { ...node.attrs };
+          if ("align" in specAttrs) attrs.align = null;
+          if ("indent" in specAttrs) attrs.indent = 0;
+          if ("lineHeight" in specAttrs) attrs.lineHeight = null;
+          tr.setNodeMarkup(pos, void 0, attrs);
+        }
+        return true;
+      });
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function createFormatCommands(schema) {
+  const run = clearFormatting(schema);
+  return {
+    clearFormatting: {
+      run,
+      isEnabled: (state) => !state.selection.empty
+    }
+  };
+}
+
+// src/core/commands/links.ts
+function linkRangeAt(state, type, pos) {
+  const $pos = state.doc.resolve(pos);
+  const mark = type.isInSet($pos.marks());
+  if (!mark) return null;
+  let start = pos;
+  let end = pos;
+  while (start > 0 && mark.isInSet(state.doc.resolve(start - 1).marks())) start--;
+  const docSize = state.doc.content.size;
+  while (end < docSize && mark.isInSet(state.doc.resolve(end + 1).marks())) end++;
+  return { from: start, to: end };
+}
+function setLink(type, attrs) {
+  return (state, dispatch) => {
+    const href = chunk5F6SPYCN_cjs.sanitizeUrl(attrs.href);
+    if (!href) return false;
+    const markAttrs = { href, title: attrs.title ?? null, target: attrs.target ?? "_blank" };
+    const { empty, from, to } = state.selection;
+    if (dispatch) {
+      const tr = state.tr;
+      if (empty) {
+        const text2 = state.schema.text(href, [type.create(markAttrs)]);
+        tr.replaceSelectionWith(text2, false);
+      } else {
+        tr.addMark(from, to, type.create(markAttrs));
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function removeLink(type) {
+  return (state, dispatch) => {
+    const { empty, from, to } = state.selection;
+    if (empty) {
+      const range = linkRangeAt(state, type, from);
+      if (!range) return false;
+      if (dispatch) dispatch(state.tr.removeMark(range.from, range.to, type));
+      return true;
+    }
+    if (!state.doc.rangeHasMark(from, to, type)) return false;
+    if (dispatch) dispatch(state.tr.removeMark(from, to, type));
+    return true;
+  };
+}
+function createLinkCommands(schema) {
+  const type = schema.marks.link;
+  if (!type) {
+    const noop3 = () => false;
+    return {
+      commands: {},
+      setLink: (_attrs) => noop3,
+      removeLink: noop3,
+      getActiveLink: (_state) => null,
+      isLinkActive: (_state) => false
+    };
+  }
+  const commands = {
+    removeLink: {
+      run: removeLink(type),
+      isEnabled: (state) => isMarkActive(state, type)
+    }
+  };
+  return {
+    commands,
+    setLink: (attrs) => setLink(type, attrs),
+    removeLink: removeLink(type),
+    getActiveLink: (state) => getActiveMarkAttrs(state, type),
+    isLinkActive: (state) => isMarkActive(state, type)
+  };
+}
+function insertImage(schema, attrs) {
+  return (state, dispatch) => {
+    const type = schema.nodes.image;
+    if (!type) return false;
+    const src = chunk5F6SPYCN_cjs.sanitizeImageSrc(attrs.src);
+    if (!src) return false;
+    if (dispatch) {
+      const node = type.create({
+        src,
+        alt: attrs.alt ?? null,
+        title: attrs.title ?? null,
+        width: attrs.width ?? null
+      });
+      dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+    }
+    return true;
+  };
+}
+function createTableNode(schema, rows, cols, withHeaderRow) {
+  const { table, table_row, table_cell, table_header } = schema.nodes;
+  if (!table || !table_row || !table_cell) return null;
+  const headerType = table_header ?? table_cell;
+  const rowNodes = [];
+  for (let r = 0; r < rows; r++) {
+    const cells = [];
+    for (let c = 0; c < cols; c++) {
+      const cellType = withHeaderRow && r === 0 ? headerType : table_cell;
+      const cell = cellType.createAndFill();
+      if (!cell) return null;
+      cells.push(cell);
+    }
+    rowNodes.push(table_row.create(null, cells));
+  }
+  return table.create(null, rowNodes);
+}
+function insertTable(schema, rows = 3, cols = 3, withHeaderRow = true) {
+  return (state, dispatch) => {
+    const node = createTableNode(schema, rows, cols, withHeaderRow);
+    if (!node) return false;
+    if (dispatch) dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+    return true;
+  };
+}
+function createTableCommands(schema) {
+  if (!schema.nodes.table) return {};
+  const wrap = (run) => ({
+    run,
+    isEnabled: (state) => run(state, void 0, void 0)
+  });
+  return {
+    addRowBefore: wrap(prosemirrorTables.addRowBefore),
+    addRowAfter: wrap(prosemirrorTables.addRowAfter),
+    deleteRow: wrap(prosemirrorTables.deleteRow),
+    addColumnBefore: wrap(prosemirrorTables.addColumnBefore),
+    addColumnAfter: wrap(prosemirrorTables.addColumnAfter),
+    deleteColumn: wrap(prosemirrorTables.deleteColumn),
+    mergeCells: wrap(prosemirrorTables.mergeCells),
+    splitCell: wrap(prosemirrorTables.splitCell),
+    toggleHeaderRow: wrap(prosemirrorTables.toggleHeaderRow),
+    toggleHeaderColumn: wrap(prosemirrorTables.toggleHeaderColumn),
+    deleteTable: wrap(prosemirrorTables.deleteTable)
+  };
+}
+
+// src/core/commands/index.ts
+function createCommands(schema) {
+  const registry = {
+    undo: { run: prosemirrorHistory.undo, isEnabled: (state) => prosemirrorHistory.undo(state) },
+    redo: { run: prosemirrorHistory.redo, isEnabled: (state) => prosemirrorHistory.redo(state) },
+    ...createMarkCommands(schema),
+    ...createBlockCommands(schema),
+    ...createListCommands(schema),
+    ...createFormatCommands(schema),
+    ...createTableCommands(schema)
+  };
+  const linkApi = createLinkCommands(schema);
+  Object.assign(registry, linkApi.commands);
+  return {
+    registry,
+    marks: createParametricMarkCommands(schema),
+    blocks: createParametricBlockCommands(schema),
+    links: linkApi,
+    insert: {
+      image: (attrs) => insertImage(schema, attrs),
+      table: (rows = 3, cols = 3, withHeaderRow = true) => insertTable(schema, rows, cols, withHeaderRow)
+    }
+  };
+}
+var editingCommands = {
+  selectAll: prosemirrorCommands.selectAll,
+  selectParentNode: prosemirrorCommands.selectParentNode,
+  deleteSelection: prosemirrorCommands.deleteSelection,
+  joinBackward: prosemirrorCommands.joinBackward,
+  joinForward: prosemirrorCommands.joinForward
+};
+function buildInputRules(schema) {
+  const rules = [...prosemirrorInputrules.smartQuotes, prosemirrorInputrules.ellipsis, prosemirrorInputrules.emDash];
+  const n = schema.nodes;
+  if (n.blockquote) {
+    rules.push(prosemirrorInputrules.wrappingInputRule(/^\s*>\s$/, n.blockquote));
+  }
+  if (n.ordered_list) {
+    rules.push(
+      prosemirrorInputrules.wrappingInputRule(
+        /^(\d+)\.\s$/,
+        n.ordered_list,
+        (match) => ({ order: +match[1] }),
+        (match, node) => node.childCount + node.attrs.order === +match[1]
+      )
+    );
+  }
+  if (n.bullet_list) {
+    rules.push(prosemirrorInputrules.wrappingInputRule(/^\s*([-+*])\s$/, n.bullet_list));
+  }
+  if (n.heading) {
+    rules.push(
+      prosemirrorInputrules.textblockTypeInputRule(/^(#{1,6})\s$/, n.heading, (match) => ({
+        level: match[1].length
+      }))
+    );
+  }
+  return prosemirrorInputrules.inputRules({ rules });
+}
+function buildKeymapPlugins(schema) {
+  const bindings = {};
+  const m = schema.marks;
+  const n = schema.nodes;
+  const bind = (key, cmd) => {
+    if (cmd) bindings[key] = cmd;
+  };
+  bind("Mod-z", prosemirrorHistory.undo);
+  bind("Shift-Mod-z", prosemirrorHistory.redo);
+  bind("Mod-y", prosemirrorHistory.redo);
+  if (m.strong) bind("Mod-b", prosemirrorCommands.toggleMark(m.strong));
+  if (m.em) bind("Mod-i", prosemirrorCommands.toggleMark(m.em));
+  if (m.underline) bind("Mod-u", prosemirrorCommands.toggleMark(m.underline));
+  if (m.strikethrough) bind("Mod-Shift-s", prosemirrorCommands.toggleMark(m.strikethrough));
+  if (m.code) bind("Mod-e", prosemirrorCommands.toggleMark(m.code));
+  if (m.superscript) bind("Mod-.", prosemirrorCommands.toggleMark(m.superscript));
+  if (m.subscript) bind("Mod-,", prosemirrorCommands.toggleMark(m.subscript));
+  if (n.paragraph) bind("Shift-Mod-0", prosemirrorCommands.setBlockType(n.paragraph));
+  if (n.heading) {
+    for (let level = 1; level <= 6; level++) {
+      bind(`Shift-Mod-${level}`, prosemirrorCommands.setBlockType(n.heading, { level }));
+    }
+  }
+  const listItem = n.list_item;
+  if (listItem) {
+    bind("Enter", prosemirrorSchemaList.splitListItem(listItem));
+  }
+  const tabChain = [];
+  const shiftTabChain = [];
+  if (n.table) {
+    tabChain.push(prosemirrorTables.goToNextCell(1));
+    shiftTabChain.push(prosemirrorTables.goToNextCell(-1));
+  }
+  if (listItem) {
+    tabChain.push(prosemirrorSchemaList.sinkListItem(listItem));
+    shiftTabChain.push(prosemirrorSchemaList.liftListItem(listItem));
+  }
+  tabChain.push(changeIndent(1));
+  shiftTabChain.push(changeIndent(-1));
+  bindings["Tab"] = prosemirrorCommands.chainCommands(...tabChain);
+  bindings["Shift-Tab"] = prosemirrorCommands.chainCommands(...shiftTabChain);
+  if (n.hard_break) {
+    const br = n.hard_break;
+    const insertBreak = prosemirrorCommands.chainCommands(prosemirrorCommands.exitCode, (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+      return true;
+    });
+    bind("Shift-Enter", insertBreak);
+    bind("Mod-Enter", insertBreak);
+  }
+  return [prosemirrorKeymap.keymap(bindings), prosemirrorKeymap.keymap(prosemirrorCommands.baseKeymap)];
+}
+function placeholderPlugin(text2) {
+  return new prosemirrorState.Plugin({
+    props: {
+      decorations(state) {
+        const { doc: doc2 } = state;
+        const isEmpty = doc2.childCount === 1 && doc2.firstChild != null && doc2.firstChild.isTextblock && doc2.firstChild.content.size === 0;
+        if (!isEmpty) return null;
+        const decoration = prosemirrorView.Decoration.node(0, doc2.firstChild.nodeSize, {
+          class: "rne-empty",
+          "data-placeholder": text2
+        });
+        return prosemirrorView.DecorationSet.create(doc2, [decoration]);
+      }
+    }
+  });
+}
+function taskListPlugin(schema) {
+  return new prosemirrorState.Plugin({
+    props: {
+      handleDOMEvents: {
+        mousedown(view, event) {
+          if (!view.editable) return false;
+          const target = event.target;
+          if (!target || !target.classList?.contains("rne-task-checkbox")) return false;
+          try {
+            const pos = view.posAtDOM(target, 0);
+            if (pos == null || pos < 0) return false;
+            const $pos = view.state.doc.resolve(pos);
+            for (let depth = $pos.depth; depth > 0; depth--) {
+              const node = $pos.node(depth);
+              if (node.type === schema.nodes.list_item && node.attrs.checked !== null) {
+                const itemPos = $pos.before(depth);
+                const tr = view.state.tr.setNodeAttribute(itemPos, "checked", !node.attrs.checked);
+                view.dispatch(tr);
+                event.preventDefault();
+                return true;
+              }
+            }
+          } catch {
+            return false;
+          }
+          return false;
+        }
+      }
+    }
+  });
+}
+
+// src/core/pagination/compute.ts
+var EPS = 0.5;
+function toUnits(blocks) {
+  const units = [];
+  for (const block of blocks) {
+    if (!Number.isFinite(block.top) || !Number.isFinite(block.height)) continue;
+    if (block.lines && block.lines.length > 1) {
+      block.lines.forEach((line, i) => {
+        if (!Number.isFinite(line.top) || !Number.isFinite(line.height)) return;
+        units.push({ pos: line.pos, top: line.top, height: line.height, inline: i > 0 });
+      });
+    } else {
+      units.push({ pos: block.pos, top: block.top, height: block.height, inline: false });
+    }
+  }
+  units.sort((a, b) => a.top - b.top);
+  return units;
+}
+function computePagination(blocks, geo) {
+  const contentHeight = Math.max(1, geo.contentHeight);
+  const interPageOffset = Math.max(0, geo.interPageOffset);
+  const units = toUnits(blocks);
+  const breaks = [];
+  const pageContentTops = [0];
+  let pageStart = 0;
+  let cumSpacer = 0;
+  let pageIndex = 0;
+  for (const unit of units) {
+    const bottom = unit.top + unit.height;
+    const overflows = bottom - pageStart > contentHeight + EPS;
+    const startsBelowPageTop = unit.top - pageStart > EPS;
+    if (overflows && startsBelowPageTop) {
+      const usedHeight = unit.top - pageStart;
+      const spacerHeight = Math.max(0, contentHeight - usedHeight) + interPageOffset;
+      pageIndex += 1;
+      cumSpacer += spacerHeight;
+      breaks.push({ pos: unit.pos, spacerHeight, pageIndex, inline: unit.inline });
+      pageContentTops.push(unit.top + cumSpacer);
+      pageStart = unit.top;
+    }
+  }
+  return { breaks, pageCount: pageIndex + 1, pageContentTops };
+}
+function paginationEquals(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.pageCount !== b.pageCount || a.breaks.length !== b.breaks.length) return false;
+  for (let i = 0; i < a.breaks.length; i++) {
+    const x = a.breaks[i];
+    const y = b.breaks[i];
+    if (x.pos !== y.pos || Math.abs(x.spacerHeight - y.spacerHeight) > 1) return false;
+  }
+  return true;
+}
+
+// src/core/pagination/plugin.ts
+var LINE_SPLIT_MIN_RATIO = 0.25;
+var MAX_LINES_PER_BLOCK = 4e3;
+var paginationKey = new prosemirrorState.PluginKey("rne-pagination");
+function buildDecorations(doc2, result) {
+  if (!result || result.breaks.length === 0) return prosemirrorView.DecorationSet.empty;
+  const decorations = result.breaks.map(
+    (br) => prosemirrorView.Decoration.widget(
+      br.pos,
+      () => {
+        const el = document.createElement("span");
+        el.className = `rne-page-spacer${br.inline ? " rne-page-spacer--inline" : ""}`;
+        el.style.display = "block";
+        el.style.width = "100%";
+        el.style.height = `${Math.max(0, br.spacerHeight)}px`;
+        el.setAttribute("contenteditable", "false");
+        el.setAttribute("aria-hidden", "true");
+        return el;
+      },
+      {
+        side: -1,
+        key: `rne-pb:${br.pos}:${Math.round(br.spacerHeight)}`,
+        ignoreSelection: true,
+        marks: []
+      }
+    )
+  );
+  return prosemirrorView.DecorationSet.create(doc2, decorations);
+}
+function paginationPlugin(options) {
+  return new prosemirrorState.Plugin({
+    key: paginationKey,
+    state: {
+      init: () => ({ result: null, decorations: prosemirrorView.DecorationSet.empty }),
+      apply(tr, prev) {
+        const meta = tr.getMeta(paginationKey);
+        if (meta) {
+          return { result: meta.result, decorations: buildDecorations(tr.doc, meta.result) };
+        }
+        if (tr.docChanged) {
+          const result = prev.result ? {
+            ...prev.result,
+            breaks: prev.result.breaks.map((b) => ({ ...b, pos: tr.mapping.map(b.pos) }))
+          } : prev.result;
+          return { result, decorations: prev.decorations.map(tr.mapping, tr.doc) };
+        }
+        return prev;
+      }
+    },
+    props: {
+      decorations(state) {
+        return paginationKey.getState(state)?.decorations ?? prosemirrorView.DecorationSet.empty;
+      }
+    },
+    view(view) {
+      return new PaginationView(view, options);
+    }
+  });
+}
+var PaginationView = class {
+  constructor(view, options) {
+    this.scheduled = false;
+    this.destroyed = false;
+    this.resizeObserver = null;
+    this.onWindowResize = () => this.schedule();
+    this.onAssetLoad = (e) => {
+      if (e.target?.tagName === "IMG") this.schedule();
+    };
+    this.view = view;
+    this.options = options;
+    if (typeof ResizeObserver !== "undefined") {
+      this.resizeObserver = new ResizeObserver(() => this.schedule());
+      this.resizeObserver.observe(view.dom);
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("resize", this.onWindowResize);
+    }
+    view.dom.addEventListener("load", this.onAssetLoad, true);
+    options.register?.(() => this.schedule());
+    this.schedule();
+  }
+  update(view, prevState) {
+    this.view = view;
+    if (view.state.doc !== prevState.doc) this.schedule();
+  }
+  schedule() {
+    if (this.scheduled || this.destroyed) return;
+    this.scheduled = true;
+    const raf = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(() => cb(0), 16);
+    raf(() => {
+      this.scheduled = false;
+      if (!this.destroyed) this.measure();
+    });
+  }
+  measure() {
+    try {
+      const geo = this.options.getGeometry();
+      const bg = this.options.getBackgroundLayer();
+      if (!geo || !bg || geo.contentHeightPx <= 0 || geo.pageHeightPx <= 0) {
+        this.clearBackground(bg);
+        return;
+      }
+      const current = paginationKey.getState(this.view.state)?.result ?? null;
+      const blocks = this.measureBlocks(geo, current);
+      const result = computePagination(blocks, {
+        contentHeight: geo.contentHeightPx,
+        interPageOffset: geo.interPageOffsetPx
+      });
+      this.renderBackground(bg, geo, result);
+      this.options.onPageCount?.(result.pageCount);
+      if (!paginationEquals(result, current)) {
+        this.view.dispatch(this.view.state.tr.setMeta(paginationKey, { result }));
+      }
+    } catch {
+    }
+  }
+  /** Measure top-level blocks in spacer-independent natural coordinates. */
+  measureBlocks(geo, current) {
+    const view = this.view;
+    const contentRect = view.dom.getBoundingClientRect();
+    const paddingTop = geo.marginTopPx;
+    const currentBreaks = current?.breaks ?? [];
+    const lineSplitThreshold = geo.contentHeightPx * LINE_SPLIT_MIN_RATIO;
+    const offsets = [];
+    const naturalTops = [];
+    const rectHeights = [];
+    const elements = [];
+    const splittable = [];
+    view.state.doc.forEach((node, offset) => {
+      let dom = null;
+      try {
+        dom = view.nodeDOM(offset);
+      } catch {
+        dom = null;
+      }
+      if (!(dom instanceof HTMLElement)) return;
+      const rect = dom.getBoundingClientRect();
+      const renderedTop = rect.top - contentRect.top;
+      let spacerBefore = 0;
+      for (const br of currentBreaks) if (br.pos <= offset) spacerBefore += br.spacerHeight;
+      offsets.push(offset);
+      naturalTops.push(renderedTop - spacerBefore - paddingTop);
+      rectHeights.push(rect.height);
+      elements.push(dom);
+      splittable.push(!node.isAtom && node.type.name !== "table");
+    });
+    const blocks = [];
+    for (let i = 0; i < offsets.length; i++) {
+      const height = i < offsets.length - 1 ? Math.max(rectHeights[i], naturalTops[i + 1] - naturalTops[i]) : rectHeights[i];
+      let lines;
+      if (splittable[i] && rectHeights[i] > lineSplitThreshold) {
+        lines = this.measureLines(elements[i], offsets[i], contentRect, paddingTop, currentBreaks);
+      }
+      blocks.push({ pos: offsets[i], top: naturalTops[i], height, lines });
+    }
+    return blocks;
+  }
+  /**
+   * Measure the line boxes of a tall, splittable block in spacer-independent
+   * natural coordinates so the block can break across pages at line boundaries.
+   * Returns `undefined` (block moves whole) if measurement is unavailable or a
+   * line position cannot be resolved — never throws.
+   */
+  measureLines(dom, blockOffset, contentRect, paddingTop, currentBreaks) {
+    try {
+      if (typeof document === "undefined" || typeof document.createRange !== "function") {
+        return void 0;
+      }
+      const range = document.createRange();
+      range.selectNodeContents(dom);
+      const rects = range.getClientRects();
+      if (!rects || rects.length === 0) return void 0;
+      const rawLines = [];
+      for (let i = 0; i < rects.length && rawLines.length < MAX_LINES_PER_BLOCK; i++) {
+        const r = rects[i];
+        if (r.width <= 0 || r.height <= 0) continue;
+        const last = rawLines[rawLines.length - 1];
+        if (last && Math.abs(last.top - r.top) < 3) {
+          last.bottom = Math.max(last.bottom, r.bottom);
+          last.left = Math.min(last.left, r.left);
+        } else {
+          rawLines.push({ top: r.top, bottom: r.bottom, left: r.left });
+        }
+      }
+      if (rawLines.length < 2) return void 0;
+      const spacerBeforePos = (pos) => {
+        let total = 0;
+        for (const br of currentBreaks) if (br.pos <= pos) total += br.spacerHeight;
+        return total;
+      };
+      const lines = [];
+      for (let i = 0; i < rawLines.length; i++) {
+        const rl = rawLines[i];
+        let pos;
+        if (i === 0) {
+          pos = blockOffset;
+        } else {
+          const at = this.view.posAtCoords({ left: rl.left + 1, top: (rl.top + rl.bottom) / 2 });
+          if (!at) continue;
+          pos = at.pos;
+        }
+        const naturalTop = rl.top - contentRect.top - spacerBeforePos(pos) - paddingTop;
+        lines.push({ pos, top: naturalTop, height: rl.bottom - rl.top });
+      }
+      return lines.length >= 2 ? lines : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  renderBackground(bg, geo, result) {
+    while (bg.firstChild) bg.removeChild(bg.firstChild);
+    const { pageContentTops, pageCount } = result;
+    const headerCfg = this.options.header;
+    const footerCfg = this.options.footer;
+    for (let p = 0; p < pageCount; p++) {
+      const sheetTop = pageContentTops[p] ?? p * (geo.contentHeightPx + geo.interPageOffsetPx);
+      const sheet = document.createElement("div");
+      sheet.className = "rne-page-sheet";
+      sheet.style.top = `${sheetTop}px`;
+      sheet.style.height = `${geo.pageHeightPx}px`;
+      sheet.style.width = `${geo.pageWidthPx}px`;
+      bg.appendChild(sheet);
+      if (headerCfg?.show && headerCfg.text) {
+        bg.appendChild(
+          this.runningElement(
+            "rne-page-header",
+            interpolate(headerCfg.text, p + 1, pageCount),
+            sheetTop + geo.marginTopPx * 0.35,
+            geo,
+            headerCfg.align ?? "left"
+          )
+        );
+      }
+      const footerText = footerCfg?.text ?? (footerCfg?.pageNumbers ? "Page {page} of {pages}" : void 0);
+      if ((footerCfg?.show || footerCfg?.pageNumbers) && footerText) {
+        bg.appendChild(
+          this.runningElement(
+            "rne-page-footer",
+            interpolate(footerText, p + 1, pageCount),
+            sheetTop + geo.pageHeightPx - geo.marginBottomPx * 0.6,
+            geo,
+            footerCfg.align ?? "center"
+          )
+        );
+      }
+    }
+    const lastTop = pageContentTops[pageCount - 1] ?? 0;
+    const totalHeight = lastTop + geo.pageHeightPx;
+    bg.style.height = `${totalHeight}px`;
+    const container = bg.parentElement;
+    if (container) container.style.minHeight = `${totalHeight}px`;
+  }
+  runningElement(className, text2, top, geo, align) {
+    const el = document.createElement("div");
+    el.className = className;
+    el.textContent = text2;
+    el.style.position = "absolute";
+    el.style.top = `${top}px`;
+    el.style.left = `${geo.marginLeftPx}px`;
+    el.style.width = `${geo.contentWidthPx}px`;
+    el.style.textAlign = align;
+    el.setAttribute("aria-hidden", "true");
+    return el;
+  }
+  clearBackground(bg) {
+    if (!bg) return;
+    while (bg.firstChild) bg.removeChild(bg.firstChild);
+    bg.style.height = "";
+    const container = bg.parentElement;
+    if (container) container.style.minHeight = "";
+  }
+  destroy() {
+    this.destroyed = true;
+    this.resizeObserver?.disconnect();
+    if (typeof window !== "undefined") window.removeEventListener("resize", this.onWindowResize);
+    this.view.dom.removeEventListener("load", this.onAssetLoad, true);
+  }
+};
+function interpolate(text2, page, pages) {
+  return text2.replace(/\{page\}/g, String(page)).replace(/\{pages\}/g, String(pages));
+}
+
+// src/core/plugins/index.ts
+function pasteSanitizerPlugin() {
+  return new prosemirrorState.Plugin({
+    props: {
+      transformPastedHTML(html) {
+        return chunk5F6SPYCN_cjs.sanitizeHtmlSync(html);
+      }
+    }
+  });
+}
+function buildPlugins(schema, options = {}) {
+  const plugins = [];
+  if (options.history !== false) {
+    plugins.push(prosemirrorHistory.history());
+  }
+  plugins.push(buildInputRules(schema));
+  plugins.push(...buildKeymapPlugins(schema));
+  plugins.push(prosemirrorDropcursor.dropCursor({ color: "var(--rne-accent, #df4a36)", width: 2 }));
+  plugins.push(prosemirrorGapcursor.gapCursor());
+  if (schema.nodes.table) {
+    plugins.push(prosemirrorTables.columnResizing());
+    plugins.push(prosemirrorTables.tableEditing());
+  }
+  plugins.push(taskListPlugin(schema));
+  plugins.push(pasteSanitizerPlugin());
+  if (options.placeholder) {
+    plugins.push(placeholderPlugin(options.placeholder));
+  }
+  if (options.pagination) {
+    plugins.push(paginationPlugin(options.pagination));
+  }
+  if (options.appendTransaction) {
+    const hook = options.appendTransaction;
+    plugins.push(new prosemirrorState.Plugin({ appendTransaction: (trs, oldS, newS) => hook(trs, oldS, newS) ?? null }));
+  }
+  if (options.extraPlugins?.length) {
+    plugins.push(...options.extraPlugins);
+  }
+  return plugins;
+}
+function createDoc(schema, content) {
+  if (content == null) return emptyDoc(schema);
+  if (typeof content === "string") {
+    return docFromText(schema, content);
+  }
+  try {
+    const node = prosemirrorModel.Node.fromJSON(schema, content);
+    node.check();
+    return node;
+  } catch (err) {
+    console.error("[react-next-editor] Invalid initial content, using empty document.", err);
+    return emptyDoc(schema);
+  }
+}
+function emptyDoc(schema) {
+  const doc2 = schema.nodes.doc.createAndFill();
+  if (!doc2) throw new Error("Schema cannot create an empty document.");
+  return doc2;
+}
+function docFromText(schema, text2) {
+  const paragraphType = schema.nodes.paragraph;
+  const lines = text2.split(/\r\n|\r|\n/);
+  const paragraphs = lines.map(
+    (line) => line ? paragraphType.create(null, schema.text(line)) : paragraphType.createAndFill()
+  );
+  if (paragraphs.length === 0) return emptyDoc(schema);
+  return schema.nodes.doc.create(null, paragraphs);
+}
+function createEditorState(options) {
+  const { schema, plugins, content } = options;
+  return prosemirrorState.EditorState.create({
+    doc: createDoc(schema, content),
+    plugins
+  });
+}
+
+// src/core/utils.ts
+function countDocument(doc2) {
+  let text2 = "";
+  doc2.descendants((node) => {
+    if (node.isText && node.text) {
+      text2 += node.text;
+    } else if (node.type.name === "hard_break") {
+      text2 += " ";
+    }
+    return true;
+  });
+  const trimmed = text2.trim();
+  const words = trimmed ? trimmed.split(/\s+/).length : 0;
+  return {
+    words,
+    characters: text2.length,
+    charactersNoSpaces: text2.replace(/\s/g, "").length
+  };
+}
+
+Object.defineProperty(exports, "splitListItem", {
+  enumerable: true,
+  get: function () { return prosemirrorSchemaList.splitListItem; }
+});
+exports.INDENT_STEP_EM = INDENT_STEP_EM;
+exports.MAX_INDENT = MAX_INDENT;
+exports.blockAttrs = blockAttrs;
+exports.blockDOMAttrs = blockDOMAttrs;
+exports.buildInputRules = buildInputRules;
+exports.buildKeymapPlugins = buildKeymapPlugins;
+exports.buildPlugins = buildPlugins;
+exports.buildSchema = buildSchema;
+exports.changeIndent = changeIndent;
+exports.clampIndent = clampIndent;
+exports.clearFormatting = clearFormatting;
+exports.countDocument = countDocument;
+exports.createCommands = createCommands;
+exports.createDoc = createDoc;
+exports.createEditorState = createEditorState;
+exports.createTableNode = createTableNode;
+exports.defaultEnabled = defaultEnabled;
+exports.defaultSchema = defaultSchema;
+exports.editingCommands = editingCommands;
+exports.getActiveMarkAttrs = getActiveMarkAttrs;
+exports.insertImage = insertImage;
+exports.insertTable = insertTable;
+exports.isBlockActive = isBlockActive;
+exports.isInNode = isInNode;
+exports.isMarkActive = isMarkActive;
+exports.isTextAlign = isTextAlign;
+exports.isTextblockAttrActive = isTextblockAttrActive;
+exports.marks_exports = marks_exports;
+exports.nodes_exports = nodes_exports;
+exports.paginationKey = paginationKey;
+exports.paginationPlugin = paginationPlugin;
+exports.placeholderPlugin = placeholderPlugin;
+exports.readBlockAttrs = readBlockAttrs;
+exports.removeLink = removeLink;
+exports.setLink = setLink;
+exports.setMark = setMark;
+exports.setTextblockAttr = setTextblockAttr;
+exports.taskListPlugin = taskListPlugin;
+exports.unsetMark = unsetMark;
+//# sourceMappingURL=chunk-DBSFCCBG.cjs.map
+//# sourceMappingURL=chunk-DBSFCCBG.cjs.map