@wangeditor-next/editor 5.6.36 → 5.6.37

package/dist/index.js

@@ -13866,7 +13866,7 @@
           // 传入 html ，转换为 JSON content
           editor.children = htmlToContent(editor, html);
       }
-      if (content && content.length) {
+      else if (content && content.length) {
           editor.children = content; // 传入 JSON content
       }
       if (editor.children.length === 0) {
@@ -32473,7 +32473,9 @@
       CodeBlockMenu.prototype.getValue = function (editor) {
           var elem = this.getSelectCodeElem(editor);
           if (elem == null) {
-              return '';
+              var _a = editor.getMenuConfig('codeSelectLang').codeLangs, codeLangs = _a === void 0 ? [] : _a;
+              var selectItem = codeLangs.find(function (item) { return item.selected; });
+              return (selectItem === null || selectItem === void 0 ? void 0 : selectItem.value) || '';
           }
           return elem.language || '';
       };
@@ -39038,9 +39040,12 @@
   }
   function tableCellToHtml(cellNode, childrenHtml) {
       var _a = cellNode, _b = _a.colSpan, colSpan = _b === void 0 ? 1 : _b, _c = _a.rowSpan, rowSpan = _c === void 0 ? 1 : _c, _d = _a.isHeader, isHeader = _d === void 0 ? false : _d, _e = _a.width, width = _e === void 0 ? 'auto' : _e, _f = _a.hidden, hidden = _f === void 0 ? false : _f;
+      // 如果单元格被隐藏，直接返回空字符串，不生成 HTML 元素
+      if (hidden) {
+          return '';
+      }
       var tag = isHeader ? 'th' : 'td';
-      var style = hidden ? 'display:none' : '';
-      return "<".concat(tag, " colSpan=\"").concat(colSpan, "\" rowSpan=\"").concat(rowSpan, "\" width=\"").concat(width, "\" style=\"").concat(style, "\">").concat(childrenHtml, "</").concat(tag, ">");
+      return "<".concat(tag, " colSpan=\"").concat(colSpan, "\" rowSpan=\"").concat(rowSpan, "\" width=\"").concat(width, "\">").concat(childrenHtml, "</").concat(tag, ">");
   }
   var tableToHtmlConf = {
       type: 'table',
@@ -39227,25 +39232,45 @@
           for (var _b = __values(matrices(editor, { at: options.at })), _c = _b.next(); !_c.done; _c = _b.next()) {
               var matrix = _c.value;
               var filledSection = [];
+              // 首先，找出最大的列数来确定矩阵的宽度
+              var maxCols = 0;
+              for (var x = 0; x < matrix.length; x += 1) {
+                  if (matrix[x]) {
+                      maxCols = Math.max(maxCols, matrix[x].length);
+                  }
+              }
               for (var x = 0; x < matrix.length; x += 1) {
                   if (!filledSection[x]) {
                       filledSection[x] = [];
                   }
+                  if (!matrix[x]) {
+                      continue;
+                  }
                   for (var y = 0; y < matrix[x].length; y += 1) {
+                      if (!matrix[x][y] || !matrix[x][y][0]) {
+                          continue;
+                      }
                       var _d = __read(matrix[x][y], 1), _e = _d[0], _f = _e.rowSpan, rowSpan = _f === void 0 ? 1 : _f, _g = _e.colSpan, colSpan = _g === void 0 ? 1 : _g;
-                      for (var c = 0, occupied = 0; c < colSpan + occupied; c += 1) {
+                      // 找到下一个可用的位置
+                      var startCol = y;
+                      while (filledSection[x] && filledSection[x][startCol]) {
+                          startCol += 1;
+                      }
+                      for (var c = 0; c < colSpan; c += 1) {
                           for (var r = 0; r < rowSpan; r += 1) {
-                              if (!filledSection[x + r]) {
-                                  filledSection[x + r] = [];
+                              var targetX = x + r;
+                              var targetY = startCol + c;
+                              if (!filledSection[targetX]) {
+                                  filledSection[targetX] = [];
                               }
-                              if (filledSection[x + r][y + c]) {
+                              if (filledSection[targetX][targetY]) {
                                   continue;
                               }
-                              filledSection[x + r][y + c] = [
-                                  matrix[x + r][y + c],
+                              filledSection[targetX][targetY] = [
+                                  matrix[x][y],
                                   {
-                                      rtl: c - occupied + 1,
-                                      ltr: colSpan - c + occupied,
+                                      rtl: c + 1,
+                                      ltr: colSpan - c,
                                       ttb: r + 1,
                                       btt: rowSpan - r,
                                   },
@@ -39636,58 +39661,92 @@
           }
           distExports$1.Editor.withoutNormalizing(editor, function () {
               var e_1, _a;
+              // 记录需要删除的单元格路径和已处理的合并单元格
+              var cellsToDelete = new Set();
+              var processedMergedCells = new Set();
+              // 遍历每一行的第 tdIndex 列
               for (var x = 0; x < matrix.length; x += 1) {
-                  var _b = __read(matrix[x][tdIndex], 2), _c = __read(_b[0], 1), hidden = _c[0].hidden, _d = _b[1], rtl = _d.rtl, ltr = _d.ltr;
-                  if (rtl > 1 || ltr > 1) {
-                      // 找到显示中 colSpan 节点
-                      var _e = __read(matrix[x][tdIndex - (rtl - 1)], 1), _f = __read(_e[0], 2), _g = _f[0], _h = _g.rowSpan, rowSpan = _h === void 0 ? 1 : _h, _j = _g.colSpan, colSpan = _j === void 0 ? 1 : _j, path = _f[1];
-                      if (hidden) {
-                          distExports$1.Transforms.setNodes(editor, {
-                              rowSpan: rowSpan,
-                              colSpan: Math.max(colSpan - 1, 1),
-                          }, { at: path });
+                  if (!matrix[x] || !matrix[x][tdIndex]) {
+                      continue;
+                  }
+                  var _b = __read(matrix[x][tdIndex], 2), _c = __read(_b[0], 2), cellPath = _c[1], _d = _b[1], rtl = _d.rtl, ltr = _d.ltr, ttb = _d.ttb, btt = _d.btt;
+                  var cellPathKey = cellPath.join(',');
+                  // 判断是否是合并单元格
+                  if (rtl > 1 || ltr > 1 || ttb > 1 || btt > 1) {
+                      // 这是合并单元格的一部分
+                      // 找到真实单元格的位置（左上角的位置）
+                      // rtl表示从右到左的距离，所以真实单元格列 = 当前列 - (rtl - 1)
+                      // ttb表示从上到下的距离，所以真实单元格行 = 当前行 - (ttb - 1)
+                      var realCellRow = x - (ttb - 1);
+                      var realCellCol = tdIndex - (rtl - 1);
+                      // 安全检查：确保真实单元格位置存在
+                      if (realCellRow < 0 || realCellRow >= matrix.length
+                          || !matrix[realCellRow] || !matrix[realCellRow][realCellCol]) {
+                          continue;
                       }
-                      else {
-                          var _k = __read(matrix[x][tdIndex + 1], 1), _l = __read(_k[0], 2), rightPath = _l[1];
+                      var _e = __read(matrix[realCellRow][realCellCol], 1), _f = __read(_e[0], 2), realCellElement = _f[0], realCellPath = _f[1];
+                      var realCellPathKey = realCellPath.join(',');
+                      // 避免重复处理同一个合并单元格
+                      if (!processedMergedCells.has(realCellPathKey)) {
+                          processedMergedCells.add(realCellPathKey);
+                          var _g = realCellElement.rowSpan, rowSpan = _g === void 0 ? 1 : _g, _h = realCellElement.colSpan, colSpan = _h === void 0 ? 1 : _h;
+                          var newColSpan = Math.max(colSpan - 1, 1);
+                          // 更新真实单元格的 colSpan
                           distExports$1.Transforms.setNodes(editor, {
                               rowSpan: rowSpan,
-                              colSpan: colSpan - 1,
-                              hidden: false,
-                          }, { at: rightPath });
-                          try {
-                              // 移动单元格 文本、图片等元素
-                              for (var _m = (e_1 = void 0, __values(distExports$1.Node.children(editor, path, { reverse: true }))), _o = _m.next(); !_o.done; _o = _m.next()) {
-                                  var _p = __read(_o.value, 2), childPath = _p[1];
-                                  distExports$1.Transforms.moveNodes(editor, {
-                                      to: __spreadArray(__spreadArray([], __read(rightPath), false), [0], false),
-                                      at: childPath,
-                                  });
-                              }
-                          }
-                          catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                          finally {
-                              try {
-                                  if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
-                              }
-                              finally { if (e_1) throw e_1.error; }
+                              colSpan: newColSpan,
+                          }, { at: realCellPath });
+                      }
+                  }
+                  else {
+                      // rtl = 1 且 ltr = 1 且 ttb = 1 且 btt = 1，说明这是独立的单元格，直接删除
+                      cellsToDelete.add(cellPathKey);
+                  }
+              }
+              // 删除独立的单元格
+              var cellsToDeleteArray = Array.from(cellsToDelete);
+              // 按路径深度降序排序，确保从深层到浅层删除，避免路径失效
+              cellsToDeleteArray.sort(function (a, b) {
+                  var pathA = a.split(',').map(Number);
+                  var pathB = b.split(',').map(Number);
+                  // 按行降序排序
+                  if (pathA[pathA.length - 2] !== pathB[pathB.length - 2]) {
+                      return pathB[pathB.length - 2] - pathA[pathA.length - 2];
+                  }
+                  // 同行内按列降序排序
+                  return pathB[pathB.length - 1] - pathA[pathA.length - 1];
+              });
+              try {
+                  for (var cellsToDeleteArray_1 = __values(cellsToDeleteArray), cellsToDeleteArray_1_1 = cellsToDeleteArray_1.next(); !cellsToDeleteArray_1_1.done; cellsToDeleteArray_1_1 = cellsToDeleteArray_1.next()) {
+                      var pathKey = cellsToDeleteArray_1_1.value;
+                      var path = pathKey.split(',').map(Number);
+                      try {
+                          if (distExports$1.Editor.hasPath(editor, path)) {
+                              distExports$1.Transforms.removeNodes(editor, { at: path });
                           }
                       }
+                      catch (error) {
+                          console.warn('删除单元格失败:', path, error);
+                      }
                   }
               }
-              // 挨个删除 cell
-              for (var x = 0; x < matrix.length; x += 1) {
-                  var _q = __read(matrix[x][tdIndex], 1), _r = __read(_q[0], 2), path = _r[1];
-                  distExports$1.Transforms.removeNodes(editor, { at: path });
+              catch (e_1_1) { e_1 = { error: e_1_1 }; }
+              finally {
+                  try {
+                      if (cellsToDeleteArray_1_1 && !cellsToDeleteArray_1_1.done && (_a = cellsToDeleteArray_1.return)) _a.call(cellsToDeleteArray_1);
+                  }
+                  finally { if (e_1) throw e_1.error; }
               }
-              // 需要调整 columnWidths
-              var _s = __read(distExports$1.Editor.nodes(editor, {
+              // 调整表格的 columnWidths
+              var _j = __read(distExports$1.Editor.nodes(editor, {
                   match: function (n) { return DomEditor.checkNodeType(n, 'table'); },
                   universal: true,
-              }), 1), tableEntry = _s[0];
+              }), 1), tableEntry = _j[0];
               if (tableEntry) {
-                  var _t = __read(tableEntry, 2), elemNode = _t[0], tablePath = _t[1];
-                  var _u = elemNode.columnWidths, columnWidths = _u === void 0 ? [] : _u;
+                  var _k = __read(tableEntry, 2), elemNode = _k[0], tablePath = _k[1];
+                  var _l = elemNode.columnWidths, columnWidths = _l === void 0 ? [] : _l;
                   var adjustColumnWidths = __spreadArray([], __read(columnWidths), false);
+                  // 删除对应列的宽度
                   adjustColumnWidths.splice(tdIndex, 1);
                   distExports$1.Transforms.setNodes(editor, { columnWidths: adjustColumnWidths }, {
                       at: tablePath,
@@ -39769,47 +39828,130 @@
           }
           distExports$1.Editor.withoutNormalizing(editor, function () {
               var e_1, _a;
+              // 收集需要在下一行插入的新单元格信息
+              var cellsToInsert = [];
               for (var y = 0; y < matrix[trIndex].length; y += 1) {
-                  var _b = __read(matrix[trIndex][y], 2), _c = __read(_b[0], 1), hidden = _c[0].hidden, _d = _b[1], ttb = _d.ttb, btt = _d.btt;
+                  var _b = __read(matrix[trIndex][y], 2), _c = __read(_b[0], 1), hidden = _c[0].hidden, _d = _b[1], ttb = _d.ttb, btt = _d.btt, rtl = _d.rtl;
                   // 寻找跨行行为
                   if (ttb > 1 || btt > 1) {
                       // 找到显示中 rowSpan 节点
-                      var _e = __read(matrix[trIndex - (ttb - 1)][y], 1), _f = __read(_e[0], 2), _g = _f[0], _h = _g.rowSpan, rowSpan = _h === void 0 ? 1 : _h, _j = _g.colSpan, colSpan = _j === void 0 ? 1 : _j, path = _f[1];
-                      // 如果当前选中节点为隐藏节点，则向上寻找处理 rowSpan 逻辑
+                      var originalRowIndex = trIndex - (ttb - 1);
+                      // 安全检查：确保目标行和列都存在
+                      if (originalRowIndex < 0 || originalRowIndex >= matrix.length || !matrix[originalRowIndex] || !matrix[originalRowIndex][y]) {
+                          continue;
+                      }
+                      var _e = __read(matrix[originalRowIndex][y], 1), _f = __read(_e[0], 2), originalCell = _f[0], path = _f[1];
+                      var typedOriginalCell = originalCell;
+                      var _g = typedOriginalCell.rowSpan, rowSpan = _g === void 0 ? 1 : _g, _h = typedOriginalCell.colSpan, colSpan = _h === void 0 ? 1 : _h;
                       if (hidden) {
+                          // 如果当前选中节点为隐藏节点，则向上寻找处理 rowSpan 逻辑
                           distExports$1.Transforms.setNodes(editor, {
                               rowSpan: Math.max(rowSpan - 1, 1),
                               colSpan: colSpan,
                           }, { at: path });
                       }
+                      else if (ttb === 1 && rtl === 1) {
+                          // 只处理合并单元格的真正位置（左上角）：ttb=1且rtl=1
+                          // 这样避免重复处理同一个合并单元格
+                          var hasNextRow = trIndex + 1 < matrix.length;
+                          if (hasNextRow && rowSpan > 1) {
+                              // 创建新的单元格，继承原单元格的内容和属性
+                              var newCell = {
+                                  type: 'table-cell',
+                                  rowSpan: rowSpan - 1, // 新单元格的rowSpan = 原rowSpan - 1
+                                  colSpan: colSpan, // 保持原来的colSpan
+                                  hidden: false,
+                                  children: typedOriginalCell.children.map(function (child) { return (__assign({}, child)); }), // 深拷贝继承原单元格的内容
+                              };
+                              // 继承原单元格的其他属性
+                              if (typedOriginalCell.isHeader) {
+                                  newCell.isHeader = typedOriginalCell.isHeader;
+                              }
+                              if (typedOriginalCell.width) {
+                                  newCell.width = typedOriginalCell.width;
+                              }
+                              if (typedOriginalCell.backgroundColor) {
+                                  newCell.backgroundColor = typedOriginalCell.backgroundColor;
+                              }
+                              if (typedOriginalCell.borderWidth) {
+                                  newCell.borderWidth = typedOriginalCell.borderWidth;
+                              }
+                              if (typedOriginalCell.borderStyle) {
+                                  newCell.borderStyle = typedOriginalCell.borderStyle;
+                              }
+                              if (typedOriginalCell.borderColor) {
+                                  newCell.borderColor = typedOriginalCell.borderColor;
+                              }
+                              if (typedOriginalCell.textAlign) {
+                                  newCell.textAlign = typedOriginalCell.textAlign;
+                              }
+                              // 记录需要插入的单元格信息
+                              cellsToInsert.push({
+                                  cell: newCell,
+                                  columnIndex: y,
+                              });
+                          }
+                          else {
+                              // 如果没有下一行，直接减少原始单元格的 rowSpan
+                              distExports$1.Transforms.setNodes(editor, {
+                                  rowSpan: Math.max(rowSpan - 1, 1),
+                                  colSpan: colSpan,
+                              }, { at: path });
+                          }
+                      }
                       else {
-                          var _k = __read(matrix[trIndex + 1][y], 1), _l = __read(_k[0], 2), belowPath = _l[1];
+                          // 处理其他跨行单元格的情况：非隐藏且非左上角原始位置
+                          // 这种情况下也需要减少原始单元格的 rowSpan
                           distExports$1.Transforms.setNodes(editor, {
-                              rowSpan: rowSpan - 1,
+                              rowSpan: Math.max(rowSpan - 1, 1),
                               colSpan: colSpan,
-                              hidden: false,
-                          }, { at: belowPath });
-                          try {
-                              // 移动单元格 文本、图片等元素
-                              for (var _m = (e_1 = void 0, __values(distExports$1.Node.children(editor, path, { reverse: true }))), _o = _m.next(); !_o.done; _o = _m.next()) {
-                                  var _p = __read(_o.value, 2), childPath = _p[1];
-                                  distExports$1.Transforms.moveNodes(editor, {
-                                      to: __spreadArray(__spreadArray([], __read(belowPath), false), [0], false),
-                                      at: childPath,
-                                  });
-                              }
-                          }
-                          catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                          finally {
+                          }, { at: path });
+                      }
+                  }
+              }
+              // 删除当前行
+              distExports$1.Transforms.removeNodes(editor, { at: rowPath });
+              // 在下一行（现在变成了当前行）的对应位置插入新单元格
+              if (cellsToInsert.length > 0) {
+                  // 删除行后，原来的下一行会移动到rowPath的位置
+                  var targetRowPath = rowPath;
+                  try {
+                      // 按列索引排序，从左到右插入
+                      cellsToInsert.sort(function (a, b) { return a.columnIndex - b.columnIndex; });
+                      try {
+                          for (var cellsToInsert_1 = __values(cellsToInsert), cellsToInsert_1_1 = cellsToInsert_1.next(); !cellsToInsert_1_1.done; cellsToInsert_1_1 = cellsToInsert_1.next()) {
+                              var _j = cellsToInsert_1_1.value, cell = _j.cell, columnIndex = _j.columnIndex;
                               try {
-                                  if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+                                  // 尝试在对应的列位置插入
+                                  var insertPath = __spreadArray(__spreadArray([], __read(targetRowPath), false), [columnIndex], false);
+                                  distExports$1.Transforms.insertNodes(editor, cell, { at: insertPath });
                               }
-                              finally { if (e_1) throw e_1.error; }
+                              catch (error) {
+                                  // 如果插入失败，尝试在行末尾插入
+                                  try {
+                                      var _k = __read(distExports$1.Editor.node(editor, targetRowPath), 1), targetRow = _k[0];
+                                      var cellCount = targetRow.children.length;
+                                      var endPath = __spreadArray(__spreadArray([], __read(targetRowPath), false), [cellCount], false);
+                                      distExports$1.Transforms.insertNodes(editor, cell, { at: endPath });
+                                  }
+                                  catch (fallbackError) {
+                                      console.warn('插入新单元格失败:', fallbackError);
+                                  }
+                              }
+                          }
+                      }
+                      catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                      finally {
+                          try {
+                              if (cellsToInsert_1_1 && !cellsToInsert_1_1.done && (_a = cellsToInsert_1.return)) _a.call(cellsToInsert_1);
                           }
+                          finally { if (e_1) throw e_1.error; }
                       }
                   }
+                  catch (error) {
+                      console.warn('插入新单元格失败:', error);
+                  }
               }
-              distExports$1.Transforms.removeNodes(editor, { at: rowPath });
           });
       };
       return DeleteRow;
@@ -39864,13 +40006,13 @@
           this.iconSvg = FULL_WIDTH_SVG;
           this.tag = 'button';
       }
-      // 是否已设置 宽度自适应
       TableFullWidth.prototype.getValue = function (editor) {
           var tableNode = DomEditor.getSelectedNodeByType(editor, 'table');
-          if (tableNode == null) {
+          if (!tableNode) {
               return false;
           }
-          return tableNode.width === '100%';
+          // 检查表格是否已经是全宽（width为100%或auto）
+          return tableNode.width === '100%' || tableNode.width === 'auto';
       };
       TableFullWidth.prototype.isActive = function (editor) {
           return !!this.getValue(editor);
@@ -39976,6 +40118,47 @@
               // 选区未处于 table cell node ，则禁用
               return true;
           }
+          // 检查当前单元格的宽度是否小于20px
+          try {
+              var _a = __read(distExports$1.Editor.nodes(editor, {
+                  match: function (n) { return DomEditor.checkNodeType(n, 'table-cell'); },
+                  universal: true,
+              }), 1), cellEntry = _a[0];
+              if (!cellEntry) {
+                  return true;
+              }
+              var _b = __read(cellEntry, 2), selectedCellPath = _b[1];
+              var matrix = filledMatrix(editor);
+              var tdIndex = -1;
+              // 找到当前单元格在矩阵中的列索引
+              for (var x = 0; x < matrix.length; x += 1) {
+                  for (var y = 0; y < matrix[x].length; y += 1) {
+                      var _c = __read(matrix[x][y], 1), _d = __read(_c[0], 2), path = _d[1];
+                      if (distExports$1.Path.equals(selectedCellPath, path)) {
+                          tdIndex = y;
+                          break;
+                      }
+                  }
+                  if (tdIndex !== -1) {
+                      break;
+                  }
+              }
+              if (tdIndex === -1) {
+                  return true;
+              }
+              // 获取表格的列宽信息
+              var tableElement = tableNode;
+              var _e = tableElement.columnWidths, columnWidths = _e === void 0 ? [] : _e;
+              // 检查当前列的宽度 - 如果小于20px则禁用插入列功能
+              var currentColWidth = columnWidths[tdIndex];
+              if (currentColWidth && currentColWidth < 20) {
+                  return true; // 宽度限制：当前列宽度小于20px时禁用插入列功能
+              }
+          }
+          catch (error) {
+              // 如果检查过程中出现错误，为安全起见禁用功能
+              return true;
+          }
           return false;
       };
       InsertCol.prototype.exec = function (editor, _value) {
@@ -40007,48 +40190,94 @@
               }
           }
           distExports$1.Editor.withoutNormalizing(editor, function () {
-              var exitMerge = [];
+              // 记录已处理的合并单元格和需要跳过插入的行
+              var processedMergedCells = new Set();
+              var skipInsertForRows = new Set();
+              // 遍历每一行的第 tdIndex 列，处理合并单元格
               for (var x = 0; x < matrix.length; x += 1) {
-                  var _a = __read(matrix[x][tdIndex], 2), _b = _a[1], ltr = _b.ltr, rtl = _b.rtl;
-                  // 向左找到 1 元素为止
-                  if (ltr > 1 || rtl > 1) {
-                      if (rtl === 1) {
+                  // 安全检查：确保行和列都存在
+                  if (!matrix[x] || !matrix[x][tdIndex]) {
+                      continue;
+                  }
+                  var _a = __read(matrix[x][tdIndex], 2); __read(_a[0], 1); var _c = _a[1], rtl = _c.rtl, ltr = _c.ltr, ttb = _c.ttb, btt = _c.btt;
+                  // 判断是否是合并单元格
+                  if (rtl > 1 || ltr > 1 || ttb > 1 || btt > 1) {
+                      // 这是合并单元格的一部分
+                      // 找到真实单元格的位置（左上角的位置）
+                      // rtl表示从右到左的距离，所以真实单元格列 = 当前列 - (rtl - 1)
+                      // ttb表示从上到下的距离，所以真实单元格行 = 当前行 - (ttb - 1)
+                      var realCellRow = x - (ttb - 1);
+                      var realCellCol = tdIndex - (rtl - 1);
+                      // 安全检查：确保真实单元格位置存在
+                      if (realCellRow < 0 || realCellRow >= matrix.length
+                          || !matrix[realCellRow] || !matrix[realCellRow][realCellCol]) {
                           continue;
                       }
-                      var _c = __read(matrix[x][tdIndex - (rtl - 1)], 1), _d = __read(_c[0], 2), element = _d[0], path = _d[1];
-                      var colSpan = element.colSpan || 1;
-                      exitMerge.push(x);
-                      if (!element.hidden) {
-                          distExports$1.Transforms.setNodes(editor, {
-                              colSpan: colSpan + 1,
-                          }, { at: path });
+                      var _d = __read(matrix[realCellRow][realCellCol], 1), _e = __read(_d[0], 2), realCellElement = _e[0], realCellPath = _e[1];
+                      var realCellPathKey = realCellPath.join(',');
+                      // 避免重复处理同一个合并单元格
+                      if (!processedMergedCells.has(realCellPathKey)) {
+                          processedMergedCells.add(realCellPathKey);
+                          var _f = realCellElement.rowSpan, rowSpan = _f === void 0 ? 1 : _f, _g = realCellElement.colSpan, colSpan = _g === void 0 ? 1 : _g;
+                          var newColSpan = colSpan + 1;
+                          // 更新真实单元格的 colSpan
+                          if (!realCellElement.hidden) {
+                              distExports$1.Transforms.setNodes(editor, {
+                                  colSpan: newColSpan,
+                              }, { at: realCellPath });
+                          }
+                          // 标记所有被这个合并单元格影响的行，这些行不需要插入新的单元格
+                          // 从真实单元格的行开始，标记rowSpan行
+                          for (var r = 0; r < rowSpan; r += 1) {
+                              skipInsertForRows.add(realCellRow + r);
+                          }
+                      }
+                      else {
+                          // 如果已经处理过这个合并单元格，当前行也不需要插入新单元格
+                          skipInsertForRows.add(x);
                       }
                   }
               }
-              // 遍历所有 rows ，挨个添加 cell
+              // 遍历所有行，为需要插入的行添加新单元格
               for (var x = 0; x < matrix.length; x += 1) {
+                  // 如果这一行被合并单元格覆盖，则不插入新单元格
+                  if (skipInsertForRows.has(x)) {
+                      continue;
+                  }
+                  // 安全检查：确保矩阵位置存在
+                  if (!matrix[x] || !matrix[x][tdIndex]) {
+                      continue;
+                  }
                   var newCell = {
                       type: 'table-cell',
-                      hidden: exitMerge.includes(x),
                       children: [{ text: '' }],
                   };
+                  // 如果是第一行且表格有标题，设置为标题单元格
                   if (x === 0 && isTableWithHeader(tableNode)) {
                       newCell.isHeader = true;
                   }
-                  var _e = __read(matrix[x][tdIndex], 1), _f = __read(_e[0], 2), insertPath = _f[1];
+                  var _h = __read(matrix[x][tdIndex], 1), _j = __read(_h[0], 2), insertPath = _j[1];
                   distExports$1.Transforms.insertNodes(editor, newCell, { at: insertPath });
               }
-              // 需要调整 columnWidths
-              var _g = __read(distExports$1.Editor.nodes(editor, {
+              // 调整 columnWidths
+              var _k = __read(distExports$1.Editor.nodes(editor, {
                   match: function (n) { return DomEditor.checkNodeType(n, 'table'); },
                   universal: true,
-              }), 1), tableEntry = _g[0];
+              }), 1), tableEntry = _k[0];
               if (tableEntry) {
-                  var _h = __read(tableEntry, 2), elemNode = _h[0], tablePath = _h[1];
-                  var _j = elemNode.columnWidths, columnWidths = _j === void 0 ? [] : _j;
+                  var _l = __read(tableEntry, 2), elemNode = _l[0], tablePath = _l[1];
+                  var _m = elemNode.columnWidths, columnWidths = _m === void 0 ? [] : _m;
                   var adjustColumnWidths = __spreadArray([], __read(columnWidths), false);
-                  var _k = editor.getMenuConfig('insertTable').minWidth, minWidth = _k === void 0 ? 60 : _k;
-                  adjustColumnWidths.splice(tdIndex, 0, parseInt(minWidth, 10) || 60);
+                  // 获取当前列的宽度，如果没有设置则使用默认宽度
+                  var _o = editor.getMenuConfig('insertTable').minWidth, minWidth = _o === void 0 ? 60 : _o;
+                  var currentColWidth = columnWidths[tdIndex] || parseInt(minWidth, 10) || 60;
+                  // 将当前列宽度一分为二
+                  var halfWidth = Math.floor(currentColWidth / 2);
+                  var remainingWidth = currentColWidth - halfWidth;
+                  // 在当前位置插入新列（左侧），使用一半宽度
+                  adjustColumnWidths.splice(tdIndex, 0, halfWidth);
+                  // 更新原列宽度为剩余的一半
+                  adjustColumnWidths[tdIndex + 1] = remainingWidth;
                   distExports$1.Transforms.setNodes(editor, { columnWidths: adjustColumnWidths }, {
                       at: tablePath,
                   });
@@ -40092,20 +40321,15 @@
           return false;
       };
       InsertRow.prototype.exec = function (editor, _value) {
+          var _a;
           if (this.isDisabled(editor)) {
               return;
           }
-          var _a = __read(distExports$1.Editor.nodes(editor, {
+          var _b = __read(distExports$1.Editor.nodes(editor, {
               match: function (n) { return DomEditor.checkNodeType(n, 'table-cell'); },
               universal: true,
-          }), 1), cellEntry = _a[0];
-          var _b = __read(cellEntry, 2), cellNode = _b[0], cellPath = _b[1];
-          // 获取 cell length ，即多少列
-          var rowNode = DomEditor.getParentNode(editor, cellNode);
-          var cellsLength = (rowNode === null || rowNode === void 0 ? void 0 : rowNode.children.length) || 0;
-          if (cellsLength === 0) {
-              return;
-          }
+          }), 1), cellEntry = _b[0];
+          var _c = __read(cellEntry, 2), cellPath = _c[1];
           var matrix = filledMatrix(editor);
           // 向下插入行为，先找到
           // 当前选区所在的 tr 索引
@@ -40113,7 +40337,7 @@
           /* eslint-disable no-labels */
           outer: for (var x = 0; x < matrix.length; x += 1) {
               for (var y = 0; y < matrix[x].length; y += 1) {
-                  var _c = __read(matrix[x][y], 1), _d = __read(_c[0], 2), path = _d[1];
+                  var _d = __read(matrix[x][y], 1), _e = __read(_d[0], 2), path = _e[1];
                   if (!distExports$1.Path.equals(cellPath, path)) {
                       continue;
                   }
@@ -40122,7 +40346,11 @@
                   break outer;
               }
           }
-          /* eslint-disable no-labels */
+          // 获取表格的真实列数（使用matrix的列数，而不是当前行的physical cell数量）
+          var cellsLength = ((_a = matrix[trIndex]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+          if (cellsLength === 0) {
+              return;
+          }
           distExports$1.Editor.withoutNormalizing(editor, function () {
               // 向下添加 tr 索引
               var destIndex = trIndex + 1;
@@ -40132,10 +40360,12 @@
                   var _a = __read(matrix[trIndex][y], 2), _b = _a[1], ttb = _b.ttb, btt = _b.btt;
                   // 向上找到 1 元素为止
                   if (ttb > 1 || btt > 1) {
-                      if (btt === 1) {
+                      var originalRowIndex = trIndex - (ttb - 1);
+                      // 安全检查：确保目标行和列都存在
+                      if (originalRowIndex < 0 || originalRowIndex >= matrix.length || !matrix[originalRowIndex] || !matrix[originalRowIndex][y]) {
                           continue;
                       }
-                      var _c = __read(matrix[trIndex - (ttb - 1)][y], 1), _d = __read(_c[0], 2), element = _d[0], path = _d[1];
+                      var _c = __read(matrix[originalRowIndex][y], 1), _d = __read(_c[0], 2), element = _d[0], path = _d[1];
                       var rowSpan = element.rowSpan || 1;
                       exitMerge.push(y);
                       if (!element.hidden) {
@@ -40147,10 +40377,14 @@
               }
               // 拼接新的 row
               var newRow = { type: 'table-row', children: [] };
+              // 只为不被合并单元格覆盖的位置创建td元素
               for (var i = 0; i < cellsLength; i += 1) {
+                  // 如果当前位置被合并单元格覆盖，则跳过（不创建td）
+                  if (exitMerge.includes(i)) {
+                      continue;
+                  }
                   var cell = {
                       type: 'table-cell',
-                      hidden: exitMerge.includes(i),
                       children: [{ text: '' }],
                   };
                   newRow.children.push(cell);
@@ -40434,14 +40668,6 @@
           this.iconSvg = MERGE_CELL_SVG;
           this.tag = 'button';
       }
-      MergeCell.prototype.needKeepCell = function (editor, trPath) {
-          // 检查同行是否有其他单元格
-          var _a = __read(distExports$1.Node.children(editor, trPath), 2), rowSibling = _a[1];
-          // 检查同列是否有其他单元格
-          var parentTable = distExports$1.Editor.parent(editor, trPath);
-          var hasOtherRows = parentTable[0].children.length > 1;
-          return !!rowSibling || hasOtherRows;
-      };
       MergeCell.prototype.getValue = function (_editor) {
           // 无需获取 val
           return '';
@@ -40487,7 +40713,6 @@
        * @returns void
        */
       MergeCell.prototype.merge = function (editor) {
-          var _this = this;
           if (!this.canMerge(editor)) {
               return;
           }
@@ -40498,45 +40723,116 @@
           var _a = __read(selection[0][0], 1), _b = __read(_a[0], 2), basePath = _b[1];
           var _c = __read(distExports$1.Node.children(editor, basePath, { reverse: true }), 1), _d = __read(_c[0], 2), lastPath = _d[1];
           distExports$1.Editor.withoutNormalizing(editor, function () {
-              var e_1, _a;
-              var rowSpan = 0;
-              var colSpan = 0;
-              for (var x = selection.length - 1; x >= 0; x -= 1, rowSpan += 1) {
-                  colSpan = 0;
-                  for (var y = selection[x].length - 1; y >= 0; y -= 1, colSpan += 1) {
-                      var _b = __read(selection[x][y], 2), _c = __read(_b[0], 2), path = _c[1], ttb = _b[1].ttb;
-                      // skip first cell and "fake" cells which belong to a cell with a `rowspan`
-                      if (distExports$1.Path.equals(basePath, path) || ttb > 1) {
+              var e_1, _a, e_2, _b, e_3, _c;
+              // 收集所有真实的单元格（避免重复计算虚拟位置）
+              var realCells = new Map();
+              var cellsToDelete = [];
+              // 计算实际的边界范围（考虑单元格的实际跨度）
+              var minRow = Infinity;
+              var maxRow = -Infinity;
+              var minCol = Infinity;
+              var maxCol = -Infinity;
+              // 第一阶段：收集所有真实单元格并计算其实际占用的范围
+              for (var x = 0; x < selection.length; x += 1) {
+                  for (var y = 0; y < selection[x].length; y += 1) {
+                      var _d = __read(selection[x][y], 2), _e = __read(_d[0], 2), element = _e[0], path = _e[1], ttb = _d[1].ttb;
+                      var pathKey = path.join(',');
+                      // 只处理真实单元格（ttb === 1 表示单元格的实际位置，不是虚拟扩展）
+                      if (ttb === 1 && !realCells.has(pathKey)) {
+                          realCells.set(pathKey, {
+                              path: path,
+                              x: x,
+                              y: y,
+                              element: element,
+                          });
+                          // 获取当前单元格的跨度
+                          var _f = element.rowSpan, rowSpan = _f === void 0 ? 1 : _f, _g = element.colSpan, colSpan = _g === void 0 ? 1 : _g;
+                          // 计算该单元格实际占用的范围
+                          var cellMinRow = x;
+                          var cellMaxRow = x + rowSpan - 1;
+                          var cellMinCol = y;
+                          var cellMaxCol = y + colSpan - 1;
+                          // 更新整体边界
+                          minRow = Math.min(minRow, cellMinRow);
+                          maxRow = Math.max(maxRow, cellMaxRow);
+                          minCol = Math.min(minCol, cellMinCol);
+                          maxCol = Math.max(maxCol, cellMaxCol);
+                      }
+                  }
+              }
+              // 计算正确的rowSpan和colSpan（基于实际占用的行列范围）
+              var finalRowSpan = maxRow - minRow + 1;
+              var finalColSpan = maxCol - minCol + 1;
+              try {
+                  // 第二阶段：确定要删除的单元格
+                  for (var realCells_1 = __values(realCells), realCells_1_1 = realCells_1.next(); !realCells_1_1.done; realCells_1_1 = realCells_1.next()) {
+                      var _h = __read(realCells_1_1.value, 2), path = _h[1].path;
+                      // 跳过基础单元格（第一个单元格作为合并后的目标）
+                      if (distExports$1.Path.equals(basePath, path)) {
                           continue;
                       }
+                      cellsToDelete.push(path);
+                  }
+              }
+              catch (e_1_1) { e_1 = { error: e_1_1 }; }
+              finally {
+                  try {
+                      if (realCells_1_1 && !realCells_1_1.done && (_a = realCells_1.return)) _a.call(realCells_1);
+                  }
+                  finally { if (e_1) throw e_1.error; }
+              }
+              // 第三阶段：按路径降序排序并删除单元格
+              cellsToDelete.sort(function (a, b) {
+                  for (var i = 0; i < Math.min(a.length, b.length); i += 1) {
+                      if (a[i] !== b[i]) {
+                          return b[i] - a[i]; // 降序
+                      }
+                  }
+                  return b.length - a.length;
+              });
+              try {
+                  // 删除单元格并移动内容
+                  for (var cellsToDelete_1 = __values(cellsToDelete), cellsToDelete_1_1 = cellsToDelete_1.next(); !cellsToDelete_1_1.done; cellsToDelete_1_1 = cellsToDelete_1.next()) {
+                      var path = cellsToDelete_1_1.value;
                       try {
-                          // prettier-ignore
-                          for (var _d = (e_1 = void 0, __values(distExports$1.Node.children(editor, path, { reverse: true }))), _e = _d.next(); !_e.done; _e = _d.next()) {
-                              var _f = __read(_e.value, 2), childPath = _f[1];
-                              distExports$1.Transforms.moveNodes(editor, {
-                                  to: distExports$1.Path.next(lastPath),
-                                  at: childPath,
-                              });
+                          // 检查节点是否仍然存在
+                          if (!distExports$1.Editor.hasPath(editor, path)) {
+                              continue;
                           }
-                      }
-                      catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                      finally {
                           try {
-                              if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                              // 移动单元格内容到基础单元格
+                              for (var _j = (e_3 = void 0, __values(distExports$1.Node.children(editor, path, { reverse: true }))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                  var _l = __read(_k.value, 2), childPath = _l[1];
+                                  distExports$1.Transforms.moveNodes(editor, {
+                                      to: distExports$1.Path.next(lastPath),
+                                      at: childPath,
+                                  });
+                              }
                           }
-                          finally { if (e_1) throw e_1.error; }
+                          catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                          finally {
+                              try {
+                                  if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                              }
+                              finally { if (e_3) throw e_3.error; }
+                          }
+                          // 删除单元格
+                          distExports$1.Transforms.removeNodes(editor, { at: path });
                       }
-                      var _g = __read(distExports$1.Editor.nodes(editor, {
-                          match: isOfType(editor, 'tr'),
-                          at: path,
-                      }), 1), _h = __read(_g[0], 2), trPath = _h[1];
-                      if (_this.needKeepCell(editor, trPath)) {
-                          distExports$1.Transforms.setNodes(editor, { hidden: true }, { at: path });
-                          continue;
+                      catch (error) {
+                          // 静默处理删除失败的情况
                       }
                   }
               }
-              distExports$1.Transforms.setNodes(editor, { rowSpan: rowSpan, colSpan: colSpan }, { at: basePath });
+              catch (e_2_1) { e_2 = { error: e_2_1 }; }
+              finally {
+                  try {
+                      if (cellsToDelete_1_1 && !cellsToDelete_1_1.done && (_b = cellsToDelete_1.return)) _b.call(cellsToDelete_1);
+                  }
+                  finally { if (e_2) throw e_2.error; }
+              }
+              // 为基础单元格设置正确的rowSpan和colSpan属性
+              distExports$1.Transforms.setNodes(editor, { rowSpan: finalRowSpan, colSpan: finalColSpan }, { at: basePath });
           });
       };
       return MergeCell;
@@ -40558,10 +40854,17 @@
           return false;
       };
       SplitCell.prototype.isDisabled = function (editor) {
+          // 查找当前选中的单元格，支持td和th两种类型
           var _a = __read(distExports$1.Editor.nodes(editor, {
-              match: isOfType(editor, 'td'),
-          }), 1), td = _a[0];
-          var _b = __read(td, 1), _c = _b[0], _d = _c.rowSpan, rowSpan = _d === void 0 ? 1 : _d, _e = _c.colSpan, colSpan = _e === void 0 ? 1 : _e;
+              match: function (n) {
+                  return DomEditor.checkNodeType(n, 'table-cell');
+              },
+          }), 1), cell = _a[0];
+          if (!cell) {
+              return true; // 如果没有找到单元格，则禁用拆分功能
+          }
+          var _b = __read(cell, 1), _c = _b[0], _d = _c.rowSpan, rowSpan = _d === void 0 ? 1 : _d, _e = _c.colSpan, colSpan = _e === void 0 ? 1 : _e;
+          // 只有当rowSpan或colSpan大于1时才能拆分
           if (rowSpan > 1 || colSpan > 1) {
               return false;
           }
@@ -40591,70 +40894,100 @@
           if (!table || !td) {
               return;
           }
-          var selection = EDITOR_TO_SELECTION.get(editor) || [];
-          // @ts-ignore
-          var matrix = filledMatrix(editor, { at: options.at });
-          // const { blocks } = DEFAULT_WITH_TABLE_OPTIONS;
+          var _b = __read(table, 1), tableNode = _b[0];
+          var hasHeader = isTableWithHeader(tableNode);
+          // 获取当前选中的单元格
+          var _c = __read(td, 2), selectedCell = _c[0], selectedCellPath = _c[1];
+          var _d = selectedCell.rowSpan, rowSpan = _d === void 0 ? 1 : _d, _e = selectedCell.colSpan, colSpan = _e === void 0 ? 1 : _e;
+          // 如果单元格未合并，无需拆分
+          if (rowSpan === 1 && colSpan === 1) {
+              return;
+          }
           distExports$1.Editor.withoutNormalizing(editor, function () {
-              for (var x = matrix.length - 1; x >= 0; x -= 1) {
-                  for (var y = matrix[x].length - 1; y >= 0; y -= 1) {
-                      var _a = __read(matrix[x][y], 2), _b = __read(_a[0], 2), path = _b[1], context = _a[1];
-                      var colSpan = context.ltr, rtl = context.rtl, rowSpan = context.btt, ttb = context.ttb;
-                      if (rtl > 1) {
-                          // get to the start of the colspan
-                          y -= rtl - 2;
-                          continue;
+              // 1. 重置当前单元格的rowSpan和colSpan
+              distExports$1.Transforms.setNodes(editor, { rowSpan: 1, colSpan: 1 }, { at: selectedCellPath });
+              // 2. 处理同行的其他列（colSpan > 1的情况）
+              // 在当前单元格后面插入 colSpan-1 个新单元格
+              for (var c = 1; c < colSpan; c += 1) {
+                  var newCell = {
+                      type: 'table-cell',
+                      children: [{ text: '' }],
+                  };
+                  // 如果在第一行且表格有表头，设置isHeader
+                  var currentRowIndex = selectedCellPath[selectedCellPath.length - 2];
+                  if (currentRowIndex === 0 && hasHeader) {
+                      newCell.isHeader = true;
+                  }
+                  // 在当前行的当前位置之后插入
+                  var currentRowPath = selectedCellPath.slice(0, -1);
+                  var insertIndex = selectedCellPath[selectedCellPath.length - 1] + c;
+                  var insertPath = __spreadArray(__spreadArray([], __read(currentRowPath), false), [insertIndex], false);
+                  try {
+                      distExports$1.Transforms.insertNodes(editor, newCell, { at: insertPath });
+                  }
+                  catch (error) {
+                      // 如果指定位置插入失败，在行末尾插入
+                      try {
+                          var _a = __read(distExports$1.Editor.node(editor, currentRowPath), 1), currentRow = _a[0];
+                          var cellsCount = currentRow.children.length;
+                          var fallbackPath = __spreadArray(__spreadArray([], __read(currentRowPath), false), [cellsCount], false);
+                          distExports$1.Transforms.insertNodes(editor, newCell, { at: fallbackPath });
                       }
-                      if (ttb > 1) {
-                          continue;
+                      catch (fallbackError) {
+                          console.warn("\u63D2\u5165\u540C\u884C\u5355\u5143\u683C\u5931\u8D25: ".concat(fallbackError instanceof Error ? fallbackError.message : String(fallbackError)));
                       }
-                      if (rowSpan === 1 && colSpan === 1) {
+                  }
+              }
+              // 3. 处理其他行（rowSpan > 1的情况）
+              // 在下面的每一行都插入相应数量的单元格
+              for (var r = 1; r < rowSpan; r += 1) {
+                  // 计算目标行路径
+                  var targetRowIndex = selectedCellPath[selectedCellPath.length - 2] + r;
+                  var targetRowPath = __spreadArray(__spreadArray([], __read(selectedCellPath.slice(0, -2)), false), [targetRowIndex], false);
+                  try {
+                      // 检查目标行是否存在
+                      var _b = __read(distExports$1.Editor.node(editor, targetRowPath), 1), targetRow = _b[0];
+                      if (!targetRow) {
+                          console.warn("\u76EE\u6807\u884C ".concat(targetRowIndex, " \u4E0D\u5B58\u5728"));
                           continue;
                       }
-                      var found = !!options.all;
-                      if (selection.length) {
-                          // eslint-disable-next-line no-labels
-                          outer: for (var i = 0; !options.all && i < selection.length; i += 1) {
-                              for (var j = 0; j < selection[i].length; j += 1) {
-                                  var _c = __read(selection[i][j], 1), _d = __read(_c[0], 2), tdPath = _d[1];
-                                  if (distExports$1.Path.equals(tdPath, path)) {
-                                      found = true;
-                                      // eslint-disable-next-line no-labels
-                                      break outer;
-                                  }
+                      // 在目标行中插入colSpan个新单元格
+                      for (var c = 0; c < colSpan; c += 1) {
+                          var newCell = {
+                              type: 'table-cell',
+                              children: [{ text: '' }],
+                          };
+                          // 计算插入位置
+                          var originalColumnIndex = selectedCellPath[selectedCellPath.length - 1];
+                          var insertIndex = originalColumnIndex + c;
+                          var insertPath = __spreadArray(__spreadArray([], __read(targetRowPath), false), [insertIndex], false);
+                          try {
+                              // 获取目标行当前的单元格数量
+                              var currentCellsCount = targetRow.children.length;
+                              // 如果插入位置超出当前行的范围，在行末尾插入
+                              if (insertIndex >= currentCellsCount) {
+                                  var endPath = __spreadArray(__spreadArray([], __read(targetRowPath), false), [currentCellsCount], false);
+                                  distExports$1.Transforms.insertNodes(editor, newCell, { at: endPath });
+                              }
+                              else {
+                                  distExports$1.Transforms.insertNodes(editor, newCell, { at: insertPath });
                               }
                           }
-                      }
-                      else {
-                          var _e = __read(td, 2), tdPath = _e[1];
-                          if (distExports$1.Path.equals(tdPath, path)) {
-                              found = true;
-                          }
-                      }
-                      if (!found) {
-                          continue;
-                      }
-                      // eslint-disable-next-line no-labels
-                      out: for (var r = 1; r < rowSpan; r += 1) {
-                          for (var i = y; i >= 0; i -= 1) {
-                              // eslint-disable-next-line @typescript-eslint/no-shadow
-                              var _f = __read(matrix[x + r][i], 2), ttb_1 = _f[1].ttb;
-                              if (ttb_1 === 1) {
-                                  continue;
+                          catch (insertError) {
+                              // 最后的备用方案：在行末尾插入
+                              try {
+                                  var updatedCellsCount = targetRow.children.length;
+                                  var fallbackPath = __spreadArray(__spreadArray([], __read(targetRowPath), false), [updatedCellsCount], false);
+                                  distExports$1.Transforms.insertNodes(editor, newCell, { at: fallbackPath });
                               }
-                              for (var c = 0; c < colSpan; c += 1) {
-                                  var _g = __read(matrix[x + r][i + c], 1), _h = __read(_g[0], 2), nextPath = _h[1];
-                                  distExports$1.Transforms.unsetNodes(editor, ['hidden', 'colSpan', 'rowSpan'], { at: nextPath });
+                              catch (finalError) {
+                                  console.warn("\u63D2\u5165\u5355\u5143\u683C\u5230\u7B2C".concat(r, "\u884C\u5931\u8D25: ").concat(finalError instanceof Error ? finalError.message : String(finalError)));
                               }
-                              // eslint-disable-next-line no-labels
-                              continue out;
                           }
                       }
-                      for (var c = 1; c < colSpan; c += 1) {
-                          var _j = __read(matrix[x][y + c], 1), _k = __read(_j[0], 2), nextPath = _k[1];
-                          distExports$1.Transforms.unsetNodes(editor, ['hidden', 'colSpan', 'rowSpan'], { at: nextPath });
-                      }
-                      distExports$1.Transforms.setNodes(editor, { rowSpan: 1, colSpan: 1 }, { at: path });
+                  }
+                  catch (rowError) {
+                      console.warn("\u5904\u7406\u7B2C".concat(r, "\u884C\u65F6\u51FA\u9519: ").concat(rowError instanceof Error ? rowError.message : String(rowError)));
                   }
               }
           });
@@ -40845,26 +41178,11 @@
           // 确保是 table-cell 类型
           if (DomEditor.getNodeType(child) === 'table-cell') {
               var tableCell = child;
-              var colSpan = tableCell.colSpan || 1;
-              tableCellChildren.push(tableCell); // 先添加当前单元格
-              // 如果 colSpan > 1，检查是否存在足够的隐藏 table-cell
-              for (var j = 1; j < colSpan; j += 1) {
-                  var nextChild = children[i + j];
-                  if (nextChild
-                      && DomEditor.getNodeType(nextChild) === 'table-cell'
-                      && nextChild.hidden) {
-                      // 已有隐藏的 table-cell，无需补充
-                      continue;
-                  }
-                  else {
-                      // 补齐缺少的隐藏 table-cell
-                      tableCellChildren.push({
-                          type: 'table-cell',
-                          children: [{ text: '' }],
-                          hidden: true,
-                      });
-                  }
+              // 如果是隐藏的单元格，则跳过（删除）
+              if (tableCell.hidden) {
+                  continue;
               }
+              tableCellChildren.push(tableCell); // 只添加非隐藏的单元格
           }
       }
       return {
@@ -40981,13 +41299,21 @@
               TableCursor.unselect(editor);
               return apply(op);
           }
+          var isTableCell = function (n) {
+              return distExports$1.Element.isElement(n)
+                  && (n.type === 'table-cell'
+                      || n.type === 'th'
+                      || n.type === 'td');
+          };
           var _a = __read(distExports$1.Editor.nodes(editor, {
-              match: isOfType(editor, 'th', 'td'),
+              match: isTableCell,
               at: distExports$1.Range.start(selection),
+              mode: 'lowest', // 确保找到最低层的匹配节点
           }), 1), fromEntry = _a[0];
           var _b = __read(distExports$1.Editor.nodes(editor, {
-              match: isOfType(editor, 'th', 'td'),
+              match: isTableCell,
               at: distExports$1.Range.end(selection),
+              mode: 'lowest', // 确保找到最低层的匹配节点
           }), 1), toEntry = _b[0];
           if (!fromEntry || !toEntry) {
               TableCursor.unselect(editor);
@@ -41000,58 +41326,104 @@
               return apply(op);
           }
           // TODO: perf: could be improved by passing a Span [fromPath, toPath]
-          var filled = filledMatrix(editor, { at: fromPath });
-          // find initial bounds
-          var from = Point.valueOf(0, 0);
-          var to = Point.valueOf(0, 0);
-          for (var x = 0; x < filled.length; x += 1) {
-              for (var y = 0; y < filled[x].length; y += 1) {
-                  var _e = __read(filled[x][y], 1), _f = __read(_e[0], 2), path = _f[1];
-                  if (distExports$1.Path.equals(fromPath, path)) {
-                      from.x = x;
-                      from.y = y;
+          try {
+              var filled = filledMatrix(editor, { at: fromPath });
+              // 基本的有效性检查
+              if (!filled || filled.length === 0) {
+                  TableCursor.unselect(editor);
+                  return apply(op);
+              }
+              // find initial bounds
+              var from = Point.valueOf(0, 0);
+              var to = Point.valueOf(0, 0);
+              var fromFound = false;
+              var toFound = false;
+              for (var x = 0; x < filled.length; x += 1) {
+                  if (!filled[x]) {
+                      continue;
+                  } // 跳过空行
+                  for (var y = 0; y < filled[x].length; y += 1) {
+                      if (!filled[x][y]) {
+                          continue;
+                      } // 跳过空单元格
+                      var _e = __read(filled[x][y], 1), _f = __read(_e[0], 2), path = _f[1];
+                      if (distExports$1.Path.equals(fromPath, path)) {
+                          from.x = x;
+                          from.y = y;
+                          fromFound = true;
+                      }
+                      if (distExports$1.Path.equals(toPath, path)) {
+                          to.x = x;
+                          to.y = y;
+                          toFound = true;
+                      }
+                  }
+              }
+              // 如果找不到位置，可能是选择了被删除的单元格区域
+              if (!fromFound || !toFound) {
+                  TableCursor.unselect(editor);
+                  return apply(op);
+              }
+              var start = Point.valueOf(Math.min(from.x, to.x), Math.min(from.y, to.y));
+              var end = Point.valueOf(Math.max(from.x, to.x), Math.max(from.y, to.y));
+              // expand the selection based on rowspan and colspan
+              for (;;) {
+                  var nextStart = Point.valueOf(start.x, start.y);
+                  var nextEnd = Point.valueOf(end.x, end.y);
+                  for (var x = nextStart.x; x <= nextEnd.x && x < filled.length; x += 1) {
+                      if (!filled[x]) {
+                          continue;
+                      }
+                      for (var y = nextStart.y; y <= nextEnd.y && y < filled[x].length; y += 1) {
+                          if (!filled[x][y]) {
+                              continue;
+                          }
+                          var _g = __read(filled[x][y], 2), context = _g[1];
+                          if (!context) {
+                              continue;
+                          }
+                          var rtl = context.rtl, ltr = context.ltr, btt = context.btt, ttb = context.ttb;
+                          nextStart.x = Math.min(nextStart.x, x - (ttb - 1));
+                          nextStart.y = Math.min(nextStart.y, y - (rtl - 1));
+                          nextEnd.x = Math.max(nextEnd.x, x + (btt - 1));
+                          nextEnd.y = Math.max(nextEnd.y, y + (ltr - 1));
+                      }
                   }
-                  if (distExports$1.Path.equals(toPath, path)) {
-                      to.x = x;
-                      to.y = y;
+                  if (Point.equals(start, nextStart) && Point.equals(end, nextEnd)) {
                       break;
                   }
+                  start = nextStart;
+                  end = nextEnd;
               }
-          }
-          var start = Point.valueOf(Math.min(from.x, to.x), Math.min(from.y, to.y));
-          var end = Point.valueOf(Math.max(from.x, to.x), Math.max(from.y, to.y));
-          // expand the selection based on rowspan and colspan
-          for (;;) {
-              var nextStart = Point.valueOf(start.x, start.y);
-              var nextEnd = Point.valueOf(end.x, end.y);
-              for (var x = nextStart.x; x <= nextEnd.x; x += 1) {
-                  for (var y = nextStart.y; y <= nextEnd.y; y += 1) {
-                      var _g = __read(filled[x][y], 2), _h = _g[1], rtl = _h.rtl, ltr = _h.ltr, btt = _h.btt, ttb = _h.ttb;
-                      nextStart.x = Math.min(nextStart.x, x - (ttb - 1));
-                      nextStart.y = Math.min(nextStart.y, y - (rtl - 1));
-                      nextEnd.x = Math.max(nextEnd.x, x + (btt - 1));
-                      nextEnd.y = Math.max(nextEnd.y, y + (ltr - 1));
+              var selected = [];
+              var selectedSet = new WeakSet();
+              for (var x = start.x; x <= end.x && x < filled.length; x += 1) {
+                  if (!filled[x]) {
+                      continue;
+                  }
+                  var cells = [];
+                  for (var y = start.y; y <= end.y && y < filled[x].length; y += 1) {
+                      if (!filled[x][y]) {
+                          continue;
+                      }
+                      var _h = __read(filled[x][y], 1), _j = __read(_h[0], 1), element = _j[0];
+                      if (!element) {
+                          continue;
+                      }
+                      selectedSet.add(element);
+                      cells.push(filled[x][y]);
+                  }
+                  if (cells.length > 0) {
+                      selected.push(cells);
                   }
               }
-              if (Point.equals(start, nextStart) && Point.equals(end, nextEnd)) {
-                  break;
-              }
-              start = nextStart;
-              end = nextEnd;
+              EDITOR_TO_SELECTION.set(editor, selected);
+              EDITOR_TO_SELECTION_SET.set(editor, selectedSet);
           }
-          var selected = [];
-          var selectedSet = new WeakSet();
-          for (var x = start.x; x <= end.x; x += 1) {
-              var cells = [];
-              for (var y = start.y; y <= end.y; y += 1) {
-                  var _j = __read(filled[x][y], 1), _k = __read(_j[0], 1), element = _k[0];
-                  selectedSet.add(element);
-                  cells.push(filled[x][y]);
-              }
-              selected.push(cells);
+          catch (error) {
+              TableCursor.unselect(editor);
+              return apply(op);
           }
-          EDITOR_TO_SELECTION.set(editor, selected);
-          EDITOR_TO_SELECTION_SET.set(editor, selectedSet);
           apply(op);
       };
       return editor;
@@ -41487,7 +41859,7 @@
    * @author wangfupeng
    */
   /**
-   * pre-prase table ，去掉 <tbody>
+   * pre-prase table ，去掉 <tbody> 和处理单元格中的 <p> 标签，以及删除隐藏的单元格
    * @param table table elem
    */
   function preParse$1(tableElem) {
@@ -41505,6 +41877,42 @@
       var $tr = $table.find('tr');
       $table.append($tr);
       $tbody.remove();
+      // 删除带有 style="display:none" 的单元格（通常来自复制的隐藏内容）
+      var $allCells = $table.find('td, th');
+      for (var i = 0; i < $allCells.length; i += 1) {
+          var cell = $allCells[i];
+          var $cell = $$1(cell);
+          var styleAttr = $cell.attr('style');
+          // 检查style属性是否包含display:none或display: none
+          if (styleAttr) {
+              // 使用正则表达式匹配display:none，支持空格变化
+              var displayNoneRegex = /display\s*:\s*none/i;
+              if (displayNoneRegex.test(styleAttr)) {
+                  $cell.remove();
+              }
+          }
+      }
+      // 处理表格单元格中的 <p> 标签（通常来自Word复制）
+      var $cells = $table.find('td, th');
+      for (var i = 0; i < $cells.length; i += 1) {
+          var cell = $cells[i];
+          var $cell = $$1(cell);
+          // 直接处理单元格中的所有 <p> 标签
+          var cellHtml = $cell.html() || '';
+          // 先清理Word特殊标签
+          cellHtml = cellHtml.replace(/<o:p[^>]*>[\s\S]*?<\/o:p>/gi, ''); // 删除 <o:p> 标签
+          cellHtml = cellHtml.replace(/<\/o:p>/gi, ''); // 删除可能的自闭合标签
+          // 一次性处理所有p标签
+          cellHtml = cellHtml.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, function (match, content) {
+              // 处理空内容或只包含空白字符的情况
+              var trimmedContent = content.trim();
+              if (!trimmedContent || trimmedContent === '&nbsp;') {
+                  return ''; // 删除空的p标签
+              }
+              return content; // 返回p标签的内容
+          });
+          $cell.html(cellHtml);
+      }
       return $table[0];
   }
   var preParseTableHtmlConf = {
@@ -41650,6 +42058,117 @@
       $window.on('mouseup', onMouseUp);
   }
   $window.on('mousedown', onMouseDown);
+  /**
+   * 计算等比例调整所有列宽度（用于最右侧列拖动）
+   */
+  function calculateProportionalWidths(columnWidths, resizingIndex, newRightmostWidth) {
+      var currentTotalWidth = columnWidths.reduce(function (a, b) { return a + b; }, 0);
+      var currentRightmostWidth = columnWidths[resizingIndex];
+      // 确保最右侧列不小于最小宽度
+      var actualNewRightmostWidth = Math.max(10, newRightmostWidth);
+      // 计算新的总宽度
+      var newTotalWidth = currentTotalWidth - currentRightmostWidth + actualNewRightmostWidth;
+      // 如果新总宽度太小，则设置最小总宽度
+      var minTotalWidth = columnWidths.length * 10; // 每列至少10px
+      if (newTotalWidth < minTotalWidth) {
+          // 如果新总宽度小于最小值，则所有列都设为最小宽度
+          return columnWidths.map(function () { return 10; });
+      }
+      // 计算其他列的总宽度
+      var otherColumnsCurrentWidth = currentTotalWidth - currentRightmostWidth;
+      var otherColumnsNewWidth = newTotalWidth - actualNewRightmostWidth;
+      // 如果其他列需要的总宽度为0或负数，则只保留最右侧列
+      if (otherColumnsNewWidth <= 0) {
+          var result = columnWidths.map(function () { return 10; });
+          result[resizingIndex] = Math.max(10, newTotalWidth - (columnWidths.length - 1) * 10);
+          return result;
+      }
+      // 计算其他列的缩放比例
+      var otherColumnsScaleFactor = otherColumnsCurrentWidth > 0 ? otherColumnsNewWidth / otherColumnsCurrentWidth : 1;
+      // 调整所有列宽度
+      var newWidths = columnWidths.map(function (width, index) {
+          if (index === resizingIndex) {
+              // 最右侧列直接使用新宽度
+              return Math.floor(actualNewRightmostWidth * 100) / 100;
+          }
+          // 其他列按比例调整
+          var newWidth = width * otherColumnsScaleFactor;
+          return Math.max(10, Math.floor(newWidth * 100) / 100);
+      });
+      // 由于最小宽度限制，可能导致总宽度偏差，需要微调最右侧列
+      var actualTotalWidth = newWidths.reduce(function (a, b) { return a + b; }, 0);
+      var widthDifference = newTotalWidth - actualTotalWidth;
+      if (Math.abs(widthDifference) > 0.01) {
+          newWidths[resizingIndex] = Math.max(10, newWidths[resizingIndex] + widthDifference);
+      }
+      return newWidths;
+  }
+  /**
+   * 计算相邻列宽度调整（用于中间列拖动）
+   */
+  function calculateAdjacentWidths(columnWidths, resizingIndex, widthChange) {
+      var newWidths = __spreadArray([], __read(columnWidths), false);
+      // 找到右侧的相邻列进行调整
+      var adjacentIndex = resizingIndex + 1;
+      if (adjacentIndex >= newWidths.length) {
+          // 如果没有右侧相邻列，则不进行调整
+          return newWidths;
+      }
+      var leftColumnWidth = newWidths[resizingIndex];
+      var rightColumnWidth = newWidths[adjacentIndex];
+      // 计算边界可以移动的范围
+      var minLeftWidth = 10;
+      var minRightWidth = 10;
+      var maxLeftWidth = leftColumnWidth + rightColumnWidth - minRightWidth;
+      // 计算新的左列宽度（边界直接跟随鼠标）
+      var newLeftWidth = leftColumnWidth + widthChange;
+      // 限制左列宽度在允许范围内
+      newLeftWidth = Math.max(minLeftWidth, Math.min(maxLeftWidth, newLeftWidth));
+      // 计算新的右列宽度（确保总宽度不变）
+      var newRightWidth = leftColumnWidth + rightColumnWidth - newLeftWidth;
+      // 应用新宽度
+      newWidths[resizingIndex] = Math.floor(newLeftWidth * 100) / 100;
+      newWidths[adjacentIndex] = Math.floor(newRightWidth * 100) / 100;
+      return newWidths;
+  }
+  /**
+   * 根据鼠标位置计算列宽度
+   * @param columnWidths 当前列宽度数组
+   * @param resizingIndex 正在调整的边界索引
+   * @param mousePositionInTable 鼠标相对于表格左边的位置
+   * @param cumulativeWidths 列宽度的累积和数组
+   * @returns 调整后的列宽度数组
+   */
+  function calculateAdjacentWidthsByBorderPosition(columnWidths, resizingIndex, mousePositionInTable, cumulativeWidths) {
+      var newWidths = __spreadArray([], __read(columnWidths), false);
+      // 检查边界范围
+      if (resizingIndex < 0 || resizingIndex >= columnWidths.length) {
+          return newWidths;
+      }
+      // 计算当前边界的左边界位置（前面所有列的宽度总和）
+      var leftBoundary = resizingIndex === 0 ? 0 : cumulativeWidths[resizingIndex - 1];
+      // 计算当前边界的右边界位置（包括当前列和下一列的宽度）
+      var rightBoundary = resizingIndex + 1 < columnWidths.length
+          ? cumulativeWidths[resizingIndex + 1]
+          : cumulativeWidths[resizingIndex];
+      // 计算允许的边界移动范围
+      var minBorderPosition = leftBoundary + 10; // 左列最小宽度
+      var maxBorderPosition = rightBoundary - 10; // 右列最小宽度
+      // 限制鼠标位置在允许范围内
+      var clampedMousePosition = Math.max(minBorderPosition, Math.min(maxBorderPosition, mousePositionInTable));
+      // 计算新的左列宽度（第resizingIndex列）
+      var newLeftWidth = clampedMousePosition - leftBoundary;
+      // 计算新的右列宽度（第resizingIndex+1列）
+      var adjacentIndex = resizingIndex + 1;
+      if (adjacentIndex < columnWidths.length) {
+          var currentTwoColumnsWidth = columnWidths[resizingIndex] + columnWidths[adjacentIndex];
+          var newRightWidth = currentTwoColumnsWidth - newLeftWidth;
+          // 应用新宽度
+          newWidths[resizingIndex] = Math.floor(newLeftWidth * 100) / 100;
+          newWidths[adjacentIndex] = Math.floor(newRightWidth * 100) / 100;
+      }
+      return newWidths;
+  }
   var onMouseMove = throttle(function (event) {
       if (!isMouseDownForResize) {
           return;
@@ -41659,28 +42178,65 @@
       }
       event.preventDefault();
       var clientX = event.clientX;
-      var newWith = cellWidthWhenMouseDown + (clientX - clientXWhenMouseDown); // 计算新宽度
-      newWith = Math.floor(newWith * 100) / 100; // 保留小数点后两位
-      if (newWith < 30) {
-          newWith = 30;
-      } // 最小宽度
+      var widthChange = clientX - clientXWhenMouseDown; // 计算宽度变化
       var _a = __read(distExports$1.Editor.nodes(editorWhenMouseDown, {
           match: isOfType(editorWhenMouseDown, 'table'),
       }), 1), _b = __read(_a[0], 1), elemNode = _b[0];
       var _c = elemNode, _d = _c.columnWidths, columnWidths = _d === void 0 ? [] : _d, _e = _c.resizingIndex, resizingIndex = _e === void 0 ? -1 : _e;
-      var cumulativeTotalWidth = columnWidths.reduce(function (a, b) { return a + b; }, 0);
-      var remainWidth = cumulativeTotalWidth - columnWidths[resizingIndex];
-      // 如果拖动引起的宽度超过容器宽度，则不调整
-      var containerElement = document.querySelector('.table-container');
-      if (containerElement && newWith > cellWidthWhenMouseDown) {
-          // 允许缩小，但不允许放大
-          if (remainWidth + newWith > containerElement.clientWidth) {
-              newWith = Math.max(30, cellWidthWhenMouseDown); // 确保不小于最小宽度
-          }
-      }
-      var adjustColumnWidths = __spreadArray([], __read(columnWidths), false).map(function (width) { return Math.floor(width); });
-      adjustColumnWidths[resizingIndex] = newWith;
-      // 这是宽度
+      var adjustColumnWidths;
+      // 判断是否为最右侧列
+      var isRightmostColumn = resizingIndex === columnWidths.length - 1;
+      if (isRightmostColumn) {
+          // 最右侧列：等比例调整所有列宽度
+          var newRightmostWidth = cellWidthWhenMouseDown + widthChange;
+          adjustColumnWidths = calculateProportionalWidths(columnWidths, resizingIndex, newRightmostWidth);
+      }
+      else {
+          // 中间列：计算边界的绝对位置
+          var tableElement = document.querySelector('.table');
+          if (tableElement) {
+              var tableRect = tableElement.getBoundingClientRect();
+              var mousePositionInTable = clientX - tableRect.left; // 鼠标相对于表格左边的位置
+              // 计算边界的新位置
+              var cumulativeWidths = getCumulativeWidths(columnWidths);
+              var newBorderPosition = mousePositionInTable;
+              // 根据新的边界位置计算列宽度
+              adjustColumnWidths = calculateAdjacentWidthsByBorderPosition(columnWidths, resizingIndex, newBorderPosition, cumulativeWidths);
+          }
+          else {
+              // 如果找不到表格元素，则使用原来的逻辑
+              adjustColumnWidths = calculateAdjacentWidths(columnWidths, resizingIndex, widthChange);
+          }
+      }
+      // 检查容器宽度限制（仅对最右侧列生效）
+      if (isRightmostColumn) {
+          var containerElement = document.querySelector('.table-container');
+          if (containerElement) {
+              var newTotalWidth = adjustColumnWidths.reduce(function (a, b) { return a + b; }, 0);
+              var minTableWidth = columnWidths.length * 10; // 最小表格宽度
+              var maxTableWidth = containerElement.clientWidth - 1; // 最大表格宽度
+              // 如果新宽度小于最小宽度，则使用最小宽度
+              if (newTotalWidth < minTableWidth) {
+                  adjustColumnWidths = columnWidths.map(function () { return 10; });
+              }
+              else if (newTotalWidth > maxTableWidth) {
+                  // 如果新宽度超过容器宽度，则限制在容器宽度内
+                  // 计算允许的最大最右侧列宽度
+                  var otherColumnsWidth = adjustColumnWidths.slice(0, -1).reduce(function (a, b) { return a + b; }, 0);
+                  var maxRightmostWidth = Math.max(10, maxTableWidth - otherColumnsWidth);
+                  // 重新计算等比例调整后的列宽度，限制在最大宽度内
+                  adjustColumnWidths = calculateProportionalWidths(columnWidths, resizingIndex, maxRightmostWidth);
+                  // 确保总宽度不超过容器宽度
+                  var finalTotalWidth = adjustColumnWidths.reduce(function (a, b) { return a + b; }, 0);
+                  if (finalTotalWidth > maxTableWidth) {
+                      // 如果仍然超过，则按比例缩小所有列
+                      var scaleFactor_1 = maxTableWidth / finalTotalWidth;
+                      adjustColumnWidths = adjustColumnWidths.map(function (width) { return Math.max(10, Math.floor(width * scaleFactor_1 * 100) / 100); });
+                  }
+              }
+          }
+      }
+      // 应用新的列宽度
       distExports$1.Transforms.setNodes(editorWhenMouseDown, { columnWidths: adjustColumnWidths }, {
           mode: 'highest',
       });