@kedataindo/docflow-core 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/Editor.ts
-import { Editor as TiptapEditor, getSchema } from "@tiptap/core";
+import { Extension as Extension5, Editor as TiptapEditor } from "@tiptap/core";
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "@tiptap/pm/state";
 import StarterKit from "@tiptap/starter-kit";
 import TextStyle from "@tiptap/extension-text-style";
-import { prosemirrorJSONToYXmlFragment } from "y-prosemirror";
 
 // src/PluginSystem.ts
 function definePlugin(plugin) {
@@ -55,9 +55,23 @@ function createActionMap(editor, plugins) {
 import { Collaboration } from "@tiptap/extension-collaboration";
 import { CollaborationCursor } from "@tiptap/extension-collaboration-cursor";
 import { Awareness } from "y-protocols/awareness";
+import { IndexeddbPersistence } from "y-indexeddb";
 import { WebrtcProvider } from "y-webrtc";
 import { WebsocketProvider } from "y-websocket";
 import * as Y from "yjs";
+var LOCAL_SIGNALING = ["ws://localhost:4444"];
+var warnedLocalSignaling = false;
+function resolveSignalingUrls(signaling) {
+  if (signaling && signaling.length > 0) return signaling;
+  if (!warnedLocalSignaling) {
+    warnedLocalSignaling = true;
+    console.warn(
+      '[docflow] webrtc provider has no `signaling` configured \u2014 falling back to localhost-only sync (ws://localhost:4444 + same-browser tabs). For production self-host, run your own signaling server and pass `signaling`, or use `provider: "websocket"` with your own websocketUrl.'
+    );
+  }
+  return LOCAL_SIGNALING;
+}
+var LOCAL_PRESENT_DEFAULT = true;
 function createAwarenessStates(awareness) {
   const states = [];
   awareness.getStates().forEach((state, clientId) => {
@@ -65,7 +79,11 @@ function createAwarenessStates(awareness) {
     states.push({
       clientId,
       user: raw.user ?? { name: "", color: "" },
-      cursor: raw.cursor ?? null
+      cursor: raw.cursor ?? null,
+      // `present` defaults to true for backwards compat (legacy states
+      // don't set it) and for the local user (always considered present
+      // until PR2 toggles it off).
+      present: raw.present ?? LOCAL_PRESENT_DEFAULT
     });
   });
   return states;
@@ -75,14 +93,14 @@ function createCollaboration(options) {
   if (options.initialStorageState) {
     Y.applyUpdate(ydoc, options.initialStorageState);
   }
+  let persistence;
+  if (options.offline) {
+    persistence = new IndexeddbPersistence(`docflow-${options.room}`, ydoc);
+  }
   let provider = null;
   if (options.provider === "webrtc") {
     provider = new WebrtcProvider(options.room, ydoc, {
-      signaling: options.signaling || [
-        "ws://localhost:4444",
-        "wss://signaling.yjs.dev",
-        "wss://y-webrtc-eu.fly.dev"
-      ]
+      signaling: resolveSignalingUrls(options.signaling)
     });
   } else if (options.provider === "websocket") {
     if (!options.websocketUrl) {
@@ -92,6 +110,16 @@ function createCollaboration(options) {
   }
   const awareness = provider?.awareness ?? new Awareness(ydoc);
   awareness.setLocalStateField("user", options.user);
+  let emitCursor = options.emitCursor ?? true;
+  const setLocalCursorEnabled = (enabled) => {
+    if (emitCursor === enabled) return;
+    emitCursor = enabled;
+    if (!enabled) {
+      awareness.setLocalStateField("cursor", null);
+    }
+    awareness.setLocalStateField("present", enabled);
+  };
+  awareness.setLocalStateField("present", emitCursor);
   let awarenessHandler;
   if (options.onAwarenessChange) {
     const notify = () => {
@@ -108,9 +136,10 @@ function createCollaboration(options) {
     awareness.setLocalState(null);
     provider?.destroy?.();
     awareness.destroy?.();
+    void persistence?.destroy();
     ydoc.destroy();
   };
-  return { ydoc, provider, awareness, destroy };
+  return { ydoc, provider, awareness, persistence, destroy, setLocalCursorEnabled };
 }
 function collaborationExtensions(options) {
   const setup = "ydoc" in options ? options : createCollaboration(options);
@@ -189,8 +218,1016 @@ var BlockAttributesExtension = Extension.create({
   }
 });
 
+// src/EditorContext.ts
+import { Extension as Extension2 } from "@tiptap/core";
+var EditorContextExtension = Extension2.create({
+  name: "editorContext",
+  addOptions() {
+    return {
+      onImageUpload: void 0,
+      citation: void 0,
+      aiStream: void 0,
+      aiDraft: void 0
+    };
+  },
+  addStorage() {
+    return {
+      onImageUpload: this.options.onImageUpload,
+      citation: this.options.citation,
+      aiStream: this.options.aiStream,
+      aiDraft: this.options.aiDraft
+    };
+  }
+});
+
+// src/SearchAndReplace.ts
+import { Extension as Extension3 } from "@tiptap/core";
+import { Plugin as Plugin2, PluginKey as PluginKey2, TextSelection } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+var searchAndReplaceKey = new PluginKey2("searchAndReplace");
+var EMPTY_STATE = { query: "", matches: [], activeIndex: 0 };
+function findMatches(doc, query) {
+  const matches = [];
+  if (!query) return matches;
+  const needle = query.toLowerCase();
+  doc.descendants((node, pos) => {
+    if (!node.isText || !node.text) return;
+    const hay = node.text.toLowerCase();
+    let idx = hay.indexOf(needle);
+    while (idx !== -1) {
+      matches.push({ from: pos + idx, to: pos + idx + needle.length });
+      idx = hay.indexOf(needle, idx + needle.length);
+    }
+  });
+  return matches;
+}
+function clampIndex(index, matches) {
+  if (matches.length === 0) return 0;
+  return Math.min(Math.max(index, 0), matches.length - 1);
+}
+function computeState(doc, query, activeIndex = 0) {
+  const matches = findMatches(doc, query);
+  return { query, matches, activeIndex: clampIndex(activeIndex, matches) };
+}
+var searchPlugin = new Plugin2({
+  key: searchAndReplaceKey,
+  state: {
+    init: () => EMPTY_STATE,
+    apply: (tr, prev) => {
+      const meta = tr.getMeta(searchAndReplaceKey);
+      if (meta) {
+        if (meta.type === "clear") return EMPTY_STATE;
+        if (meta.type === "set") return computeState(tr.doc, meta.query);
+        return { ...prev, activeIndex: clampIndex(meta.index, prev.matches) };
+      }
+      if (tr.docChanged && prev.query) {
+        return computeState(tr.doc, prev.query, prev.activeIndex);
+      }
+      return prev;
+    }
+  },
+  props: {
+    decorations: (state) => {
+      const s = searchAndReplaceKey.getState(state);
+      if (!s || s.matches.length === 0) return null;
+      return DecorationSet2.create(
+        state.doc,
+        s.matches.map(
+          (m, i) => Decoration2.inline(m.from, m.to, {
+            class: i === s.activeIndex ? "find-match find-match-active" : "find-match"
+          })
+        )
+      );
+    }
+  }
+});
+var SearchAndReplaceExtension = Extension3.create({
+  name: "searchAndReplace",
+  addProseMirrorPlugins() {
+    return [searchPlugin];
+  }
+});
+function getSearchState(editor) {
+  return searchAndReplaceKey.getState(editor.state) ?? EMPTY_STATE;
+}
+function setSearchQuery(editor, query) {
+  editor.view.dispatch(editor.state.tr.setMeta(searchAndReplaceKey, { type: "set", query }));
+}
+function clearSearch(editor) {
+  editor.view.dispatch(editor.state.tr.setMeta(searchAndReplaceKey, { type: "clear" }));
+}
+function activateMatch(editor, index) {
+  const s = getSearchState(editor);
+  const match = s.matches[index];
+  const tr = editor.state.tr.setMeta(searchAndReplaceKey, { type: "setActive", index });
+  if (match) {
+    tr.setSelection(TextSelection.create(editor.state.doc, match.from, match.to));
+    tr.scrollIntoView();
+  }
+  editor.view.dispatch(tr);
+}
+function searchNext(editor) {
+  const s = getSearchState(editor);
+  if (s.matches.length === 0) return null;
+  const next = (s.activeIndex + 1) % s.matches.length;
+  activateMatch(editor, next);
+  return s.matches[next];
+}
+function searchPrev(editor) {
+  const s = getSearchState(editor);
+  if (s.matches.length === 0) return null;
+  const prev = (s.activeIndex - 1 + s.matches.length) % s.matches.length;
+  activateMatch(editor, prev);
+  return s.matches[prev];
+}
+function replaceCurrent(editor, replacement) {
+  const s = getSearchState(editor);
+  const match = s.matches[s.activeIndex];
+  if (!match) return false;
+  editor.view.dispatch(editor.state.tr.insertText(replacement, match.from, match.to));
+  return true;
+}
+function replaceAll(editor, replacement) {
+  const s = getSearchState(editor);
+  if (s.matches.length === 0) return 0;
+  const tr = editor.state.tr;
+  for (let i = s.matches.length - 1; i >= 0; i--) {
+    tr.insertText(replacement, s.matches[i].from, s.matches[i].to);
+  }
+  editor.view.dispatch(tr);
+  return s.matches.length;
+}
+
+// ../../node_modules/.pnpm/tiptap-pagination-plus@3.1.0_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/tiptap-pagination-plus/dist/PaginationPlus.js
+import { Extension as Extension4 } from "@tiptap/core";
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@tiptap/pm/state";
+import { ReplaceStep, ReplaceAroundStep, AddMarkStep, RemoveMarkStep, RemoveNodeMarkStep, AttrStep } from "@tiptap/pm/transform";
+import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "@tiptap/pm/view";
+
+// ../../node_modules/.pnpm/tiptap-pagination-plus@3.1.0_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/tiptap-pagination-plus/dist/utils.js
+var updateCssVariables = (targetNode, config) => {
+  const cssVariables = {
+    "rm-page-height": `${config.pageHeight}px`,
+    "rm-margin-top": `${config.marginTop}px`,
+    "rm-margin-bottom": `${config.marginBottom}px`,
+    "rm-margin-left": `${config.marginLeft}px`,
+    "rm-margin-right": `${config.marginRight}px`,
+    "rm-content-margin-top": `${config.contentMarginTop}px`,
+    "rm-content-margin-bottom": `${config.contentMarginBottom}px`,
+    "rm-page-gap-border-color": `${config.pageGapBorderColor}`,
+    "rm-page-width": `${config.pageWidth}px`
+  };
+  Object.entries(cssVariables).forEach(([key2, value]) => {
+    targetNode.style.setProperty(`--${key2}`, value);
+  });
+};
+var getPageSize = (height, width, marginTop, marginBottom, marginLeft, marginRight) => {
+  return {
+    pageHeight: height,
+    pageWidth: width,
+    marginTop,
+    marginBottom,
+    marginLeft,
+    marginRight
+  };
+};
+var getHeaderHeight = (targetNode, pageNumbers, type) => {
+  const headerHeightMap = /* @__PURE__ */ new Map();
+  const clientHeader = targetNode.querySelector(getHeaderHeightSelector(0, type));
+  headerHeightMap.set(0, clientHeader ? clientHeader.clientHeight : 0);
+  pageNumbers.forEach((pageNumber) => {
+    const clientHeader2 = targetNode.querySelector(getHeaderHeightSelector(pageNumber, type));
+    const headerHeight = clientHeader2 ? clientHeader2.clientHeight : 0;
+    headerHeightMap.set(pageNumber, headerHeight);
+  });
+  return headerHeightMap;
+};
+var getHeaderHeightSelector = (pageNumber, type) => {
+  return type === "actual" ? `.rm-page-header-${pageNumber}` : `.rm-page-header-${pageNumber} .rm-page-header-content`;
+};
+var getFooterHeight = (targetNode, pageNumbers, type) => {
+  const footerHeightMap = /* @__PURE__ */ new Map();
+  const clientFooter = targetNode.querySelector(getFooterHeightSelector(0, type));
+  footerHeightMap.set(0, clientFooter ? clientFooter.clientHeight : 0);
+  pageNumbers.forEach((pageNumber) => {
+    const clientFooter2 = targetNode.querySelector(getFooterHeightSelector(pageNumber, type));
+    const footerHeight = clientFooter2 ? clientFooter2.clientHeight : 0;
+    footerHeightMap.set(pageNumber, footerHeight);
+  });
+  return footerHeightMap;
+};
+var getFooterHeightSelector = (pageNumber, type) => {
+  return type === "actual" ? `.rm-page-footer-${pageNumber}` : `.rm-page-footer-${pageNumber} .rm-page-footer-content`;
+};
+function deepEqualIterative(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
+    return false;
+  }
+  const stack = [{ x: a, y: b }];
+  while (stack.length) {
+    const _stackItem = stack.pop();
+    if (!_stackItem)
+      continue;
+    const { x, y } = _stackItem;
+    if (x === y)
+      continue;
+    if (typeof x !== typeof y)
+      return false;
+    if (typeof x !== "object")
+      return false;
+    if (x == null || y == null)
+      return false;
+    const xKeys = Object.keys(x);
+    const yKeys = Object.keys(y);
+    if (xKeys.length !== yKeys.length)
+      return false;
+    for (const key2 of xKeys) {
+      if (!(key2 in y))
+        return false;
+      const xVal = x[key2];
+      const yVal = y[key2];
+      if (xVal === yVal)
+        continue;
+      if (typeof xVal === "object" && typeof yVal === "object") {
+        stack.push({ x: xVal, y: yVal });
+      } else {
+        if (xVal !== yVal)
+          return false;
+      }
+    }
+  }
+  return true;
+}
+function getCustomPages(customHeader, customFooter) {
+  return [...Object.keys(customHeader), ...Object.keys(customFooter)].map(Number);
+}
+function getFooter(footerRightContent, footerLeftContent, onFooterClick, pageNumber) {
+  const pageFooter = document.createElement("div");
+  pageFooter.classList.add("rm-page-footer");
+  pageFooter.classList.add(`rm-page-footer-${pageNumber ? pageNumber : 0}`);
+  pageFooter.style.overflow = "visible";
+  pageFooter.style.position = "relative";
+  pageFooter.style.cursor = "pointer";
+  const pageFooterContent = document.createElement("div");
+  pageFooterContent.classList.add("rm-page-footer-content");
+  pageFooterContent.style.width = "100%";
+  pageFooterContent.style.overflow = "hidden";
+  const footerRight = footerRightContent.replace("{page}", `<span class="rm-page-number"></span>`);
+  const footerLeft = footerLeftContent.replace("{page}", `<span class="rm-page-number"></span>`);
+  const pageFooterLeft = document.createElement("div");
+  pageFooterLeft.classList.add("rm-page-footer-left");
+  pageFooterLeft.innerHTML = footerLeft;
+  const pageFooterRight = document.createElement("div");
+  pageFooterRight.classList.add("rm-page-footer-right");
+  pageFooterRight.innerHTML = footerRight;
+  pageFooterContent.append(pageFooterLeft, pageFooterRight);
+  pageFooter.append(pageFooterContent);
+  pageFooter.addEventListener("click", onFooterClick);
+  return pageFooter;
+}
+function getHeader(headerRightContent, headerLeftContent, onHeaderClick, pageNumber) {
+  const pageHeader = document.createElement("div");
+  pageHeader.classList.add("rm-page-header");
+  pageHeader.classList.add(`rm-page-header-${pageNumber ? pageNumber : 0}`);
+  pageHeader.style.overflow = "hidden";
+  pageHeader.style.cursor = "pointer";
+  pageHeader.style.position = "relative";
+  const pageHeaderContent = document.createElement("div");
+  pageHeaderContent.classList.add("rm-page-header-content");
+  pageHeaderContent.style.width = "100%";
+  pageHeaderContent.style.overflow = "hidden";
+  const headerLeft = headerLeftContent.replace("{page}", `<span class="rm-page-number-plus"></span>`);
+  const headerRight = headerRightContent.replace("{page}", `<span class="rm-page-number-plus"></span>`);
+  const pageHeaderLeft = document.createElement("div");
+  pageHeaderLeft.classList.add("rm-page-header-left");
+  pageHeaderLeft.innerHTML = headerLeft;
+  const pageHeaderRight = document.createElement("div");
+  pageHeaderRight.classList.add("rm-page-header-right");
+  pageHeaderRight.innerHTML = headerRight;
+  pageHeaderContent.append(pageHeaderLeft, pageHeaderRight);
+  pageHeader.append(pageHeaderContent);
+  pageHeader.addEventListener("click", onHeaderClick);
+  return pageHeader;
+}
+var getHeight = (pageOptions, _headerHeight, _footerHeight) => {
+  const _pageHeaderHeight = pageOptions.contentMarginTop + pageOptions.marginTop + _headerHeight;
+  const _pageFooterHeight = pageOptions.contentMarginBottom + pageOptions.marginBottom + _footerHeight;
+  const _pageHeight = pageOptions.pageHeight - _pageHeaderHeight - _pageFooterHeight;
+  return {
+    _pageHeaderHeight,
+    _pageFooterHeight,
+    _pageHeight
+  };
+};
+var headerClickEvent = (pageNumber, onHeaderClick) => {
+  return (event) => {
+    onHeaderClick === null || onHeaderClick === void 0 ? void 0 : onHeaderClick({
+      event,
+      pageNumber
+    });
+  };
+};
+var footerClickEvent = (pageNumber, onFooterClick) => {
+  return (event) => {
+    onFooterClick === null || onFooterClick === void 0 ? void 0 : onFooterClick({
+      event,
+      pageNumber
+    });
+  };
+};
+
+// ../../node_modules/.pnpm/tiptap-pagination-plus@3.1.0_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/tiptap-pagination-plus/dist/PaginationPlus.js
+var page_count_meta_key = "PAGE_COUNT_META_KEY";
+var key = new PluginKey3("brDecoration");
+function buildDecorations(doc) {
+  const decorations = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name === "hardBreak") {
+      const afterPos = pos + 1;
+      const widget = Decoration3.widget(afterPos, () => {
+        const el = document.createElement("span");
+        el.classList.add("rm-br-decoration");
+        return el;
+      });
+      decorations.push(widget);
+    }
+  });
+  return DecorationSet3.create(doc, decorations);
+}
+var defaultPageConfig = {
+  enabled: true,
+  pageBreakBackground: "#ffffff",
+  pageHeight: 800,
+  pageWidth: 789,
+  marginTop: 20,
+  marginBottom: 20,
+  marginLeft: 50,
+  marginRight: 50,
+  pageGap: 50,
+  contentMarginTop: 10,
+  contentMarginBottom: 10,
+  footerRight: "{page}",
+  footerLeft: "",
+  headerRight: "",
+  headerLeft: "",
+  customHeader: {},
+  customFooter: {}
+};
+var defaultOptions = Object.assign({ pageGapBorderSize: 1, pageGapBorderColor: "#e5e5e5" }, defaultPageConfig);
+var refreshPage = (targetNode, paginationEnabled = true) => {
+  var _a;
+  const paginationElement = targetNode.querySelector("[data-rm-pagination]");
+  if (paginationEnabled) {
+    targetNode.removeAttribute("rm-pagination-disabled");
+    if (paginationElement) {
+      const lastPageBreak = (_a = paginationElement.lastElementChild) === null || _a === void 0 ? void 0 : _a.querySelector(".breaker");
+      if (lastPageBreak) {
+        const minHeight = lastPageBreak.offsetTop + lastPageBreak.offsetHeight;
+        targetNode.style.minHeight = `calc(${minHeight}px + 2px)`;
+      }
+    }
+  } else {
+    targetNode.setAttribute("rm-pagination-disabled", "");
+    targetNode.style.minHeight = `auto`;
+  }
+};
+var getPageConfig = (_storage, _currentOptions) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+  const pageConfig = {
+    enabled: (_a = _storage.enabled) !== null && _a !== void 0 ? _a : defaultOptions.enabled,
+    pageBreakBackground: (_b = _storage.pageBreakBackground) !== null && _b !== void 0 ? _b : defaultOptions.pageBreakBackground,
+    pageHeight: (_c = _storage.pageHeight) !== null && _c !== void 0 ? _c : defaultOptions.pageHeight,
+    pageWidth: (_d = _storage.pageWidth) !== null && _d !== void 0 ? _d : defaultPageConfig.pageWidth,
+    marginTop: (_e = _storage.marginTop) !== null && _e !== void 0 ? _e : defaultPageConfig.marginTop,
+    marginBottom: (_f = _storage.marginBottom) !== null && _f !== void 0 ? _f : defaultPageConfig.marginBottom,
+    marginLeft: (_g = _storage.marginLeft) !== null && _g !== void 0 ? _g : defaultPageConfig.marginLeft,
+    marginRight: (_h = _storage.marginRight) !== null && _h !== void 0 ? _h : defaultPageConfig.marginRight,
+    pageGap: (_j = _storage.pageGap) !== null && _j !== void 0 ? _j : defaultPageConfig.pageGap,
+    contentMarginTop: (_k = _storage.contentMarginTop) !== null && _k !== void 0 ? _k : defaultPageConfig.contentMarginTop,
+    contentMarginBottom: (_l = _storage.contentMarginBottom) !== null && _l !== void 0 ? _l : defaultPageConfig.contentMarginBottom,
+    footerRight: (_m = _storage.footerRight) !== null && _m !== void 0 ? _m : defaultPageConfig.footerRight,
+    footerLeft: (_o = _storage.footerLeft) !== null && _o !== void 0 ? _o : defaultPageConfig.footerLeft,
+    headerRight: (_p = _storage.headerRight) !== null && _p !== void 0 ? _p : defaultPageConfig.headerRight,
+    headerLeft: (_q = _storage.headerLeft) !== null && _q !== void 0 ? _q : defaultPageConfig.headerLeft,
+    customHeader: (_r = _storage.customHeader) !== null && _r !== void 0 ? _r : defaultPageConfig.customHeader,
+    customFooter: (_s = _storage.customFooter) !== null && _s !== void 0 ? _s : defaultPageConfig.customFooter
+  };
+  return {
+    config: pageConfig,
+    options: Object.assign(Object.assign({}, _currentOptions), pageConfig)
+  };
+};
+var getPageConfigFromOptions = (_currentOptions) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+  return {
+    enabled: (_a = _currentOptions.enabled) !== null && _a !== void 0 ? _a : defaultOptions.enabled,
+    pageBreakBackground: (_b = _currentOptions.pageBreakBackground) !== null && _b !== void 0 ? _b : defaultOptions.pageBreakBackground,
+    pageHeight: (_c = _currentOptions.pageHeight) !== null && _c !== void 0 ? _c : defaultOptions.pageHeight,
+    pageWidth: (_d = _currentOptions.pageWidth) !== null && _d !== void 0 ? _d : defaultPageConfig.pageWidth,
+    marginTop: (_e = _currentOptions.marginTop) !== null && _e !== void 0 ? _e : defaultPageConfig.marginTop,
+    marginBottom: (_f = _currentOptions.marginBottom) !== null && _f !== void 0 ? _f : defaultPageConfig.marginBottom,
+    marginLeft: (_g = _currentOptions.marginLeft) !== null && _g !== void 0 ? _g : defaultPageConfig.marginLeft,
+    marginRight: (_h = _currentOptions.marginRight) !== null && _h !== void 0 ? _h : defaultPageConfig.marginRight,
+    pageGap: (_j = _currentOptions.pageGap) !== null && _j !== void 0 ? _j : defaultPageConfig.pageGap,
+    contentMarginTop: (_k = _currentOptions.contentMarginTop) !== null && _k !== void 0 ? _k : defaultPageConfig.contentMarginTop,
+    contentMarginBottom: (_l = _currentOptions.contentMarginBottom) !== null && _l !== void 0 ? _l : defaultPageConfig.contentMarginBottom,
+    footerRight: (_m = _currentOptions.footerRight) !== null && _m !== void 0 ? _m : defaultPageConfig.footerRight,
+    footerLeft: (_o = _currentOptions.footerLeft) !== null && _o !== void 0 ? _o : defaultPageConfig.footerLeft,
+    headerRight: (_p = _currentOptions.headerRight) !== null && _p !== void 0 ? _p : defaultPageConfig.headerRight,
+    headerLeft: (_q = _currentOptions.headerLeft) !== null && _q !== void 0 ? _q : defaultPageConfig.headerLeft,
+    customHeader: (_r = _currentOptions.customHeader) !== null && _r !== void 0 ? _r : defaultPageConfig.customHeader,
+    customFooter: (_s = _currentOptions.customFooter) !== null && _s !== void 0 ? _s : defaultPageConfig.customFooter
+  };
+};
+var paginationKey = new PluginKey3("pagination");
+var PaginationPlus = Extension4.create({
+  name: "PaginationPlus",
+  addOptions() {
+    return defaultOptions;
+  },
+  addStorage() {
+    return Object.assign(Object.assign({}, defaultOptions), { headerHeight: /* @__PURE__ */ new Map(), footerHeight: /* @__PURE__ */ new Map(), appliedConfig: defaultPageConfig });
+  },
+  onCreate() {
+    const { options: _currentOptions } = getPageConfig(this.storage, this.options);
+    const pageConfig = getPageConfigFromOptions(this.options);
+    const targetNode = this.editor.view.dom;
+    targetNode.classList.add("rm-with-pagination");
+    targetNode.style.border = `1px solid var(--rm-page-gap-border-color)`;
+    targetNode.style.paddingLeft = `var(--rm-margin-left)`;
+    targetNode.style.paddingRight = `var(--rm-margin-right)`;
+    targetNode.style.width = `var(--rm-page-width)`;
+    updateCssVariables(targetNode, Object.assign(Object.assign({}, _currentOptions), pageConfig));
+    const style = document.createElement("style");
+    style.dataset.rmPaginationStyle = "";
+    style.textContent = `
+      .rm-pagination-gap{
+        border-top: 1px solid;
+        border-bottom: 1px solid;
+        border-color: var(--rm-page-gap-border-color);
+      }
+      .rm-with-pagination,
+      .rm-with-pagination .rm-first-page-header {
+        counter-reset: page-number page-number-plus 1;
+      }
+      .rm-with-pagination .image-plus-wrapper,
+      .rm-with-pagination .table-plus td,
+      .rm-with-pagination .table-plus th {
+        max-height: var(--rm-max-content-child-height);
+        overflow-y: auto;
+      }
+      .rm-with-pagination .image-plus-wrapper {
+        overflow-y: visible;
+      }
+      .rm-with-pagination .rm-page-break {
+        counter-increment: page-number page-number-plus;
+      }
+      
+      .rm-with-pagination .rm-page-break:last-child .rm-pagination-gap {
+        display: none;
+      }
+      .rm-with-pagination .rm-page-break:last-child .rm-page-header {
+        display: none;
+      }
+      
+      .rm-with-pagination table tr td,
+      .rm-with-pagination table tr th {
+        word-break: break-all;
+      }
+      .rm-with-pagination table > tr {
+        display: grid;
+        min-width: 100%;
+      }
+      .rm-with-pagination table {
+        border-collapse: collapse;
+        width: 100%;
+        display: contents;
+      }
+      .rm-with-pagination table tbody{
+        display: table;
+        max-height: 300px;
+        overflow-y: auto;
+      }
+      .rm-with-pagination table tbody > tr{
+        display: table-row !important;
+      }
+      .rm-with-pagination *:has(>br.ProseMirror-trailingBreak:only-child) {
+        display: table;
+        width: 100%;
+      }
+      .rm-with-pagination .rm-br-decoration {
+        display: table;
+        width: 100%;
+      }
+      .rm-with-pagination .table-row-group {
+        max-height: var(--rm-max-content-child-height);
+        overflow-y: auto;
+        width: 100%;
+      }
+      .rm-with-pagination .rm-page-footer-left,
+      .rm-with-pagination .rm-page-footer-right,
+      .rm-with-pagination .rm-page-header-left,
+      .rm-with-pagination .rm-page-header-right {
+        display: inline-block;
+      }
+      
+      .rm-with-pagination .rm-page-header-left,
+      .rm-with-pagination .rm-page-footer-left{
+        float: left;
+        margin-left: var(--rm-margin-left);
+      }
+      .rm-with-pagination .rm-page-header-right,
+      .rm-with-pagination .rm-page-footer-right{
+        float: right;
+        margin-right: var(--rm-margin-right);
+      }
+      .rm-with-pagination .rm-first-page-header .rm-page-header-right{
+        margin-right: 0px !important;
+      }
+      .rm-with-pagination .rm-first-page-header .rm-page-header-left{
+        margin-left: 0px !important;
+      }
+      .rm-with-pagination .rm-page-number::before {
+        content: counter(page-number);
+      }
+      .rm-with-pagination .rm-page-number-plus::before {
+        content: counter(page-number-plus);
+      }
+      .rm-with-pagination .rm-page-header,
+      .rm-with-pagination .rm-page-footer{
+        width: 100%;
+      }
+      .rm-with-pagination .rm-page-header{
+        padding-bottom: var(--rm-content-margin-top) !important;
+        padding-top: var(--rm-margin-top) !important;
+        display: inline-flex;
+        justify-content: space-between;
+        max-height: calc(calc(var(--rm-page-height) * 0.45) - var(--rm-margin-top) - var(--rm-content-margin-top));
+        overflow-y: hidden;
+      }
+      .rm-with-pagination .rm-page-footer{
+        padding-top: var(--rm-content-margin-bottom) !important;
+        padding-bottom: var(--rm-margin-bottom) !important;
+        display: inline-flex;
+        justify-content: space-between;
+        max-height: calc(calc(var(--rm-page-height) * 0.45) - var(--rm-content-margin-bottom) - var(--rm-margin-bottom));
+        overflow-y: hidden;
+      }
+      .rm-with-pagination[rm-pagination-disabled] {
+        padding-top: var(--rm-margin-top) !important;
+        padding-bottom: var(--rm-margin-bottom) !important;
+      }
+    `;
+    document.head.appendChild(style);
+    refreshPage(targetNode, _currentOptions.enabled);
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    const storage = this.storage;
+    return [
+      new Plugin3({
+        key: paginationKey,
+        state: {
+          init: (_, state) => {
+            const _currentOptions = getPageConfigFromOptions(this.options);
+            const pageConfig = getPageConfigFromOptions(this.options);
+            const widgetList = createDecoration(Object.assign(Object.assign({}, this.options), _currentOptions), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+            storage.pageBreakBackground = _currentOptions.pageBreakBackground;
+            storage.pageHeight = _currentOptions.pageHeight;
+            storage.pageWidth = _currentOptions.pageWidth;
+            storage.marginTop = _currentOptions.marginTop;
+            storage.marginBottom = _currentOptions.marginBottom;
+            storage.marginLeft = _currentOptions.marginLeft;
+            storage.marginRight = _currentOptions.marginRight;
+            storage.pageGap = _currentOptions.pageGap;
+            storage.contentMarginTop = _currentOptions.contentMarginTop;
+            storage.contentMarginBottom = _currentOptions.contentMarginBottom;
+            storage.footerRight = _currentOptions.footerRight;
+            storage.footerLeft = _currentOptions.footerLeft;
+            storage.headerRight = _currentOptions.headerRight;
+            storage.headerLeft = _currentOptions.headerLeft;
+            storage.customHeader = _currentOptions.customHeader;
+            storage.customFooter = _currentOptions.customFooter;
+            storage.headerHeight = /* @__PURE__ */ new Map();
+            storage.footerHeight = /* @__PURE__ */ new Map();
+            storage.appliedConfig = pageConfig;
+            return {
+              decorations: DecorationSet3.create(state.doc, widgetList)
+            };
+          },
+          apply: (tr, oldDeco, oldState, newState) => {
+            const { options: _currentOptions, config: pageConfig } = getPageConfig(storage, this.options);
+            if (storage.enabled === storage.appliedConfig.enabled && storage.enabled === false && storage.appliedConfig.enabled === false) {
+              return oldDeco;
+            }
+            const pageCount = getNewPageCount(editor.view, Object.assign(Object.assign({}, _currentOptions), pageConfig));
+            const currentPageCount = getExistingPageCount(editor.view);
+            const getNewDecoration = () => {
+              const { options: _currentOptions2, config: pageConfig2 } = getPageConfig(storage, this.options);
+              updateCssVariables(editor.view.dom, _currentOptions2);
+              let headerHeight = "headerHeight" in this.storage ? this.storage.headerHeight : /* @__PURE__ */ new Map();
+              let footerHeight = "footerHeight" in this.storage ? this.storage.footerHeight : /* @__PURE__ */ new Map();
+              const widgetList = createDecoration(Object.assign(Object.assign({}, _currentOptions2), pageConfig2), headerHeight, footerHeight);
+              storage.appliedConfig = pageConfig2;
+              storage.headerHeight = headerHeight;
+              storage.footerHeight = footerHeight;
+              return {
+                decorations: DecorationSet3.create(newState.doc, [...widgetList]),
+                footerHeight
+              };
+            };
+            if (
+              // If pagination is enabled only then check for other changes
+              (pageCount > 1 ? pageCount : 1) !== currentPageCount || storage.enabled !== storage.appliedConfig.enabled || storage.pageBreakBackground !== storage.appliedConfig.pageBreakBackground || storage.pageHeight !== storage.appliedConfig.pageHeight || storage.pageWidth !== storage.appliedConfig.pageWidth || storage.marginTop !== storage.appliedConfig.marginTop || storage.marginBottom !== storage.appliedConfig.marginBottom || storage.marginLeft !== storage.appliedConfig.marginLeft || storage.marginRight !== storage.appliedConfig.marginRight || storage.pageGap !== storage.appliedConfig.pageGap || storage.contentMarginTop !== storage.appliedConfig.contentMarginTop || storage.contentMarginBottom !== storage.appliedConfig.contentMarginBottom || storage.headerLeft !== storage.appliedConfig.headerLeft || storage.headerRight !== storage.appliedConfig.headerRight || storage.footerLeft !== storage.appliedConfig.footerLeft || storage.footerRight !== storage.appliedConfig.footerRight || !deepEqualIterative(storage.appliedConfig.customHeader, storage.customHeader) || !deepEqualIterative(storage.appliedConfig.customFooter, storage.customFooter)
+            ) {
+              return getNewDecoration();
+            }
+            return oldDeco;
+          }
+        },
+        props: {
+          decorations(state) {
+            var _a;
+            return (_a = this.getState(state)) === null || _a === void 0 ? void 0 : _a.decorations;
+          }
+        },
+        view: (editorView) => {
+          return {
+            update: (view) => {
+              const { options: _currentOptions, config: pageConfig } = getPageConfig(storage, this.options);
+              if (!pageConfig.enabled && !view.dom.hasAttribute("rm-pagination-disabled")) {
+                refreshPage(view.dom, false);
+                return;
+              }
+              const pageCount = getNewPageCount(view, Object.assign(Object.assign({}, _currentOptions), pageConfig));
+              const currentPageCount = getExistingPageCount(view);
+              const triggerUpdate = (_footerHeight) => {
+                requestAnimationFrame(() => {
+                  const tr = view.state.tr.setMeta(page_count_meta_key, { footerHeight: _footerHeight });
+                  view.dispatch(tr);
+                });
+              };
+              if (currentPageCount !== pageCount) {
+                triggerUpdate();
+                return;
+              }
+              const headerHeight = getHeaderHeight(view.dom, getCustomPages(_currentOptions.customHeader, {}), "content");
+              const footerHeight = getFooterHeight(view.dom, getCustomPages({}, _currentOptions.customFooter), "content");
+              const footerHeightForCurrentPages = /* @__PURE__ */ new Map();
+              for (let i = 0; i <= pageCount; i++) {
+                if (footerHeight.has(i)) {
+                  footerHeightForCurrentPages.set(i, footerHeight.get(i) || 0);
+                }
+              }
+              const headerHeightForCurrentPages = /* @__PURE__ */ new Map();
+              for (let i = 0; i <= pageCount; i++) {
+                if (headerHeight.has(i)) {
+                  headerHeightForCurrentPages.set(i, headerHeight.get(i) || 0);
+                }
+              }
+              const pagesSetToCheck = /* @__PURE__ */ new Set([1, ...footerHeightForCurrentPages.keys(), ...headerHeightForCurrentPages.keys()]);
+              let missingPageNumber = void 0;
+              for (let i = 1; i <= pageCount; i++) {
+                if (!pagesSetToCheck.has(i)) {
+                  missingPageNumber = i;
+                  break;
+                }
+              }
+              if (missingPageNumber) {
+                pagesSetToCheck.add(missingPageNumber);
+              }
+              pagesSetToCheck.delete(0);
+              let pageContentHeightVariable = {};
+              let maxContentHeight = void 0;
+              for (const page of pagesSetToCheck) {
+                const headerHeight2 = headerHeightForCurrentPages.has(page) ? headerHeightForCurrentPages.get(page) || 0 : headerHeightForCurrentPages.get(0) || 0;
+                const footerHeight2 = footerHeightForCurrentPages.has(page) ? footerHeightForCurrentPages.get(page) || 0 : footerHeightForCurrentPages.get(0) || 0;
+                const { _pageHeaderHeight, _pageHeight } = getHeight(_currentOptions, headerHeight2, footerHeight2);
+                const contentHeight = page === 1 ? _pageHeight + _pageHeaderHeight : _pageHeight;
+                if (page === 1) {
+                  pageContentHeightVariable[`rm-page-content-first`] = `${contentHeight}px`;
+                }
+                if (page === missingPageNumber) {
+                  pageContentHeightVariable[`rm-page-content-general`] = `${contentHeight}px`;
+                } else {
+                  pageContentHeightVariable[`rm-page-content-${page}`] = `${contentHeight}px`;
+                }
+                if (maxContentHeight === void 0 || contentHeight < maxContentHeight) {
+                  maxContentHeight = contentHeight;
+                }
+              }
+              if (maxContentHeight) {
+                view.dom.style.setProperty(`--rm-max-content-child-height`, `${maxContentHeight - 10}px`);
+              }
+              Object.entries(pageContentHeightVariable).forEach(([key2, value]) => {
+                view.dom.style.setProperty(`--${key2}`, value);
+              });
+              refreshPage(view.dom, _currentOptions.enabled);
+              return;
+            }
+          };
+        }
+      }),
+      new Plugin3({
+        key,
+        state: {
+          init(_, state) {
+            return buildDecorations(state.doc);
+          },
+          apply(tr, old) {
+            if (tr.docChanged || tr.steps.some((step) => step instanceof ReplaceStep) || tr.steps.some((step) => step instanceof ReplaceAroundStep) || tr.steps.some((step) => step instanceof AddMarkStep) || tr.steps.some((step) => step instanceof RemoveMarkStep) || tr.steps.some((step) => step instanceof RemoveNodeMarkStep) || tr.steps.some((step) => step instanceof AttrStep)) {
+              return buildDecorations(tr.doc);
+            }
+            return old;
+          }
+        },
+        props: {
+          decorations(state) {
+            var _a;
+            return (_a = key.getState(state)) !== null && _a !== void 0 ? _a : DecorationSet3.empty;
+          }
+        }
+      })
+    ];
+  },
+  addCommands() {
+    return {
+      updatePageBreakBackground: (color) => () => {
+        this.storage.pageBreakBackground = color;
+        return true;
+      },
+      updatePageSize: (size) => () => {
+        this.storage.pageHeight = size.pageHeight;
+        this.storage.pageWidth = size.pageWidth;
+        this.storage.marginTop = size.marginTop;
+        this.storage.marginBottom = size.marginBottom;
+        this.storage.marginLeft = size.marginLeft;
+        this.storage.marginRight = size.marginRight;
+        return true;
+      },
+      updatePageWidth: (width) => () => {
+        this.storage.pageWidth = width;
+        return true;
+      },
+      updatePageHeight: (height) => () => {
+        this.storage.pageHeight = height;
+        return true;
+      },
+      updatePageGap: (gap) => () => {
+        this.storage.pageGap = gap;
+        return true;
+      },
+      updateMargins: (margins) => () => {
+        this.storage.marginTop = margins.top;
+        this.storage.marginBottom = margins.bottom;
+        this.storage.marginLeft = margins.left;
+        this.storage.marginRight = margins.right;
+        return true;
+      },
+      updateContentMargins: (margins) => () => {
+        this.storage.contentMarginTop = margins.top;
+        this.storage.contentMarginBottom = margins.bottom;
+        return true;
+      },
+      updateHeaderContent: (left, right, pageNumber) => () => {
+        if (pageNumber) {
+          this.storage.customHeader = Object.assign(Object.assign({}, this.storage.customHeader), { [pageNumber]: { headerLeft: left, headerRight: right } });
+        } else {
+          this.storage.headerLeft = left;
+          this.storage.headerRight = right;
+        }
+        return true;
+      },
+      updateFooterContent: (left, right, pageNumber) => () => {
+        if (pageNumber) {
+          this.storage.customFooter = Object.assign(Object.assign({}, this.storage.customFooter), { [pageNumber]: { footerLeft: left, footerRight: right } });
+        } else {
+          this.storage.footerLeft = left;
+          this.storage.footerRight = right;
+        }
+        return true;
+      },
+      togglePagination: () => () => {
+        this.storage.enabled = !this.storage.enabled;
+        return true;
+      },
+      enablePagination: () => () => {
+        this.storage.enabled = true;
+        return true;
+      },
+      disablePagination: () => () => {
+        this.storage.enabled = false;
+        return true;
+      }
+    };
+  }
+});
+var getExistingPageCount = (view) => {
+  const editorDom = view.dom;
+  const paginationElement = editorDom.querySelector("[data-rm-pagination]");
+  if (paginationElement) {
+    return paginationElement.children.length;
+  }
+  return 0;
+};
+var calculatePageCount = (view, pageOptions, headerHeight = 0, footerHeight = 0) => {
+  var _a;
+  const editorDom = view.dom;
+  const _pageHeaderHeight = pageOptions.contentMarginTop + pageOptions.marginTop + headerHeight;
+  const _pageFooterHeight = pageOptions.contentMarginBottom + pageOptions.marginBottom + footerHeight;
+  const pageContentAreaHeight = pageOptions.pageHeight - _pageHeaderHeight - _pageFooterHeight;
+  const paginationElement = editorDom.querySelector("[data-rm-pagination]");
+  const currentPageCount = getExistingPageCount(view);
+  if (paginationElement) {
+    const lastElementOfEditor = editorDom.lastElementChild;
+    const lastPageBreak = (_a = paginationElement.lastElementChild) === null || _a === void 0 ? void 0 : _a.querySelector(".breaker");
+    if (lastElementOfEditor && lastPageBreak) {
+      const lastElementRect = lastElementOfEditor.getBoundingClientRect();
+      const lastPageBreakRect = lastPageBreak.getBoundingClientRect();
+      const lastPageGap = lastElementRect.bottom - lastPageBreakRect.bottom;
+      if (lastPageGap > 0) {
+        const addPage = Math.ceil(lastPageGap / pageContentAreaHeight);
+        return currentPageCount + addPage;
+      } else {
+        const allBreaksAfterLastElement = Array.from(paginationElement.querySelectorAll(".breaker"));
+        const allBreaksAfterLastElementRect = allBreaksAfterLastElement.filter((element) => element.getBoundingClientRect().top > lastElementRect.bottom);
+        const removePage = allBreaksAfterLastElementRect.length;
+        if (removePage > 1) {
+          return currentPageCount - removePage;
+        } else {
+          return currentPageCount;
+        }
+      }
+    }
+    return 1;
+  } else {
+    const editorHeight = editorDom.scrollHeight;
+    let pageCount = Math.ceil(editorHeight / pageContentAreaHeight);
+    pageCount = pageCount <= 0 ? 1 : pageCount;
+    return pageCount;
+  }
+};
+var getNewPageCount = (view, pageOptions) => {
+  if (pageOptions.enabled) {
+    const pageCount = calculatePageCount(view, pageOptions);
+    return pageCount <= 1 ? 1 : pageCount;
+  } else {
+    return 0;
+  }
+};
+function createDecoration(pageOptions, headerHeightMap, footerHeightMap) {
+  if (!pageOptions.enabled) {
+    return [];
+  }
+  const commonHeaderOptions = { headerLeft: pageOptions.headerLeft, headerRight: pageOptions.headerRight };
+  const commonFooterOptions = { footerLeft: pageOptions.footerLeft, footerRight: pageOptions.footerRight };
+  const pageWidget = Decoration3.widget(0, (view) => {
+    const _pageGap = pageOptions.pageGap;
+    const _pageBreakBackground = pageOptions.pageBreakBackground;
+    const el = document.createElement("div");
+    el.dataset.rmPagination = "true";
+    const pageBreakDefinition = (firstPage, pageHeader, pageFooter, headerHeight, footerHeight, pageNumber) => {
+      const { _pageHeaderHeight, _pageHeight } = getHeight(pageOptions, headerHeight, footerHeight);
+      const pageContainer = document.createElement("div");
+      pageContainer.classList.add("rm-page-break");
+      const page = document.createElement("div");
+      page.classList.add("page");
+      page.style.position = "relative";
+      page.style.float = "left";
+      page.style.clear = "both";
+      const marginTop = firstPage ? `calc(${_pageHeaderHeight}px + ${_pageHeight}px)` : _pageHeight + "px";
+      if (pageNumber) {
+        page.style.marginTop = `var(--rm-page-content-${pageNumber}, ${marginTop})`;
+      } else {
+        page.style.marginTop = firstPage ? `var(--rm-page-content-first, ${marginTop})` : `var(--rm-page-content-general, ${marginTop})`;
+      }
+      const pageBreak = document.createElement("div");
+      pageBreak.classList.add("breaker");
+      pageBreak.style.width = `calc(100% + var(--rm-margin-left) + var(--rm-margin-right))`;
+      pageBreak.style.marginLeft = `calc(-1 * var(--rm-margin-left))`;
+      pageBreak.style.marginRight = `calc(-1 * var(--rm-margin-right))`;
+      pageBreak.style.position = "relative";
+      pageBreak.style.float = "left";
+      pageBreak.style.clear = "both";
+      pageBreak.style.left = `0px`;
+      pageBreak.style.right = `0px`;
+      pageBreak.style.zIndex = "2";
+      const pageSpace = document.createElement("div");
+      pageSpace.classList.add("rm-pagination-gap");
+      pageSpace.style.height = _pageGap + "px";
+      pageSpace.style.borderLeft = "1px solid";
+      pageSpace.style.borderRight = "1px solid";
+      pageSpace.style.position = "relative";
+      pageSpace.style.setProperty("width", "calc(100% + 2px)", "important");
+      pageSpace.style.left = "-1px";
+      pageSpace.style.backgroundColor = _pageBreakBackground;
+      pageSpace.style.borderLeftColor = _pageBreakBackground;
+      pageSpace.style.borderRightColor = _pageBreakBackground;
+      pageBreak.append(pageFooter, pageSpace, pageHeader);
+      pageContainer.append(page, pageBreak);
+      return pageContainer;
+    };
+    const _headerHeight = headerHeightMap.get(0) || 0;
+    const _footerHeight = footerHeightMap.get(0) || 0;
+    const fragment = document.createDocumentFragment();
+    const pageCount = getNewPageCount(view, pageOptions);
+    for (let i = 0; i < pageCount; i++) {
+      const pageNumber = i + 1;
+      const headerPageNumber = i + 2;
+      if (headerPageNumber in pageOptions.customHeader || pageNumber in pageOptions.customFooter || pageNumber in pageOptions.customHeader) {
+        let _headerOptions = commonHeaderOptions;
+        let _footerOptions = commonFooterOptions;
+        let _pageHeaderHeight = _headerHeight;
+        let _pageFooterHeight = _footerHeight;
+        if (headerPageNumber in pageOptions.customHeader) {
+          _headerOptions = pageOptions.customHeader[headerPageNumber] || commonHeaderOptions;
+          _pageHeaderHeight = headerHeightMap.get(headerPageNumber) || 0;
+        }
+        if (pageNumber in pageOptions.customFooter) {
+          _footerOptions = pageOptions.customFooter[pageNumber] || commonFooterOptions;
+          _pageFooterHeight = footerHeightMap.get(pageNumber) || 0;
+        }
+        let _pageHeader = getHeader(_headerOptions.headerRight, _headerOptions.headerLeft, headerClickEvent(headerPageNumber, pageOptions.onHeaderClick), headerPageNumber);
+        let _pageFooter = getFooter(_footerOptions.footerRight, _footerOptions.footerLeft, footerClickEvent(pageNumber, pageOptions.onFooterClick), pageNumber);
+        let pageBreak = pageBreakDefinition(i === 0, _pageHeader, _pageFooter, _pageHeaderHeight, _pageFooterHeight, pageNumber);
+        fragment.appendChild(pageBreak);
+      } else {
+        const __pageHeader = getHeader(commonHeaderOptions.headerRight, commonHeaderOptions.headerLeft, headerClickEvent(headerPageNumber, pageOptions.onHeaderClick));
+        const __pageFooter = getFooter(commonFooterOptions.footerRight, commonFooterOptions.footerLeft, footerClickEvent(pageNumber, pageOptions.onFooterClick));
+        fragment.appendChild(pageBreakDefinition(i === 0, __pageHeader, __pageFooter, _headerHeight, _footerHeight));
+      }
+    }
+    el.append(fragment);
+    el.id = "pages";
+    el.classList.add("rm-pages-wrapper");
+    return el;
+  }, { side: -1 });
+  const firstHeaderWidget = Decoration3.widget(0, () => {
+    const pageNumber = 1;
+    let _headerOptions = commonHeaderOptions;
+    if (pageNumber in pageOptions.customHeader) {
+      _headerOptions = pageOptions.customHeader[pageNumber];
+    }
+    const el = getHeader(_headerOptions.headerRight, _headerOptions.headerLeft, headerClickEvent(pageNumber, pageOptions.onHeaderClick));
+    el.classList.add("rm-first-page-header");
+    return el;
+  }, { side: -1 });
+  return [pageWidget, firstHeaderWidget];
+}
+
+// ../../node_modules/.pnpm/tiptap-pagination-plus@3.1.0_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/tiptap-pagination-plus/dist/constants.js
+var A4_PAGE_SIZE = getPageSize(1123, 794, 95, 95, 76, 76);
+var A3_PAGE_SIZE = getPageSize(1591, 1123, 95, 95, 76, 76);
+var A5_PAGE_SIZE = getPageSize(794, 419, 76, 76, 57, 57);
+var LETTER_PAGE_SIZE = getPageSize(1060, 818, 96, 96, 96, 96);
+var LEGAL_PAGE_SIZE = getPageSize(1404, 818, 96, 96, 96, 96);
+var TABLOID_PAGE_SIZE = getPageSize(1635, 1060, 96, 96, 96, 96);
+var PAGE_SIZES = {
+  A4: A4_PAGE_SIZE,
+  A3: A3_PAGE_SIZE,
+  A5: A5_PAGE_SIZE,
+  LETTER: LETTER_PAGE_SIZE,
+  LEGAL: LEGAL_PAGE_SIZE,
+  TABLOID: TABLOID_PAGE_SIZE
+};
+
 // src/Editor.ts
-import { PaginationPlus } from "tiptap-pagination-plus";
+function sanitizePastedHTML(html) {
+  let cleaned = html.replace(/<meta[^>]*>/gi, "");
+  cleaned = cleaned.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  cleaned = cleaned.replace(/<!--[\s\S]*?-->/g, "");
+  cleaned = cleaned.replace(/<link[^>]*>/gi, "");
+  cleaned = cleaned.replace(/<base[^>]*>/gi, "");
+  cleaned = cleaned.replace(/<title[^>]*>[\s\S]*?<\/title>/gi, "");
+  {
+    for (let pass = 0; pass < 10; pass++) {
+      const before = cleaned;
+      cleaned = cleaned.replace(
+        /<span\s([^>]*style\s*=\s*["'][^"']*(?:background-color|background)[^"']*["'][^>]*)>([^<]*(?:<(?!\/?span)[^>]*>[^<]*)*)<\/span>/gi,
+        (_full, attrs, content) => {
+          if (!/background(?:-color)?\s*:/.test(attrs)) return _full;
+          const colorMatch = attrs.match(/(?<!background-)color\s*:\s*([^;"]+)/i);
+          const colorVal = colorMatch ? colorMatch[1].trim() : null;
+          const markAttrs = colorVal ? attrs.replace(/(?<!background-)color\s*:\s*[^;"]+;?\s*/gi, "").trim() : attrs;
+          if (colorVal) {
+            return `<mark ${markAttrs}><span style="color: ${colorVal};">${content}</span></mark>`;
+          }
+          return `<mark ${markAttrs}>${content}</mark>`;
+        }
+      );
+      if (cleaned === before) break;
+    }
+  }
+  cleaned = cleaned.replace(
+    /<b\s[^>]*style\s*=\s*["'][^"']*font-weight:\s*normal[^"']*["'][^>]*>/gi,
+    ""
+  );
+  cleaned = cleaned.replace(/<\/b>/gi, "");
+  cleaned = cleaned.replace(/\sid\s*=\s*["']docs-internal[^"']*["']/gi, "");
+  return cleaned;
+}
 function migrateContent(content) {
   if (!content) return content;
   if (typeof content === "string") {
@@ -290,20 +1327,338 @@ function createTiptapEditor(options, plugins, collaborationSetup) {
   const pluginExtensions = collectExtensions(plugins);
   const blockAttrs = options.getPageMap ? BlockAttributesExtension.configure({ pageMap: options.getPageMap }) : BlockAttributesExtension;
   const paginationExt = options.paginationOptions ? PaginationPlus.configure(options.paginationOptions) : PaginationPlus;
+  const ManualColumnResize = Extension5.create({
+    name: "manualColumnResize",
+    addProseMirrorPlugins() {
+      const key2 = new PluginKey4("manualColumnResize");
+      return [new Plugin4({
+        key: key2,
+        view(view) {
+          function pauseObserver() {
+            try {
+              view.domObserver?.stop?.();
+            } catch (_) {
+            }
+          }
+          function resumeObserver() {
+            try {
+              view.domObserver?.start?.();
+            } catch (_) {
+            }
+          }
+          function getMaxContainerWidth(tableEl) {
+            let curr = tableEl.parentElement;
+            while (curr) {
+              const style = window.getComputedStyle(curr);
+              const paddingLeft = parseFloat(style.paddingLeft) || 0;
+              const paddingRight = parseFloat(style.paddingRight) || 0;
+              const availWidth = curr.clientWidth - paddingLeft - paddingRight;
+              if (availWidth > 100 && (curr.classList.contains("docs-editor__paper") || curr.classList.contains("docs-editor-page") || curr.classList.contains("ProseMirror") || curr.classList.contains("rm-with-pagination"))) {
+                return availWidth;
+              }
+              curr = curr.parentElement;
+            }
+            return tableEl.parentElement?.clientWidth || 614;
+          }
+          const onMouseDown = function(event) {
+            if (event.button !== 0) return;
+            const td = event.target.closest("td, th");
+            if (!td) return;
+            const r = td.getBoundingClientRect();
+            const parent = td.parentElement;
+            if (!parent) return;
+            const colIdx = Array.from(parent.children).indexOf(td);
+            if (colIdx === -1) return;
+            const table = td.closest("table");
+            if (!table) return;
+            const distRight = Math.abs(event.clientX - r.right);
+            const distLeft = Math.abs(event.clientX - r.left);
+            let targetColIdx = -1;
+            if (distRight <= 16) {
+              targetColIdx = colIdx;
+            } else if (distLeft <= 16 && colIdx > 0) {
+              targetColIdx = colIdx - 1;
+            } else {
+              return;
+            }
+            const colsList = table.querySelectorAll("colgroup col");
+            const totalCols = colsList.length || table.querySelector("tr")?.children.length || 0;
+            const allColWidths = [];
+            for (let c = 0; c < totalCols; c++) {
+              const colEl = colsList[c];
+              const w = colEl ? parseFloat(colEl.style.width) : 0;
+              allColWidths[c] = w || initialWidth(table, c);
+            }
+            const isLastCol = targetColIdx === totalCols - 1;
+            const startX = event.clientX;
+            const startW = allColWidths[targetColIdx] || initialWidth(table, targetColIdx);
+            const maxContainerW = getMaxContainerWidth(table);
+            let otherColsW = 0;
+            allColWidths.forEach((w, idx) => {
+              if (idx !== targetColIdx) {
+                otherColsW += w;
+              }
+            });
+            const maxNw = Math.max(20, maxContainerW - otherColsW);
+            function updateDOMWidths(targetIdx, targetW) {
+              let totalWidth = 0;
+              allColWidths.forEach((_, idx) => {
+                const w = idx === targetIdx ? targetW : allColWidths[idx];
+                const col = table.querySelector(`colgroup col:nth-child(${idx + 1})`);
+                if (col) col.style.setProperty("width", w + "px", "important");
+                table.querySelectorAll("tr").forEach(function(row) {
+                  const cell = row.children[idx];
+                  if (cell) {
+                    cell.style.setProperty("width", w + "px", "important");
+                    cell.setAttribute("width", String(w));
+                  }
+                });
+                totalWidth += w;
+              });
+              if (totalWidth > 0) {
+                table.style.setProperty("width", Math.min(totalWidth, maxContainerW) + "px", "important");
+              }
+            }
+            event.stopPropagation();
+            let lastNw = startW;
+            let moveCount = 0;
+            const onMove = function(e) {
+              moveCount++;
+              if (!e.buttons) {
+                onUp(e);
+                return;
+              }
+              const diff = e.clientX - startX;
+              const nw = Math.min(maxNw, Math.max(20, startW + diff));
+              lastNw = nw;
+              let borderPos = table.getBoundingClientRect().left;
+              for (let i = 0; i <= targetColIdx; i++) {
+                borderPos += i === targetColIdx ? nw : allColWidths[i];
+              }
+              showLine(table, borderPos);
+              pauseObserver();
+              updateDOMWidths(targetColIdx, nw);
+              resumeObserver();
+            };
+            const onUp = function(upEvent) {
+              document.removeEventListener("mousemove", onMove);
+              document.removeEventListener("mouseup", onUp, true);
+              upEvent.stopPropagation();
+              hideLine();
+              if (lastNw === startW) return;
+              allColWidths[targetColIdx] = lastNw;
+              console.log("[Resize] onUp:", { lastNw, startW, isLastCol, targetColIdx, allColWidths });
+              try {
+                const { state } = view;
+                const { doc } = state;
+                let tablePos = -1;
+                doc.descendants((node, pos) => {
+                  if (tablePos >= 0) return false;
+                  if (node.type.name === "table") {
+                    try {
+                      const dom = view.nodeDOM(pos);
+                      if (dom === table || dom instanceof HTMLElement && dom.contains(table) || table.contains(dom)) {
+                        tablePos = pos;
+                        return false;
+                      }
+                    } catch (_) {
+                    }
+                  }
+                  return true;
+                });
+                if (tablePos >= 0) {
+                  const tableNode = doc.nodeAt(tablePos);
+                  if (tableNode) {
+                    const tr = state.tr;
+                    let cellsUpdated = 0;
+                    tableNode.forEach((row, rowOffset) => {
+                      let cellColIdx = 0;
+                      row.forEach((cell, cellOffset) => {
+                        const colspan = cell.attrs.colspan || 1;
+                        const cellPos = tablePos + 1 + rowOffset + 1 + cellOffset;
+                        const cw = new Array(colspan);
+                        for (let k = 0; k < colspan; k++) {
+                          cw[k] = allColWidths[cellColIdx + k] || 100;
+                        }
+                        tr.setNodeMarkup(cellPos, null, { ...cell.attrs, colwidth: cw });
+                        cellsUpdated++;
+                        cellColIdx += colspan;
+                      });
+                    });
+                    view.dispatch(tr);
+                    pauseObserver();
+                    updateDOMWidths(targetColIdx, lastNw);
+                    resumeObserver();
+                  }
+                } else {
+                  console.warn("[Resize] could not find table position in doc");
+                }
+              } catch (err) {
+                console.warn("[Resize] transaction failed, falling back to DOM:", err);
+                pauseObserver();
+                updateDOMWidths(targetColIdx, lastNw);
+                resumeObserver();
+              }
+            };
+            document.addEventListener("mousemove", onMove);
+            document.addEventListener("mouseup", onUp, true);
+          };
+          function initialWidth(table, colIdx) {
+            const firstRow = table.querySelector("tr");
+            if (!firstRow) return 100;
+            const cell = firstRow.children[colIdx];
+            if (!cell) return 100;
+            return Math.round(cell.getBoundingClientRect().width) || cell.offsetWidth || 100;
+          }
+          let lineEl = null;
+          let isDragging = false;
+          function getOrCreateLine() {
+            if (!lineEl) {
+              lineEl = document.createElement("div");
+              lineEl.className = "docflow-active-border-line";
+              Object.assign(lineEl.style, {
+                position: "fixed",
+                width: "3px",
+                background: "#06b6d4",
+                boxShadow: "0 0 8px rgba(6, 182, 212, 0.9)",
+                pointerEvents: "none",
+                zIndex: "999999",
+                display: "none",
+                borderRadius: "1.5px"
+              });
+              const dotTop = document.createElement("div");
+              Object.assign(dotTop.style, {
+                position: "absolute",
+                top: "-4px",
+                left: "-3.5px",
+                width: "10px",
+                height: "10px",
+                borderRadius: "50%",
+                background: "#ffffff",
+                border: "2px solid #06b6d4"
+              });
+              const dotBottom = document.createElement("div");
+              Object.assign(dotBottom.style, {
+                position: "absolute",
+                bottom: "-4px",
+                left: "-3.5px",
+                width: "10px",
+                height: "10px",
+                borderRadius: "50%",
+                background: "#ffffff",
+                border: "2px solid #06b6d4"
+              });
+              lineEl.appendChild(dotTop);
+              lineEl.appendChild(dotBottom);
+              document.body.appendChild(lineEl);
+            }
+            return lineEl;
+          }
+          function showLine(table, borderX) {
+            const line = getOrCreateLine();
+            const tableRect = table.getBoundingClientRect();
+            line.style.left = `${borderX - 1.5}px`;
+            line.style.top = `${tableRect.top}px`;
+            line.style.height = `${tableRect.height}px`;
+            line.style.display = "block";
+            document.body.style.cursor = "col-resize";
+            view.dom.style.cursor = "col-resize";
+          }
+          function hideLine() {
+            if (lineEl) {
+              lineEl.style.display = "none";
+            }
+            document.body.style.cursor = "";
+            view.dom.style.cursor = "";
+          }
+          const onMouseMoveHover = function(event) {
+            if (isDragging) return;
+            const target = event.target;
+            const td = target.closest("td, th");
+            if (!td) {
+              hideLine();
+              return;
+            }
+            const r = td.getBoundingClientRect();
+            const distRight = Math.abs(event.clientX - r.right);
+            const distLeft = Math.abs(event.clientX - r.left);
+            const parent = td.parentElement;
+            if (!parent) {
+              hideLine();
+              return;
+            }
+            const colIdx = Array.from(parent.children).indexOf(td);
+            let borderX = -1;
+            if (distRight <= 16) {
+              borderX = r.right;
+            } else if (distLeft <= 16 && colIdx > 0) {
+              borderX = r.left;
+            }
+            if (borderX >= 0) {
+              const table = td.closest("table");
+              if (table) {
+                showLine(table, borderX);
+              }
+            } else {
+              hideLine();
+            }
+          };
+          document.addEventListener("mousemove", onMouseMoveHover, true);
+          view.dom.addEventListener("mousedown", function handleMouseDown(event) {
+            onMouseDown(event);
+            const td = event.target.closest("td, th");
+            if (!td) return;
+            const r = td.getBoundingClientRect();
+            const distRight = Math.abs(event.clientX - r.right);
+            const distLeft = Math.abs(event.clientX - r.left);
+            const parent = td.parentElement;
+            if (!parent) return;
+            const colIdx = Array.from(parent.children).indexOf(td);
+            if (distRight <= 16 || distLeft <= 16 && colIdx > 0) {
+              isDragging = true;
+              hideLine();
+              const onDragEnd = function() {
+                isDragging = false;
+                hideLine();
+                document.removeEventListener("mouseup", onDragEnd, true);
+              };
+              document.addEventListener("mouseup", onDragEnd, true);
+            }
+          }, true);
+          return {
+            destroy: function() {
+              document.removeEventListener("mousemove", onMouseMoveHover, true);
+              if (lineEl && lineEl.parentElement) {
+                lineEl.parentElement.removeChild(lineEl);
+              }
+              lineEl = null;
+              hideLine();
+            }
+          };
+        }
+      })];
+    }
+  });
   let extensions = [
+    ManualColumnResize,
     baseStarterKit,
     TextStyle,
     blockAttrs,
     paginationExt,
+    // Always present — carries host-injected ports (onImageUpload, citation, …)
+    // in storage so plugin commands can reach them through the editor instance.
+    EditorContextExtension.configure({
+      onImageUpload: options.onImageUpload,
+      citation: options.citation,
+      aiStream: options.aiStream,
+      aiDraft: options.aiDraft
+    }),
+    // Always present — find & replace decorations + state (core editing infra).
+    SearchAndReplaceExtension,
     ...pluginExtensions
   ];
   const content = options.collaboration ? void 0 : options.content;
   if (options.collaboration && collaborationSetup) {
-    const fragment = collaborationSetup.ydoc.getXmlFragment("default");
-    if (fragment.length === 0 && options.content && typeof options.content === "object") {
-      const schema = getSchema([baseStarterKit, TextStyle, blockAttrs, paginationExt, ...pluginExtensions]);
-      prosemirrorJSONToYXmlFragment(schema, options.content, fragment);
-    }
     extensions = [...extensions, ...collaborationExtensions(collaborationSetup)];
   }
   return new TiptapEditor({
@@ -313,12 +1668,18 @@ function createTiptapEditor(options, plugins, collaborationSetup) {
     editable: options.editable ?? true,
     onUpdate: ({ editor }) => {
       options.onUpdate?.(editor.getJSON());
+    },
+    editorProps: {
+      // Sanitize pasted HTML (strips <meta>, <style>, comments, etc.)
+      // before ProseMirror parsing. Prevents crashes from non-content
+      // tags commonly produced by Google Docs clipboard data.
+      transformPastedHTML: sanitizePastedHTML
     }
   });
 }
 
 // src/FontSize.ts
-import { Extension as Extension2 } from "@tiptap/core";
+import { Extension as Extension6 } from "@tiptap/core";
 function mergeFontSize(textStyleType, existing, fontSize) {
   if (fontSize === null) {
     const { fontSize: _removed, ...rest } = existing?.attrs ?? {};
@@ -329,7 +1690,7 @@ function mergeFontSize(textStyleType, existing, fontSize) {
 function hasAttrs(mark) {
   return Object.values(mark.attrs).some((v) => v != null);
 }
-var FontSizeExtension = Extension2.create({
+var FontSizeExtension = Extension6.create({
   name: "fontSize",
   addGlobalAttributes() {
     return [
@@ -427,18 +1788,135 @@ var FontSizeExtension = Extension2.create({
   }
 });
 
-// src/index.ts
-import { PaginationPlus as PaginationPlus2, PAGE_SIZES } from "tiptap-pagination-plus";
+// src/SubdocumentProvider.ts
+import { Awareness as AwarenessClass } from "y-protocols/awareness";
+import { WebsocketProvider as WebsocketProvider2 } from "y-websocket";
+import * as Y2 from "yjs";
+var SubdocumentProvider = class {
+  parentDoc;
+  subdocs;
+  awareness;
+  options;
+  states = /* @__PURE__ */ new Map();
+  activeQueue = [];
+  parentProvider = null;
+  constructor(options) {
+    this.options = {
+      maxActive: options.maxActive ?? 5,
+      onStateChange: options.onStateChange ?? (() => {
+      }),
+      ...options
+    };
+    this.parentDoc = new Y2.Doc();
+    this.subdocs = this.parentDoc.getMap("subdocs");
+    this.awareness = new AwarenessClass(this.parentDoc);
+    this.awareness.setLocalStateField("user", this.options.user);
+    this.parentProvider = new WebsocketProvider2(
+      this.options.websocketUrl,
+      `${this.options.roomPrefix}/_parent`,
+      this.parentDoc
+    );
+  }
+  /** Create a new subdocument. Does NOT activate it. */
+  createSubdoc(id, initialState) {
+    if (this.states.has(id)) return this.states.get(id).doc;
+    const doc = new Y2.Doc();
+    if (initialState) Y2.applyUpdate(doc, initialState);
+    doc.getXmlFragment("default");
+    this.subdocs.set(id, doc);
+    this.states.set(id, {
+      id,
+      doc,
+      provider: null,
+      active: false
+    });
+    this.options.onStateChange(this.getAllStates());
+    return doc;
+  }
+  /** Activate a subdocument — connects it to the network for live sync. */
+  activate(id) {
+    const state = this.states.get(id);
+    if (!state || state.active) return;
+    if (this.activeQueue.length >= this.options.maxActive) {
+      const oldest = this.activeQueue.shift();
+      if (oldest) this.deactivate(oldest);
+    }
+    const doc = state.doc;
+    const roomName = `${this.options.roomPrefix}/${id}`;
+    const provider = new WebsocketProvider2(
+      this.options.websocketUrl,
+      roomName,
+      doc
+    );
+    provider.awareness.setLocalStateField("user", this.options.user);
+    state.provider = provider;
+    state.active = true;
+    this.activeQueue.push(id);
+    this.options.onStateChange(this.getAllStates());
+  }
+  /** Deactivate a subdocument — disconnects it from the network. */
+  deactivate(id) {
+    const state = this.states.get(id);
+    if (!state || !state.active) return;
+    state.provider?.destroy();
+    state.provider = null;
+    state.active = false;
+    const idx = this.activeQueue.indexOf(id);
+    if (idx >= 0) this.activeQueue.splice(idx, 1);
+    this.options.onStateChange(this.getAllStates());
+  }
+  /** Get the Y.XmlFragment for a subdocument. */
+  getFragment(id) {
+    const doc = this.states.get(id)?.doc ?? this.subdocs.get(id);
+    if (!doc) return null;
+    return doc.getXmlFragment("default");
+  }
+  /** Check if a subdocument is currently active (syncing). */
+  isActive(id) {
+    return this.states.get(id)?.active ?? false;
+  }
+  /** Get all subdocument states. */
+  getAllStates() {
+    return Array.from(this.states.values());
+  }
+  /** Get IDs of all active subdocuments. */
+  getActiveIds() {
+    return [...this.activeQueue];
+  }
+  /** Destroy all subdocuments and providers. */
+  destroy() {
+    for (const [id] of this.states) {
+      this.deactivate(id);
+    }
+    this.parentProvider?.destroy();
+    this.parentDoc.destroy();
+    this.states.clear();
+    this.activeQueue.length = 0;
+  }
+};
 export {
   BlockAttributesExtension,
+  EditorContextExtension,
   FontSizeExtension,
   PAGE_SIZES,
-  PaginationPlus2 as PaginationPlus,
+  PaginationPlus,
+  SearchAndReplaceExtension,
+  SubdocumentProvider,
+  clearSearch,
   collaborationExtensions,
   collectExtensions,
   createActionMap,
   createCollaboration,
   createEditor,
   definePlugin,
-  resolveAction
+  findMatches,
+  getSearchState,
+  replaceAll,
+  replaceCurrent,
+  resolveAction,
+  sanitizePastedHTML,
+  searchAndReplaceKey,
+  searchNext,
+  searchPrev,
+  setSearchQuery
 };