@superdoc-dev/cli 0.3.0-next.54 → 0.3.0-next.55

package/dist/index.js

@@ -152177,7 +152177,7 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-ncOuYa9X.es.js
+// ../../packages/superdoc/dist/chunks/src-D389XrYP.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -156292,6 +156292,249 @@ function cellWrapping2($pos) {
   }
   return null;
 }
+function findAncestorDepth($pos, predicate) {
+  for (let depth = $pos.depth;depth > 0; depth -= 1)
+    if (predicate($pos.node(depth)))
+      return depth;
+  return -1;
+}
+function findRunDepthWithinParagraph($pos, paragraphDepth) {
+  for (let depth = $pos.depth;depth > paragraphDepth; depth -= 1)
+    if ($pos.node(depth).type.name === "run")
+      return depth;
+  return -1;
+}
+function findParagraphDepth($pos) {
+  return findAncestorDepth($pos, (node3) => node3.type.name === "paragraph");
+}
+function allInlineMarkersBetween(paragraph2, fromIndex, toIndex) {
+  for (let i4 = fromIndex;i4 < toIndex; i4 += 1) {
+    const child = paragraph2.child(i4);
+    if (child.type.name === "run")
+      return false;
+    if (!child.isInline)
+      return false;
+    if (child.textContent !== "")
+      return false;
+  }
+  return true;
+}
+function isAtEffectiveParagraphEnd($head) {
+  const paragraphDepth = findParagraphDepth($head);
+  if (paragraphDepth < 0)
+    return false;
+  const paragraph2 = $head.node(paragraphDepth);
+  if (paragraph2.content.size === 0)
+    return true;
+  if ($head.pos === $head.end(paragraphDepth))
+    return true;
+  const runDepth = findRunDepthWithinParagraph($head, paragraphDepth);
+  if (runDepth < 0)
+    return false;
+  if ($head.pos !== $head.end(runDepth))
+    return false;
+  return allInlineMarkersBetween(paragraph2, $head.index(paragraphDepth) + 1, paragraph2.childCount);
+}
+function isAtEffectiveParagraphStart($head) {
+  const paragraphDepth = findParagraphDepth($head);
+  if (paragraphDepth < 0)
+    return false;
+  const paragraph2 = $head.node(paragraphDepth);
+  if (paragraph2.content.size === 0)
+    return true;
+  if ($head.pos === $head.start(paragraphDepth))
+    return true;
+  const runDepth = findRunDepthWithinParagraph($head, paragraphDepth);
+  if (runDepth < 0)
+    return false;
+  if ($head.pos !== $head.start(runDepth))
+    return false;
+  return allInlineMarkersBetween(paragraph2, 0, $head.index(paragraphDepth));
+}
+function isInLastParagraphOfCell($head, cellDepth) {
+  return $head.index(cellDepth) === $head.node(cellDepth).childCount - 1;
+}
+function isInFirstParagraphOfCell($head, cellDepth) {
+  return $head.index(cellDepth) === 0;
+}
+function getTableContext($head) {
+  const cellDepth = findAncestorDepth($head, (node3) => TABLE_CELL_ROLES.has(node3.type.spec.tableRole));
+  if (cellDepth < 0)
+    return null;
+  const tableDepth = findAncestorDepth($head, (node3) => node3.type.spec.tableRole === "table");
+  if (tableDepth < 0)
+    return null;
+  const table2 = $head.node(tableDepth);
+  return {
+    cellDepth,
+    cellStart: $head.before(cellDepth),
+    tableStart: $head.start(tableDepth),
+    tablePos: $head.before(tableDepth),
+    table: table2
+  };
+}
+function getCellRect(context) {
+  const map$12 = TableMap.get(context.table);
+  return {
+    map: map$12,
+    rect: map$12.findCell(context.cellStart - context.tableStart)
+  };
+}
+function isLastCellInTable(context) {
+  if (!context)
+    return false;
+  const { map: map$12, rect } = getCellRect(context);
+  return rect.right === map$12.width && rect.bottom === map$12.height;
+}
+function isFirstCellInTable(context) {
+  if (!context)
+    return false;
+  const { rect } = getCellRect(context);
+  return rect.left === 0 && rect.top === 0;
+}
+function findFirstTextPosInNode(node3, nodePos) {
+  if (node3.isText)
+    return nodePos;
+  for (let index2 = 0, offset$1 = 0;index2 < node3.childCount; index2 += 1) {
+    const child = node3.child(index2);
+    const found2 = findFirstTextPosInNode(child, nodePos + 1 + offset$1);
+    if (found2 != null)
+      return found2;
+    offset$1 += child.nodeSize;
+  }
+  return null;
+}
+function findLastTextPosInNode(node3, nodePos) {
+  if (node3.isText)
+    return nodePos + (node3.text?.length ?? 0);
+  for (let index2 = node3.childCount - 1, offset$1 = node3.content.size;index2 >= 0; index2 -= 1) {
+    const child = node3.child(index2);
+    offset$1 -= child.nodeSize;
+    const found2 = findLastTextPosInNode(child, nodePos + 1 + offset$1);
+    if (found2 != null)
+      return found2;
+  }
+  return null;
+}
+function findFirstTextPosAfterBoundary(state, boundaryPos) {
+  const nextNode = state.doc.resolve(boundaryPos).nodeAfter;
+  if (!nextNode)
+    return null;
+  return findFirstTextPosInNode(nextNode, boundaryPos);
+}
+function findLastTextPosBeforeBoundary(state, boundaryPos) {
+  const prevNode = state.doc.resolve(boundaryPos).nodeBefore;
+  if (!prevNode)
+    return null;
+  return findLastTextPosInNode(prevNode, boundaryPos - prevNode.nodeSize);
+}
+function findSelectionNearBoundary(state, boundaryPos, dir) {
+  return Selection.findFrom(state.doc.resolve(boundaryPos), dir, true) ?? Selection.near(state.doc.resolve(boundaryPos), dir);
+}
+function getDirectionHelpers(dir) {
+  if (dir > 0)
+    return {
+      isAtParagraphBoundary: isAtEffectiveParagraphEnd,
+      isEdgeParagraphInCell: isInLastParagraphOfCell,
+      isEdgeCellInTable: isLastCellInTable,
+      findTextPosAcrossBoundary: findFirstTextPosAfterBoundary,
+      getTableBoundaryPos: (context) => context.tablePos + context.table.nodeSize
+    };
+  return {
+    isAtParagraphBoundary: isAtEffectiveParagraphStart,
+    isEdgeParagraphInCell: isInFirstParagraphOfCell,
+    isEdgeCellInTable: isFirstCellInTable,
+    findTextPosAcrossBoundary: findLastTextPosBeforeBoundary,
+    getTableBoundaryPos: (context) => context.tablePos
+  };
+}
+function isInProtectedTrailingTableParagraph(state) {
+  const selection = state.selection;
+  if (!selection.empty)
+    return false;
+  const $head = selection.$head;
+  const paragraphDepth = findParagraphDepth($head);
+  if (paragraphDepth !== 1)
+    return false;
+  const paragraph2 = $head.node(paragraphDepth);
+  if (paragraph2.type.name !== "paragraph" || paragraph2.textContent !== "")
+    return false;
+  const paragraphIndex = $head.index(0);
+  if (paragraphIndex !== state.doc.childCount - 1 || paragraphIndex === 0)
+    return false;
+  return state.doc.child(paragraphIndex - 1)?.type.name === "table";
+}
+function getTableBoundaryExitSelection(state, dir) {
+  const selection = state.selection;
+  if (!selection.empty)
+    return null;
+  const context = getTableContext(selection.$head);
+  if (!context)
+    return null;
+  const helpers = getDirectionHelpers(dir);
+  if (!helpers.isEdgeParagraphInCell(selection.$head, context.cellDepth))
+    return null;
+  if (!helpers.isAtParagraphBoundary(selection.$head))
+    return null;
+  if (!helpers.isEdgeCellInTable(context))
+    return null;
+  const boundaryPos = helpers.getTableBoundaryPos(context);
+  const targetPos = helpers.findTextPosAcrossBoundary(state, boundaryPos);
+  if (targetPos != null)
+    return TextSelection2.create(state.doc, targetPos);
+  return findSelectionNearBoundary(state, boundaryPos, dir);
+}
+function getAdjacentTableEntrySelection(state, dir) {
+  const selection = state.selection;
+  if (!selection.empty)
+    return null;
+  const $head = selection.$head;
+  const paragraphDepth = findParagraphDepth($head);
+  if (paragraphDepth < 0)
+    return null;
+  if (!getDirectionHelpers(dir).isAtParagraphBoundary($head))
+    return null;
+  const boundaryPos = dir > 0 ? $head.end(paragraphDepth) + 1 : $head.start(paragraphDepth) - 1;
+  const $boundary = state.doc.resolve(boundaryPos);
+  const adjacentNode = dir > 0 ? $boundary.nodeAfter : $boundary.nodeBefore;
+  if (!adjacentNode || adjacentNode.type.spec.tableRole !== "table")
+    return null;
+  if (dir > 0) {
+    const targetPos$1 = findFirstTextPosInNode(adjacentNode, boundaryPos);
+    if (targetPos$1 != null)
+      return TextSelection2.create(state.doc, targetPos$1);
+    return findSelectionNearBoundary(state, boundaryPos, 1);
+  }
+  const tablePos = boundaryPos - adjacentNode.nodeSize;
+  const targetPos = findLastTextPosInNode(adjacentNode, tablePos);
+  if (targetPos != null)
+    return TextSelection2.create(state.doc, targetPos);
+  return findSelectionNearBoundary(state, tablePos + adjacentNode.nodeSize, -1);
+}
+function createTableBoundaryNavigationPlugin() {
+  return new Plugin({
+    key: TableBoundaryNavigationPluginKey,
+    props: { handleKeyDown(view, event) {
+      if (event.defaultPrevented)
+        return false;
+      if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey)
+        return false;
+      if ((event.key === "Backspace" || event.key === "Delete") && isInProtectedTrailingTableParagraph(view.state)) {
+        event.preventDefault();
+        return true;
+      }
+      const dir = event.key === "ArrowRight" ? 1 : event.key === "ArrowLeft" ? -1 : 0;
+      if (!dir)
+        return false;
+      const nextSelection = getTableBoundaryExitSelection(view.state, dir) ?? getAdjacentTableEntrySelection(view.state, dir);
+      if (!nextSelection)
+        return false;
+      view.dispatch(view.state.tr.setSelection(nextSelection).scrollIntoView());
+      event.preventDefault();
+      return true;
+    } }
+  });
+}
 function toggleHeaderRow(state, dispatch) {
   const target = resolveTarget2(state);
   if (!target)
@@ -156614,20 +156857,61 @@ function insertRowAtIndex({ tr, tablePos, tableNode, sourceRowIndex, insertIndex
   }
   return true;
 }
-function tableSeparatorNeeds(doc$12, pos) {
-  const $pos = doc$12.resolve(pos);
-  if ($pos.depth !== 0)
+function tableSeparatorNeeds(doc$12, pos, replaceRange2 = {}) {
+  const boundaryBefore = replaceRange2.from ?? pos;
+  const boundaryAfter = replaceRange2.to ?? pos;
+  const $before = doc$12.resolve(boundaryBefore);
+  const $after = doc$12.resolve(boundaryAfter);
+  if ($before.depth !== 0 || $after.depth !== 0)
     return {
       before: false,
       after: false
     };
-  const indexAfter = $pos.index(0);
-  const nodeAfter = indexAfter < doc$12.childCount ? doc$12.child(indexAfter) : null;
+  const beforeIndex = $before.index(0);
+  const afterIndex = $after.index(0);
+  const nodeBefore = beforeIndex > 0 ? doc$12.child(beforeIndex - 1) : null;
+  const nodeAfter = afterIndex < doc$12.childCount ? doc$12.child(afterIndex) : null;
   return {
-    before: (indexAfter > 0 ? doc$12.child(indexAfter - 1) : null)?.type.name === "table",
+    before: nodeBefore?.type.name === "table",
     after: !nodeAfter || nodeAfter.type.name === "table"
   };
 }
+function createTableSeparatorParagraph(schema) {
+  const attrs = {
+    sdBlockId: v4_default(),
+    paraId: generateDocxHexId()
+  };
+  return schema.nodes.paragraph.createAndFill(attrs);
+}
+function insertTopLevelTableWithSeparators(tr, doc$12, pos, tableNode, replaceRange2 = {}) {
+  const replaceFrom = replaceRange2.from ?? pos;
+  const replaceTo = replaceRange2.to ?? pos;
+  const sep = tableSeparatorNeeds(doc$12, pos, replaceRange2);
+  if (!sep.before && !sep.after) {
+    tr.replaceWith(replaceFrom, replaceTo, tableNode);
+    return { inserted: true };
+  }
+  const nodes = [];
+  if (sep.before) {
+    const before = createTableSeparatorParagraph(doc$12.type.schema);
+    if (!before)
+      return { inserted: false };
+    nodes.push(before);
+  }
+  nodes.push(tableNode);
+  if (sep.after) {
+    const after = createTableSeparatorParagraph(doc$12.type.schema);
+    if (!after)
+      return { inserted: false };
+    nodes.push(after);
+  }
+  tr.replaceWith(replaceFrom, replaceTo, Fragment.from(nodes));
+  return { inserted: true };
+}
+function getFirstTableCellTextPos(tablePos, tableNode) {
+  const map$12 = TableMap.get(tableNode);
+  return tablePos + 1 + map$12.map[0] + 2;
+}
 function getCellType({ node: node3, state }) {
   return tableNodeTypes(state.schema)[node3.type.spec.tableRole];
 }
@@ -168708,7 +168992,7 @@ function getAdjacentLineClientTarget(editor, coords, direction) {
   const currentLine = findLineElementAtPoint(doc$12, caretX, coords.clientY + coords.height / 2);
   if (!currentLine)
     return null;
-  const adjacentLine = findAdjacentLineElement(currentLine, direction);
+  const adjacentLine = findAdjacentLineElement(currentLine, direction, caretX);
   if (!adjacentLine)
     return null;
   const pageEl = adjacentLine.closest?.(`.${DOM_CLASS_NAMES.PAGE}`);
@@ -168753,33 +169037,17 @@ function findLineElementAtPoint(doc$12, x, y$1) {
       return el;
   return null;
 }
-function findAdjacentLineElement(currentLine, direction) {
-  const lineClass = DOM_CLASS_NAMES.LINE;
-  const fragmentClass = DOM_CLASS_NAMES.FRAGMENT;
+function findAdjacentLineElement(currentLine, direction, caretX) {
   const pageClass = DOM_CLASS_NAMES.PAGE;
-  const headerClass = "superdoc-page-header";
-  const footerClass = "superdoc-page-footer";
-  const fragment2 = currentLine.closest?.(`.${fragmentClass}`);
   const page = currentLine.closest?.(`.${pageClass}`);
-  if (!fragment2 || !page)
+  if (!page)
     return null;
-  const lineEls = Array.from(fragment2.querySelectorAll(`.${lineClass}`));
-  const index2 = lineEls.indexOf(currentLine);
-  if (index2 !== -1) {
-    const nextInFragment = lineEls[index2 + direction];
-    if (nextInFragment)
-      return nextInFragment;
-  }
-  const fragments = Array.from(page.querySelectorAll(`.${fragmentClass}`)).filter((frag) => {
-    return !frag.closest?.(`.${headerClass}, .${footerClass}`);
-  });
-  const fragmentIndex = fragments.indexOf(fragment2);
-  if (fragmentIndex !== -1) {
-    const nextFragment = fragments[fragmentIndex + direction];
-    const fallbackLine = getEdgeLineFromFragment(nextFragment, direction);
-    if (fallbackLine)
-      return fallbackLine;
-  }
+  const currentLineMetrics = getLineMetrics(currentLine);
+  if (!currentLineMetrics)
+    return null;
+  const adjacentOnCurrentPage = findClosestLineInDirection(getPageLineElements(page), currentLine, currentLineMetrics, direction, caretX);
+  if (adjacentOnCurrentPage)
+    return adjacentOnCurrentPage;
   const pages = Array.from(page.parentElement?.querySelectorAll?.(`.${pageClass}`) ?? []);
   const pageIndex = pages.indexOf(page);
   if (pageIndex === -1)
@@ -168787,12 +169055,7 @@ function findAdjacentLineElement(currentLine, direction) {
   const nextPage = pages[pageIndex + direction];
   if (!nextPage)
     return null;
-  const pageFragments = Array.from(nextPage.querySelectorAll(`.${fragmentClass}`)).filter((frag) => {
-    return !frag.closest?.(`.${headerClass}, .${footerClass}`);
-  });
-  if (direction > 0)
-    return getEdgeLineFromFragment(pageFragments[0], direction);
-  return getEdgeLineFromFragment(pageFragments[pageFragments.length - 1], direction);
+  return findEdgeLineForPage(getPageLineElements(nextPage), direction, caretX);
 }
 function resolvePositionAtGoalX(editor, pmStart, pmEnd, goalX) {
   const presentationEditor = editor.presentationEditor;
@@ -168821,13 +169084,105 @@ function resolvePositionAtGoalX(editor, pmStart, pmEnd, goalX) {
   }
   return { pos: bestPos };
 }
-function getEdgeLineFromFragment(fragment2, direction) {
-  if (!fragment2)
+function getPageLineElements(page) {
+  const fragmentClass = DOM_CLASS_NAMES.FRAGMENT;
+  const lineClass = DOM_CLASS_NAMES.LINE;
+  const headerClass = "superdoc-page-header";
+  const footerClass = "superdoc-page-footer";
+  return Array.from(page.querySelectorAll(`.${fragmentClass}`)).filter((fragment2) => !fragment2.closest?.(`.${headerClass}, .${footerClass}`)).flatMap((fragment2) => Array.from(fragment2.querySelectorAll(`.${lineClass}`)));
+}
+function findClosestLineInDirection(lineEls, currentLine, currentMetrics, direction, caretX) {
+  const directionalCandidates = lineEls.filter((line) => line !== currentLine).map((line) => ({
+    line,
+    metrics: getLineMetrics(line)
+  })).filter(({ metrics }) => metrics && isLineInDirection(metrics.centerY, currentMetrics.centerY, direction));
+  if (directionalCandidates.length === 0)
     return null;
-  const lineEls = Array.from(fragment2.querySelectorAll(`.${DOM_CLASS_NAMES.LINE}`));
-  if (lineEls.length === 0)
+  const nearestVerticalDistance = directionalCandidates.reduce((minDistance, { metrics }) => {
+    const distance = Math.abs(metrics.centerY - currentMetrics.centerY);
+    return Math.min(minDistance, distance);
+  }, Infinity);
+  const targetRowCenterY = directionalCandidates.filter(({ metrics }) => isWithinTolerance(Math.abs(metrics.centerY - currentMetrics.centerY), nearestVerticalDistance, 1)).reduce((bestCenterY, { metrics }) => {
+    if (bestCenterY == null)
+      return metrics.centerY;
+    return direction > 0 ? Math.min(bestCenterY, metrics.centerY) : Math.max(bestCenterY, metrics.centerY);
+  }, null);
+  if (!Number.isFinite(targetRowCenterY))
+    return null;
+  return chooseLineClosestToX(directionalCandidates.filter(({ metrics }) => isWithinTolerance(metrics.centerY, targetRowCenterY, getRowTolerance(currentMetrics, metrics))), caretX);
+}
+function findEdgeLineForPage(lineEls, direction, caretX) {
+  const candidates = lineEls.map((line) => ({
+    line,
+    metrics: getLineMetrics(line)
+  })).filter(({ metrics }) => metrics);
+  if (candidates.length === 0)
+    return null;
+  const targetRowCenterY = candidates.reduce((edgeCenterY, { metrics }) => {
+    if (edgeCenterY == null)
+      return metrics.centerY;
+    return direction > 0 ? Math.min(edgeCenterY, metrics.centerY) : Math.max(edgeCenterY, metrics.centerY);
+  }, null);
+  if (!Number.isFinite(targetRowCenterY))
     return null;
-  return direction > 0 ? lineEls[0] : lineEls[lineEls.length - 1];
+  return chooseLineClosestToX(candidates.filter(({ metrics }) => isWithinTolerance(metrics.centerY, targetRowCenterY, Math.max(metrics.height / 2, 1))), caretX);
+}
+function chooseLineClosestToX(candidates, caretX) {
+  if (candidates.length === 0)
+    return null;
+  let best = null;
+  for (const candidate of candidates) {
+    const horizontalDistance = getHorizontalDistanceToLine(candidate.metrics, caretX);
+    const centerDistance = Math.abs(candidate.metrics.centerX - caretX);
+    if (!best || horizontalDistance < best.horizontalDistance || horizontalDistance === best.horizontalDistance && centerDistance < best.centerDistance)
+      best = {
+        line: candidate.line,
+        horizontalDistance,
+        centerDistance
+      };
+  }
+  return best?.line ?? null;
+}
+function getLineMetrics(line) {
+  const rect = line?.getBoundingClientRect?.();
+  if (!rect)
+    return null;
+  const { top: top$1, bottom: bottom$1, left: left$1, right: right$1, height, width } = rect;
+  if (![
+    top$1,
+    bottom$1,
+    left$1,
+    right$1,
+    height,
+    width
+  ].every(Number.isFinite))
+    return null;
+  return {
+    top: top$1,
+    bottom: bottom$1,
+    left: left$1,
+    right: right$1,
+    height,
+    centerX: left$1 + width / 2,
+    centerY: top$1 + height / 2
+  };
+}
+function isLineInDirection(lineCenterY, currentCenterY, direction) {
+  const epsilon = 1;
+  return direction > 0 ? lineCenterY > currentCenterY + epsilon : lineCenterY < currentCenterY - epsilon;
+}
+function isWithinTolerance(value, expected, tolerance) {
+  return Math.abs(value - expected) <= tolerance;
+}
+function getRowTolerance(currentMetrics, candidateMetrics) {
+  return Math.max(Math.min(currentMetrics.height, candidateMetrics.height) / 2, 1);
+}
+function getHorizontalDistanceToLine(metrics, caretX) {
+  if (caretX < metrics.left)
+    return metrics.left - caretX;
+  if (caretX > metrics.right)
+    return caretX - metrics.right;
+  return 0;
 }
 function getAttributesDiff(objectA = {}, objectB = {}, ignoreKeys = []) {
   const diff = {
@@ -210878,7 +211233,7 @@ var Node$13 = class Node$14 {
     insideH: borderSpec,
     insideV: borderSpec
   };
-}, ZERO_WIDTH_SPACE = "​", ROW_START_TO_TEXT_OFFSET = 3, CELL_TO_TEXT_OFFSET = 2, normalizeHeaderAttrsForBodyCell = (attrs) => {
+}, TABLE_CELL_ROLES, TableBoundaryNavigationPluginKey, ZERO_WIDTH_SPACE = "​", ROW_START_TO_TEXT_OFFSET = 3, CELL_TO_TEXT_OFFSET = 2, normalizeHeaderAttrsForBodyCell = (attrs) => {
   if (attrs?.borders !== null)
     return attrs;
   const nextAttrs = { ...attrs };
@@ -231035,7 +231390,7 @@ var Node$13 = class Node$14 {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_ncOuYa9X_es = __esm(() => {
+var init_src_D389XrYP_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_SuperConverter_Cukh7tk8_es();
   init_jszip_ChlR43oI_es();
@@ -234943,6 +235298,8 @@ ${err.toString()}`);
       } };
     }
   });
+  TABLE_CELL_ROLES = new Set(["cell", "header_cell"]);
+  TableBoundaryNavigationPluginKey = new PluginKey("tableBoundaryNavigation");
   Table = Node$13.create({
     name: "table",
     content: "tableRow+",
@@ -235119,7 +235476,7 @@ ${err.toString()}`);
             return true;
           }).run();
         },
-        insertTable: ({ rows = 3, cols = 3, withHeaderRow = false, columnWidths = null } = {}) => ({ tr, dispatch, editor }) => {
+        insertTable: ({ rows = 3, cols = 3, withHeaderRow = false, columnWidths = null } = {}) => ({ tr, dispatch, editor, state }) => {
           const widths = columnWidths ?? computeColumnWidths(editor, cols);
           const resolved = normalizeNewTableAttrs(editor);
           const tableAttrs = {
@@ -235129,10 +235486,34 @@ ${err.toString()}`);
           };
           const node3 = createTable(editor.schema, rows, cols, withHeaderRow, null, widths, tableAttrs);
           if (dispatch) {
-            let offset$1 = tr.selection.$from.end() + 1;
-            if (tr.selection.$from.parent?.type?.name === "run")
-              offset$1 = tr.selection.$from.after(tr.selection.$from.depth - 1);
-            tr.replaceSelectionWith(node3).scrollIntoView().setSelection(TextSelection2.near(tr.doc.resolve(offset$1)));
+            let offset$1;
+            let replaceRange2 = undefined;
+            if (tr.selection.$from.depth === 0) {
+              offset$1 = tr.selection.from;
+              replaceRange2 = {
+                from: tr.selection.from,
+                to: tr.selection.to
+              };
+            } else {
+              offset$1 = tr.selection.$from.end() + 1;
+              const paragraphDepth = tr.selection.$from.parent?.type?.name === "run" ? tr.selection.$from.depth - 1 : tr.selection.$from.depth;
+              const paragraph2 = tr.selection.$from.node(paragraphDepth);
+              const isTopLevelParagraph = paragraphDepth === 1;
+              const isEmptyParagraph = paragraph2.type.name === "paragraph" && paragraph2.textContent === "";
+              if (isTopLevelParagraph && isEmptyParagraph) {
+                offset$1 = tr.selection.$from.before(paragraphDepth);
+                replaceRange2 = {
+                  from: tr.selection.$from.before(paragraphDepth),
+                  to: tr.selection.$from.after(paragraphDepth)
+                };
+              } else if (tr.selection.$from.parent?.type?.name === "run")
+                offset$1 = tr.selection.$from.after(paragraphDepth);
+            }
+            const { inserted } = insertTopLevelTableWithSeparators(tr, state.doc, offset$1, node3, replaceRange2);
+            if (!inserted)
+              return false;
+            const selectionPos = getFirstTableCellTextPos(offset$1, node3);
+            tr.scrollIntoView().setSelection(TextSelection2.near(tr.doc.resolve(selectionPos)));
           }
           return true;
         },
@@ -235172,30 +235553,9 @@ ${err.toString()}`);
             };
             const tableNode = tableType.createChecked(tableAttrs, rowNodes);
             if (dispatch) {
-              const sep = tableSeparatorNeeds(state.doc, pos);
-              const makeSep = () => {
-                const attrs = {
-                  sdBlockId: v4_default(),
-                  paraId: generateDocxHexId()
-                };
-                return state.schema.nodes.paragraph.createAndFill(attrs);
-              };
-              if (sep.before || sep.after) {
-                const nodes = [];
-                if (sep.before) {
-                  const s2 = makeSep();
-                  if (s2)
-                    nodes.push(s2);
-                }
-                nodes.push(tableNode);
-                if (sep.after) {
-                  const s2 = makeSep();
-                  if (s2)
-                    nodes.push(s2);
-                }
-                tr.insert(pos, Fragment.from(nodes));
-              } else
-                tr.insert(pos, tableNode);
+              const { inserted } = insertTopLevelTableWithSeparators(tr, state.doc, pos, tableNode);
+              if (!inserted)
+                return false;
               tr.setMeta("inputType", "programmatic");
               if (tracked === true)
                 tr.setMeta("forceTrackChanges", true);
@@ -235524,6 +235884,7 @@ ${err.toString()}`);
           View: createTableView({ editor: this.editor })
         })] : [],
         tableEditing({ allowTableNodeSelection: this.options.allowTableNodeSelection }),
+        createTableBoundaryNavigationPlugin(),
         (() => {
           let initialScanDone = false;
           return new Plugin({
@@ -264336,7 +264697,7 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_ncOuYa9X_es();
+  init_src_D389XrYP_es();
   init_SuperConverter_Cukh7tk8_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_BtmJ6bNs_es();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/cli",
-  "version": "0.3.0-next.54",
+  "version": "0.3.0-next.55",
   "type": "module",
   "bin": {
     "superdoc": "./dist/index.js"
@@ -22,19 +22,19 @@
     "typescript": "^5.9.2",
     "@superdoc/document-api": "0.0.1",
     "@superdoc/super-editor": "0.0.1",
-    "@superdoc/pm-adapter": "0.0.0",
-    "superdoc": "1.20.0"
+    "superdoc": "1.20.0",
+    "@superdoc/pm-adapter": "0.0.0"
   },
   "module": "src/index.ts",
   "publishConfig": {
     "access": "public"
   },
   "optionalDependencies": {
-    "@superdoc-dev/cli-darwin-arm64": "0.3.0-next.54",
-    "@superdoc-dev/cli-darwin-x64": "0.3.0-next.54",
-    "@superdoc-dev/cli-linux-arm64": "0.3.0-next.54",
-    "@superdoc-dev/cli-linux-x64": "0.3.0-next.54",
-    "@superdoc-dev/cli-windows-x64": "0.3.0-next.54"
+    "@superdoc-dev/cli-darwin-arm64": "0.3.0-next.55",
+    "@superdoc-dev/cli-darwin-x64": "0.3.0-next.55",
+    "@superdoc-dev/cli-linux-x64": "0.3.0-next.55",
+    "@superdoc-dev/cli-linux-arm64": "0.3.0-next.55",
+    "@superdoc-dev/cli-windows-x64": "0.3.0-next.55"
   },
   "scripts": {
     "predev": "node scripts/ensure-superdoc-build.js",