@windoc/core 0.3.20 → 0.3.22

package/dist/index.js

@@ -78,7 +78,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.ts
-var version = "0.3.20";
+var version = "0.3.22";
 
 // src/dataset/enum/Common.ts
 var MaxHeightRatio = /* @__PURE__ */ ((MaxHeightRatio2) => {
@@ -503,7 +503,7 @@ var ElementType = /* @__PURE__ */ ((ElementType2) => {
 // src/utils/ua.ts
 var isApple = typeof navigator !== "undefined" && /Mac OS X/.test(navigator.userAgent);
 var isIOS = typeof navigator !== "undefined" && /iPad|iPhone/.test(navigator.userAgent);
-var isMobile = /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+var isMobile = typeof navigator !== "undefined" && /Mobile|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
   navigator.userAgent
 );
 var isFirefox = typeof navigator !== "undefined" && /Firefox/.test(navigator.userAgent);
@@ -598,6 +598,8 @@ var TABLE_TD_ZIP_ATTR = [
   "externalId",
   "verticalAlign",
   "backgroundColor",
+  "borderColor",
+  "padding",
   "borderTypes",
   "slashTypes",
   "disabled",
@@ -5016,6 +5018,37 @@ function pickElementAttr(payload, option = {}) {
   });
   return element;
 }
+function mergeSplitTableRowsForZip(trList) {
+  for (let t = trList.length - 1; t >= 0; t--) {
+    const splitTr = trList[t];
+    if (!splitTr.splitParentId) continue;
+    const parentTrIdx = trList.findIndex(
+      (tr) => tr.id === splitTr.splitParentId
+    );
+    if (!~parentTrIdx) continue;
+    const parentTr = trList[parentTrIdx];
+    parentTr.height += splitTr.height;
+    for (let d = 0; d < parentTr.tdList.length; d++) {
+      const parentTd = parentTr.tdList[d];
+      const splitTd = splitTr.tdList[d];
+      if (!parentTd || !splitTd) continue;
+      const hasSyntheticLeadingZero = !!splitTd.splitSyntheticLeadingZero && splitTd.value[0]?.value === ZERO;
+      parentTd.value.push(
+        ...hasSyntheticLeadingZero ? splitTd.value.slice(1) : splitTd.value
+      );
+    }
+    trList.splice(t, 1);
+  }
+  for (let t = 0; t < trList.length; t++) {
+    const tr = trList[t];
+    delete tr.id;
+    delete tr.splitParentId;
+    delete tr.splitRootId;
+    delete tr.splitLevel;
+    delete tr.splitBoundaryTop;
+    delete tr.splitBoundaryBottom;
+  }
+}
 function zipElementList(payload, options = {}) {
   const { extraPickAttrs, isClassifyArea = false, isClone = true } = options;
   const elementList = isClone ? deepClone(payload) : payload;
@@ -5115,8 +5148,11 @@ function zipElementList(payload, options = {}) {
         while (tableIndex < elementList.length) {
           const nextElement = elementList[tableIndex];
           if (nextElement.pagingId === element.pagingId) {
+            const nextTrList = nextElement.trList.filter(
+              (tr) => !tr.pagingRepeat
+            );
             element.height += nextElement.height;
-            element.trList.push(...nextElement.trList);
+            element.trList.push(...nextTrList);
             tableIndex++;
             combineCount++;
           } else {
@@ -5126,9 +5162,9 @@ function zipElementList(payload, options = {}) {
         e += combineCount;
       }
       if (element.trList) {
+        mergeSplitTableRowsForZip(element.trList);
         for (let t = 0; t < element.trList.length; t++) {
           const tr = element.trList[t];
-          delete tr.id;
           for (let d = 0; d < tr.tdList.length; d++) {
             const td = tr.tdList[d];
             const zipTd = {
@@ -6828,6 +6864,57 @@ var RadioControl = class extends CheckboxControl {
   }
 };
 
+// src/core/event/handlers/splitCell.ts
+function isSameSplitCellSelection(first, second) {
+  if (!first || !second) return false;
+  return first.pagingId === second.pagingId && first.rootTrId === second.rootTrId && first.colIndex === second.colIndex;
+}
+function getSplitCellPointer(draw, position) {
+  if (!position.isTable || position.index === void 0 || position.tdIndex === void 0 || position.tdValueIndex === void 0 || !position.trId) {
+    return null;
+  }
+  const originalElementList = draw.getOriginalElementList();
+  const tableElement = originalElementList[position.index];
+  if (tableElement?.type !== "table" /* TABLE */ || !tableElement.pagingId || !tableElement.trList?.length) {
+    return null;
+  }
+  const tr = tableElement.trList.find((row) => row.id === position.trId);
+  const td = tr?.tdList[position.tdIndex];
+  if (!tr || !td || td.colIndex === void 0 || !tr.id) {
+    return null;
+  }
+  const splitCellSelection = {
+    pagingId: tableElement.pagingId,
+    rootTrId: tr.splitRootId || tr.id,
+    colIndex: td.colIndex
+  };
+  const splitCellContext = draw.getSplitCellSelectionContext(
+    originalElementList,
+    splitCellSelection
+  );
+  if (!splitCellContext) {
+    return null;
+  }
+  let globalIndex = 0;
+  for (let c = 0; c < splitCellContext.cellContextList.length; c++) {
+    const cellContext = splitCellContext.cellContextList[c];
+    const currentTd = cellContext.td;
+    const skipLeadingZero = !!currentTd.splitSyntheticLeadingZero && currentTd.value[0]?.value === ZERO ? 1 : 0;
+    if (cellContext.tr.id === tr.id && currentTd.id === td.id) {
+      globalIndex += Math.max(position.tdValueIndex - skipLeadingZero, 0);
+      return {
+        splitCellSelection,
+        globalIndex
+      };
+    }
+    globalIndex += Math.max(currentTd.value.length - skipLeadingZero, 0);
+  }
+  return null;
+}
+function isSameSplitCellPointer(first, second) {
+  return isSameSplitCellSelection(first, second);
+}
+
 // src/core/event/handlers/mousedown.ts
 function setRangeCache(host) {
   const draw = host.getDraw();
@@ -6915,9 +7002,11 @@ function mousedown(evt, host) {
     tdValueIndex,
     hitLineStartIndex
   } = positionResult;
+  const splitCellPointer = getSplitCellPointer(draw, positionResult);
   host.mouseDownStartPosition = {
     ...positionResult,
-    index: isTable ? tdValueIndex : index,
+    index: splitCellPointer ? splitCellPointer.globalIndex : isTable ? tdValueIndex : index,
+    splitCellSelection: splitCellPointer?.splitCellSelection,
     x: evt.offsetX,
     y: evt.offsetY
   };
@@ -7357,10 +7446,33 @@ function mousemove(evt, host) {
     isTable: startIsTable,
     tdIndex: startTdIndex,
     trIndex: startTrIndex,
-    tableId: startTableId
+    tableId: startTableId,
+    splitCellSelection: startSplitCellSelection
   } = host.mouseDownStartPosition;
   const endIndex = isTable ? tdValueIndex : index;
   const rangeManager = draw.getRange();
+  if (startSplitCellSelection) {
+    const currentSplitCellPointer = getSplitCellPointer(draw, positionResult);
+    if (currentSplitCellPointer && isSameSplitCellPointer(
+      startSplitCellSelection,
+      currentSplitCellPointer.splitCellSelection
+    )) {
+      let start = startIndex;
+      let end = currentSplitCellPointer.globalIndex;
+      if (start > end) {
+        [start, end] = [end, start];
+      }
+      if (start === end) return;
+      rangeManager.setRange(start, end);
+      rangeManager.setSplitCellSelection(startSplitCellSelection);
+      draw.render({
+        isSubmitHistory: false,
+        isSetCursor: false,
+        isCompute: false
+      });
+      return;
+    }
+  }
   if (isTable && startIsTable && (tdIndex !== startTdIndex || trIndex !== startTrIndex)) {
     rangeManager.setRange(
       endIndex,
@@ -7403,6 +7515,71 @@ function mousemove(evt, host) {
   });
 }
 
+// src/core/event/handlers/keydown/tableSplit.ts
+function moveEmptySplitTdCursorToParent(host) {
+  const draw = host.getDraw();
+  const position = draw.getPosition();
+  const positionContext = position.getPositionContext();
+  const cursorPosition = position.getCursorPosition();
+  if (!positionContext.isTable || !cursorPosition || cursorPosition.index !== 0) {
+    return null;
+  }
+  const elementList = draw.getOriginalElementList();
+  const resolved = draw.resolveTableCellContext(elementList, positionContext);
+  if (!resolved) return null;
+  const currentTr = resolved.element.trList?.[resolved.trIndex];
+  const currentTd = resolved.td;
+  if (!currentTr?.splitParentId || currentTd.value.length !== 1 || currentTd.value[0]?.value !== ZERO) {
+    return null;
+  }
+  const pagingId = resolved.element.pagingId;
+  if (!pagingId) return null;
+  let parentTarget;
+  for (let i = resolved.index; i >= 0; i--) {
+    const tableElement = elementList[i];
+    if (tableElement.type !== "table" /* TABLE */) continue;
+    if (tableElement.pagingId !== pagingId) {
+      if (i < resolved.index) break;
+      continue;
+    }
+    const parentTrIndex = tableElement.trList?.findIndex((tr) => tr.id === currentTr.splitParentId) ?? -1;
+    if (parentTrIndex < 0) continue;
+    const parentTr2 = tableElement.trList[parentTrIndex];
+    const parentTdIndex = parentTr2.tdList.findIndex(
+      (td) => td.colIndex === currentTd.colIndex
+    );
+    if (parentTdIndex < 0) return null;
+    parentTarget = {
+      tableId: tableElement.id,
+      tableIndex: i,
+      trIndex: parentTrIndex,
+      tdIndex: parentTdIndex
+    };
+    break;
+  }
+  if (!parentTarget) return null;
+  const parentElement = elementList[parentTarget.tableIndex];
+  const parentTr = parentElement.trList[parentTarget.trIndex];
+  const parentTd = parentTr.tdList[parentTarget.tdIndex];
+  if (!currentTd.splitSyntheticLeadingZero) {
+    currentTd.value.splice(0, 1);
+    currentTd.rowList = void 0;
+    currentTd.positionList = void 0;
+  }
+  const curIndex = Math.max(parentTd.value.length - 1, 0);
+  position.setPositionContext({
+    isTable: true,
+    index: parentTarget.tableIndex,
+    trIndex: parentTarget.trIndex,
+    tdIndex: parentTarget.tdIndex,
+    tdId: parentTd.id,
+    trId: parentTr.id,
+    tableId: parentTarget.tableId
+  });
+  draw.getRange().setRange(curIndex, curIndex);
+  return curIndex;
+}
+
 // src/core/event/handlers/keydown/backspace.ts
 function backspaceHideElement(host) {
   const draw = host.getDraw();
@@ -7444,13 +7621,27 @@ function backspace(evt, host) {
   if (draw.isReadonly()) return;
   const rangeManager = draw.getRange();
   if (!rangeManager.getIsCanInput()) return;
+  if (rangeManager.getIsCollapsed()) {
+    const splitParentIndex = moveEmptySplitTdCursorToParent(host);
+    if (splitParentIndex !== null) {
+      draw.getGlobalEvent().setCanvasEventAbility();
+      draw.render({
+        curIndex: splitParentIndex,
+        isSubmitHistory: false
+      });
+      evt.preventDefault();
+      return;
+    }
+  }
   if (rangeManager.getIsCollapsed()) {
     backspaceHideElement(host);
   }
   const control = draw.getControl();
   const { startIndex, endIndex, isCrossRowCol } = rangeManager.getRange();
   let curIndex;
-  if (isCrossRowCol) {
+  if (rangeManager.getSplitCellSelection() && startIndex !== endIndex) {
+    curIndex = draw.replaceSplitCellSelection([]);
+  } else if (isCrossRowCol) {
     const rowCol = draw.getTableParticle().getRangeRowCol();
     if (!rowCol) return;
     let isDeleted = false;
@@ -7589,6 +7780,18 @@ function del(evt, host) {
   if (draw.isReadonly()) return;
   const rangeManager = draw.getRange();
   if (!rangeManager.getIsCanInput()) return;
+  if (rangeManager.getIsCollapsed()) {
+    const splitParentIndex = moveEmptySplitTdCursorToParent(host);
+    if (splitParentIndex !== null) {
+      draw.getGlobalEvent().setCanvasEventAbility();
+      draw.render({
+        curIndex: splitParentIndex,
+        isSubmitHistory: false
+      });
+      evt.preventDefault();
+      return;
+    }
+  }
   const { startIndex, endIndex, isCrossRowCol } = rangeManager.getRange();
   const elementList = draw.getElementList();
   const control = draw.getControl();
@@ -7596,7 +7799,9 @@ function del(evt, host) {
     deleteHideElement(host);
   }
   let curIndex;
-  if (isCrossRowCol) {
+  if (rangeManager.getSplitCellSelection() && startIndex !== endIndex) {
+    curIndex = draw.replaceSplitCellSelection([]);
+  } else if (isCrossRowCol) {
     const rowCol = draw.getTableParticle().getRangeRowCol();
     if (!rowCol) return;
     let isDeleted = false;
@@ -8508,6 +8713,8 @@ function input(data2, host) {
     if (!isComposing) {
       control.emitControlContentChange();
     }
+  } else if (rangeManager.getSplitCellSelection()) {
+    curIndex = draw.replaceSplitCellSelection(inputData);
   } else {
     const start = startIndex + 1;
     if (startIndex !== endIndex) {
@@ -9007,7 +9214,7 @@ var CanvasEvent = class {
   }
   selectAll() {
     if (this.position.getPositionContext().isTable) {
-      this.draw.getTableOperate().tableSelectAll();
+      this.draw.getTableOperate().tableTdSelectAll();
     } else {
       const positionList = this.position.getPositionList();
       this.range.setRange(0, positionList.length - 1);
@@ -9284,8 +9491,11 @@ var Position = class {
     return this.floatPositionList;
   }
   getTablePositionList(sourceElementList) {
-    const { index, trIndex, tdIndex } = this.positionContext;
-    return sourceElementList[index].trList[trIndex].tdList[tdIndex].positionList || [];
+    const splitCellSelectionContext = this.draw.getSplitCellSelectionContext(sourceElementList);
+    if (splitCellSelectionContext) {
+      return splitCellSelectionContext.positionList;
+    }
+    return this.draw.resolveTableCellContext(sourceElementList, this.positionContext)?.td.positionList || [];
   }
   getPositionList() {
     return this.positionContext.isTable ? this.getTablePositionList(this.draw.getOriginalElementList()) : this.getOriginalPositionList();
@@ -9939,6 +10149,46 @@ var Position = class {
         positionResult.index = newIndex;
       }
     }
+    if (positionResult.isTable && positionResult.trId != null) {
+      const elementList = this.draw.getOriginalMainElementList();
+      const tableElement = elementList[positionResult.index];
+      if (tableElement?.trList) {
+        const matchedTr = tableElement.trList.find(
+          (r) => r.id === positionResult.trId
+        );
+        if (matchedTr?.splitRootId) {
+          const matchedTd = matchedTr.tdList[positionResult.tdIndex];
+          if (matchedTd && matchedTd.splitSyntheticLeadingZero && matchedTd.value.length === 1 && matchedTd.value[0].value === ZERO) {
+            const pagingId = tableElement.pagingId;
+            if (pagingId) {
+              for (let i = positionResult.index - 1; i >= 0; i--) {
+                const prevElement = elementList[i];
+                if (prevElement.pagingId !== pagingId) break;
+                const rootTr = prevElement.trList?.find(
+                  (r) => r.id === matchedTr.splitRootId
+                );
+                if (rootTr) {
+                  const rootTd = rootTr.tdList.find(
+                    (t) => t.colIndex === matchedTd.colIndex
+                  );
+                  const isRootTdEmpty = !!rootTd && rootTd.value.length === 1 && rootTd.value[0].value === ZERO;
+                  if (rootTd && isRootTdEmpty) {
+                    positionResult.index = i;
+                    positionResult.trIndex = prevElement.trList.indexOf(rootTr);
+                    positionResult.tdIndex = rootTr.tdList.indexOf(rootTd);
+                    positionResult.trId = rootTr.id;
+                    positionResult.tdId = rootTd.id;
+                    positionResult.tableId = prevElement.id;
+                    positionResult.tdValueIndex = 0;
+                  }
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
     const {
       index,
       isCheckbox,
@@ -10035,6 +10285,18 @@ var RangeManager = class {
   clearRange() {
     this.setRange(-1, -1);
   }
+  getSplitCellSelection() {
+    return this.range.splitCellSelection;
+  }
+  setSplitCellSelection(payload) {
+    this.range.splitCellSelection = payload || void 0;
+  }
+  getTableCellSelection() {
+    return this.range.tableCellSelection;
+  }
+  setTableCellSelection(payload) {
+    this.range.tableCellSelection = payload || void 0;
+  }
   setDefaultStyle(style) {
     if (!style) {
       this.defaultStyle = null;
@@ -10325,6 +10587,8 @@ var RangeManager = class {
       this.range.isCrossRowCol = !!(startTdIndex || endTdIndex || startTrIndex || endTrIndex);
       this.setDefaultStyle(null);
     }
+    this.range.splitCellSelection = void 0;
+    this.range.tableCellSelection = void 0;
     this.range.zone = this.draw.getZone().getZone();
     const control = this.draw.getControl();
     if (~startIndex && ~endIndex) {
@@ -11655,13 +11919,18 @@ var TableParticle = class {
     ctx.beginPath();
     const x = Math.round(startX);
     const y = Math.round(startY);
+    const rx = Math.round(startX + width);
+    const ry = Math.round(startY + height);
     ctx.translate(0.5, 0.5);
     if (isDrawFullBorder) {
-      ctx.rect(x, y, width, height);
+      ctx.rect(x, y, rx - x, ry - y);
+    } else if (borderExternalWidth) {
+      ctx.moveTo(x, ry);
+      ctx.lineTo(x, y);
+      ctx.lineTo(rx, y);
     } else {
-      ctx.moveTo(x, y + height);
+      ctx.moveTo(x, ry);
       ctx.lineTo(x, y);
-      ctx.lineTo(x + width, y);
     }
     ctx.stroke();
     if (borderExternalWidth) {
@@ -11669,20 +11938,32 @@ var TableParticle = class {
     }
     ctx.translate(-0.5, -0.5);
   }
+  _drawHorizontalBorder(payload) {
+    const { ctx, startX, endX, y } = payload;
+    const x = Math.round(startX);
+    const rx = Math.round(endX);
+    const ty = Math.round(y);
+    ctx.beginPath();
+    ctx.translate(0.5, 0.5);
+    ctx.moveTo(x, ty);
+    ctx.lineTo(rx, ty);
+    ctx.stroke();
+    ctx.translate(-0.5, -0.5);
+  }
   _drawSlash(ctx, td, startX, startY) {
     const { scale } = this.options;
     ctx.save();
-    const width = td.width * scale;
-    const height = td.height * scale;
-    const x = Math.round(td.x * scale + startX);
-    const y = Math.round(td.y * scale + startY);
+    const lx = Math.round(td.x * scale + startX);
+    const ty = Math.round(td.y * scale + startY);
+    const rx = Math.round((td.x + td.width) * scale + startX);
+    const by = Math.round((td.y + td.height) * scale + startY);
     if (td.slashTypes?.includes("forward" /* FORWARD */)) {
-      ctx.moveTo(x + width, y);
-      ctx.lineTo(x, y + height);
+      ctx.moveTo(rx, ty);
+      ctx.lineTo(lx, by);
     }
     if (td.slashTypes?.includes("back" /* BACK */)) {
-      ctx.moveTo(x, y);
-      ctx.lineTo(x + width, y + height);
+      ctx.moveTo(lx, ty);
+      ctx.lineTo(rx, by);
     }
     ctx.stroke();
     ctx.restore();
@@ -11723,6 +12004,8 @@ var TableParticle = class {
         isDrawFullBorder: isExternalBorderType
       });
     }
+    const firstTr = trList[0];
+    const lastTr = trList[trList.length - 1];
     for (let t = 0; t < trList.length; t++) {
       const tr = trList[t];
       for (let d = 0; d < tr.tdList.length; d++) {
@@ -11733,10 +12016,10 @@ var TableParticle = class {
         if (!td.borderTypes?.length && (isEmptyBorderType || isExternalBorderType)) {
           continue;
         }
-        const width = td.width * scale;
-        const height = td.height * scale;
-        const x = Math.round(td.x * scale + startX + width);
-        const y = Math.round(td.y * scale + startY);
+        const lx = Math.round(td.x * scale + startX);
+        const ty = Math.round(td.y * scale + startY);
+        const rx = Math.round((td.x + td.width) * scale + startX);
+        const by = Math.round((td.y + td.height) * scale + startY);
         if (td.borderColor) {
           ctx.save();
           ctx.strokeStyle = td.borderColor;
@@ -11744,29 +12027,33 @@ var TableParticle = class {
         ctx.translate(0.5, 0.5);
         ctx.beginPath();
         if (td.borderTypes?.includes("top" /* TOP */)) {
-          ctx.moveTo(x - width, y);
-          ctx.lineTo(x, y);
+          ctx.moveTo(lx, ty);
+          ctx.lineTo(rx, ty);
           ctx.stroke();
         }
         if (td.borderTypes?.includes("right" /* RIGHT */)) {
-          ctx.moveTo(x, y);
-          ctx.lineTo(x, y + height);
+          ctx.moveTo(rx, ty);
+          ctx.lineTo(rx, by);
           ctx.stroke();
         }
         if (td.borderTypes?.includes("bottom" /* BOTTOM */)) {
-          ctx.moveTo(x, y + height);
-          ctx.lineTo(x - width, y + height);
+          ctx.moveTo(rx, by);
+          ctx.lineTo(lx, by);
           ctx.stroke();
         }
         if (td.borderTypes?.includes("left" /* LEFT */)) {
-          ctx.moveTo(x - width, y);
-          ctx.lineTo(x - width, y + height);
+          ctx.moveTo(lx, ty);
+          ctx.lineTo(lx, by);
           ctx.stroke();
         }
         if (!isEmptyBorderType && !isExternalBorderType) {
+          if (td.rowIndex === 0 && !borderExternalWidth) {
+            ctx.moveTo(lx, ty);
+            ctx.lineTo(rx, ty);
+          }
           if (!isInternalBorderType || td.colIndex + td.colspan < colgroup.length) {
-            ctx.moveTo(x, y);
-            ctx.lineTo(x, y + height);
+            ctx.moveTo(rx, ty);
+            ctx.lineTo(rx, by);
             if (borderExternalWidth && borderExternalWidth !== borderWidth && td.colIndex + td.colspan === colgroup.length) {
               const lineWidth = ctx.lineWidth;
               ctx.lineWidth = borderExternalWidth * scale;
@@ -11776,13 +12063,14 @@ var TableParticle = class {
             }
           }
           if (!isInternalBorderType || td.rowIndex + td.rowspan < trList.length) {
-            const isSetExternalBottomBorder = borderExternalWidth && borderExternalWidth !== borderWidth && td.rowIndex + td.rowspan === trList.length;
+            const isBottomEdge = td.rowIndex + td.rowspan === trList.length;
+            const isSetExternalBottomBorder = borderExternalWidth && borderExternalWidth !== borderWidth && isBottomEdge;
             if (isSetExternalBottomBorder) {
               ctx.stroke();
               ctx.beginPath();
             }
-            ctx.moveTo(x, y + height);
-            ctx.lineTo(x - width, y + height);
+            ctx.moveTo(rx, by);
+            ctx.lineTo(lx, by);
             if (isSetExternalBottomBorder) {
               const lineWidth = ctx.lineWidth;
               ctx.lineWidth = borderExternalWidth * scale;
@@ -11798,12 +12086,12 @@ var TableParticle = class {
           ctx.translate(0.5, 0.5);
           ctx.beginPath();
           if (td.rowIndex === 0) {
-            ctx.moveTo(x - width, y);
-            ctx.lineTo(x, y);
+            ctx.moveTo(lx, ty);
+            ctx.lineTo(rx, ty);
           }
           if (td.colIndex === 0) {
-            ctx.moveTo(x - width, y);
-            ctx.lineTo(x - width, y + height);
+            ctx.moveTo(lx, ty);
+            ctx.lineTo(lx, by);
           }
           if (td.rowIndex === 0 || td.colIndex === 0) {
             ctx.stroke();
@@ -11815,6 +12103,22 @@ var TableParticle = class {
         }
       }
     }
+    if (!isEmptyBorderType && !isExternalBorderType && !borderExternalWidth && firstTr?.splitBoundaryTop) {
+      this._drawHorizontalBorder({
+        ctx,
+        startX,
+        endX: startX + tableWidth,
+        y: startY
+      });
+    }
+    if (!isEmptyBorderType && !isExternalBorderType && !borderExternalWidth && lastTr?.splitBoundaryBottom) {
+      this._drawHorizontalBorder({
+        ctx,
+        startX,
+        endX: startX + tableWidth,
+        y: startY + tableHeight
+      });
+    }
     ctx.restore();
   }
   _drawBackgroundColor(ctx, element, startX, startY) {
@@ -11827,12 +12131,12 @@ var TableParticle = class {
         const td = tr.tdList[d];
         if (!td.backgroundColor) continue;
         ctx.save();
-        const width = td.width * scale;
-        const height = td.height * scale;
-        const x = Math.round(td.x * scale + startX);
-        const y = Math.round(td.y * scale + startY);
+        const lx = Math.round(td.x * scale + startX);
+        const ty = Math.round(td.y * scale + startY);
+        const rx = Math.round((td.x + td.width) * scale + startX);
+        const by = Math.round((td.y + td.height) * scale + startY);
         ctx.fillStyle = td.backgroundColor;
-        ctx.fillRect(x, y, width, height);
+        ctx.fillRect(lx, ty, rx - lx, by - ty);
         ctx.restore();
       }
     }
@@ -12007,6 +12311,44 @@ var TableParticle = class {
     }
     ctx.restore();
   }
+  _isSelectedCell(element, tr, td, selection) {
+    if (selection.pagingId && selection.rootTrId && selection.colIndex !== void 0) {
+      return element.pagingId === selection.pagingId && (tr.id === selection.rootTrId || tr.splitRootId === selection.rootTrId) && td.colIndex === selection.colIndex;
+    }
+    if (selection.tableId && element.id !== selection.tableId) {
+      return false;
+    }
+    if (selection.trId && tr.id !== selection.trId) {
+      return false;
+    }
+    if (selection.tdId) {
+      return td.id === selection.tdId;
+    }
+    return false;
+  }
+  drawCellRange(ctx, element, startX, startY, selection) {
+    const { scale, rangeAlpha, rangeColor } = this.options;
+    const { type, trList } = element;
+    if (!trList || type !== "table" /* TABLE */) return;
+    ctx.save();
+    ctx.globalAlpha = rangeAlpha;
+    ctx.fillStyle = rangeColor;
+    for (let t = 0; t < trList.length; t++) {
+      const tr = trList[t];
+      for (let d = 0; d < tr.tdList.length; d++) {
+        const td = tr.tdList[d];
+        if (!this._isSelectedCell(element, tr, td, selection)) {
+          continue;
+        }
+        const x = td.x * scale;
+        const y = td.y * scale;
+        const width = td.width * scale;
+        const height = td.height * scale;
+        ctx.fillRect(x + startX, y + startY, width, height);
+      }
+    }
+    ctx.restore();
+  }
   render(ctx, element, startX, startY) {
     this._drawBackgroundColor(ctx, element, startX, startY);
     this._drawBorder(ctx, element, startX, startY);
@@ -15242,7 +15584,12 @@ var Control = class {
     let element;
     const newIndex = position.isTable ? tdValueIndex : index;
     if (position.isTable) {
-      elementList = elementList[index].trList[trIndex].tdList[tdIndex].value;
+      elementList = this.draw.resolveTableCellContext(elementList, {
+        isTable: true,
+        index,
+        trIndex,
+        tdIndex
+      })?.td.value || [];
       element = elementList[tdValueIndex];
     } else {
       element = elementList[index];
@@ -16506,17 +16853,14 @@ function computeValue(data2, options) {
   const { extraPickAttrs = [] } = options || {};
   return {
     header: zipElementList(data2.header, {
-      extraPickAttrs,
-      isClone: false
+      extraPickAttrs
     }),
     main: zipElementList(data2.main, {
       extraPickAttrs,
-      isClassifyArea: true,
-      isClone: false
+      isClassifyArea: true
     }),
     footer: zipElementList(data2.footer, {
-      extraPickAttrs,
-      isClone: false
+      extraPickAttrs
     })
   };
 }
@@ -18555,6 +18899,38 @@ var ListParticle = class {
     const level = element.listLevel ?? 0;
     return level * INDENT_PER_LEVEL * scale;
   }
+  _getListMarkerStyleElement(elementList, startIndex = 0) {
+    const startElement = elementList[startIndex];
+    for (let i = startIndex + 1; i < elementList.length; i++) {
+      const element = elementList[i];
+      if (element.value === ZERO && !element.listWrap) {
+        break;
+      }
+      if (element.type === "tab" /* TAB */) {
+        continue;
+      }
+      if (element.value !== ZERO || element.type) {
+        return element;
+      }
+    }
+    return startElement;
+  }
+  _getListMarkerText(element, listIndex) {
+    if (element.listStyle === "checkbox" /* CHECKBOX */) {
+      return "";
+    }
+    if (element.listType === "ul" /* UL */) {
+      if (element.listPreset) {
+        return this._getUlBulletForLevel(element);
+      }
+      return ulStyleMapping[element.listStyle] || ulStyleMapping["disc" /* DISC */];
+    }
+    if (element.listPreset) {
+      const olStyle = this._getOlStyleForLevel(element);
+      return formatOlNumber(listIndex, olStyle);
+    }
+    return `${listIndex + 1}${"." /* PERIOD */}`;
+  }
   computeListStyle(ctx, elementList) {
     const listStyleMap = /* @__PURE__ */ new Map();
     let start = 0;
@@ -18585,23 +18961,40 @@ var ListParticle = class {
   }
   getListStyleWidth(ctx, listElementList) {
     const { scale, checkbox } = this.options;
-    const startElement = listElementList[0];
-    if (startElement.listStyle && startElement.listStyle !== "decimal" /* DECIMAL */) {
-      if (startElement.listStyle === "checkbox" /* CHECKBOX */) {
-        return (checkbox.width + this.LIST_GAP) * scale;
+    let maxWidth = 0;
+    let listIndex = 0;
+    for (let i = 0; i < listElementList.length; i++) {
+      const element = listElementList[i];
+      if (element.value !== ZERO || element.listWrap) continue;
+      if (element.listStyle === "checkbox" /* CHECKBOX */) {
+        maxWidth = Math.max(maxWidth, checkbox.width + this.LIST_GAP);
+        listIndex++;
+        continue;
       }
-      return this.UN_COUNT_STYLE_WIDTH * scale;
-    }
-    const count = listElementList.reduce((pre, cur) => {
-      if (cur.value === ZERO) {
-        pre += 1;
+      const markerStyleElement = this._getListMarkerStyleElement(
+        listElementList,
+        i
+      );
+      const text = this._getListMarkerText(element, listIndex);
+      if (!text) {
+        listIndex++;
+        continue;
       }
-      return pre;
-    }, 0);
-    if (!count) return 0;
-    const text = `${this.MEASURE_BASE_TEXT.repeat(String(count).length)}${"." /* PERIOD */}`;
-    const textMetrics = ctx.measureText(text);
-    return Math.ceil((textMetrics.width + this.LIST_GAP) * scale);
+      ctx.save();
+      ctx.font = this.draw.getElementFont(markerStyleElement);
+      const textMetrics = ctx.measureText(text);
+      ctx.restore();
+      maxWidth = Math.max(maxWidth, textMetrics.width + this.LIST_GAP);
+      listIndex++;
+    }
+    if (maxWidth > 0) {
+      return Math.ceil(maxWidth * scale);
+    }
+    const startElement = listElementList[0];
+    if (startElement?.listStyle === "checkbox" /* CHECKBOX */) {
+      return (checkbox.width + this.LIST_GAP) * scale;
+    }
+    return this.UN_COUNT_STYLE_WIDTH * scale;
   }
   _getOlStyleForLevel(element) {
     const preset = element.listPreset || "olDefault" /* DEFAULT */;
@@ -18622,7 +19015,7 @@ var ListParticle = class {
     const startElement = elementList[0];
     if (startElement.value !== ZERO || startElement.listWrap) return;
     let tabWidth = 0;
-    const { defaultTabWidth, scale, defaultFont, defaultSize } = this.options;
+    const { defaultTabWidth, scale } = this.options;
     for (let i = 1; i < elementList.length; i++) {
       const element = elementList[i];
       if (element?.type !== "tab" /* TAB */) break;
@@ -18660,24 +19053,11 @@ var ListParticle = class {
         }
       });
     } else {
-      let text = "";
-      if (startElement.listType === "ul" /* UL */) {
-        if (startElement.listPreset) {
-          text = this._getUlBulletForLevel(startElement);
-        } else {
-          text = ulStyleMapping[startElement.listStyle] || ulStyleMapping["disc" /* DISC */];
-        }
-      } else {
-        if (startElement.listPreset) {
-          const olStyle = this._getOlStyleForLevel(startElement);
-          text = formatOlNumber(listIndex, olStyle);
-        } else {
-          text = `${listIndex + 1}${"." /* PERIOD */}`;
-        }
-      }
+      const text = this._getListMarkerText(startElement, listIndex);
       if (!text) return;
+      const markerStyleElement = this._getListMarkerStyleElement(elementList);
       ctx.save();
-      ctx.font = `${defaultSize * (96 / 72) * scale}px ${defaultFont}`;
+      ctx.font = this.draw.getElementFont(markerStyleElement, scale);
       ctx.fillText(text, x, y);
       ctx.restore();
     }
@@ -19127,6 +19507,39 @@ var TableOperate = class {
     this.tableParticle = draw.getTableParticle();
     this.options = draw.getOptions();
   }
+  getActiveTableElements() {
+    const positionContext = this.position.getPositionContext();
+    if (!positionContext.isTable) return [];
+    const originalElementList = this.draw.getOriginalElementList();
+    const element = originalElementList[positionContext.index];
+    if (!element || element.type !== "table" /* TABLE */) return [];
+    if (!element.pagingId) return [element];
+    return originalElementList.filter(
+      (item) => item.type === "table" /* TABLE */ && item.pagingId === element.pagingId
+    );
+  }
+  getSplitCellStyleSelection() {
+    const tableCellSelection = this.range.getTableCellSelection();
+    if (tableCellSelection?.pagingId && tableCellSelection.rootTrId && tableCellSelection.colIndex !== void 0) {
+      return tableCellSelection;
+    }
+    return this.range.getSplitCellSelection();
+  }
+  getStyleTargetRowCol() {
+    const splitCellSelection = this.getSplitCellStyleSelection();
+    if (splitCellSelection) {
+      const splitCellContext = this.draw.getSplitCellSelectionContext(
+        this.draw.getOriginalElementList(),
+        splitCellSelection
+      );
+      if (splitCellContext) {
+        return splitCellContext.cellContextList.map((cellContext) => [
+          cellContext.td
+        ]);
+      }
+    }
+    return this.tableParticle.getRangeRowCol();
+  }
   insertTable(row, col) {
     const { startIndex, endIndex } = this.range.getRange();
     if (!~startIndex && !~endIndex) return;
@@ -19807,7 +20220,7 @@ var TableOperate = class {
     this.tableTool.render();
   }
   tableTdVerticalAlign(payload) {
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     for (let r = 0; r < rowCol.length; r++) {
       const row = rowCol[r];
@@ -19827,13 +20240,17 @@ var TableOperate = class {
   tableBorderType(payload) {
     const positionContext = this.position.getPositionContext();
     if (!positionContext.isTable) return;
-    const { index } = positionContext;
-    const originalElementList = this.draw.getOriginalElementList();
-    const element = originalElementList[index];
-    if (!element.borderType && payload === "all" /* ALL */ || element.borderType === payload) {
+    const tableElements = this.getActiveTableElements();
+    if (!tableElements.length) return;
+    const isAllSame = tableElements.every(
+      (element) => !element.borderType && payload === "all" /* ALL */ || element.borderType === payload
+    );
+    if (isAllSame) {
       return;
     }
-    element.borderType = payload;
+    tableElements.forEach((element) => {
+      element.borderType = payload;
+    });
     const { endIndex } = this.range.getRange();
     this.draw.render({
       curIndex: endIndex
@@ -19842,13 +20259,17 @@ var TableOperate = class {
   tableBorderColor(payload) {
     const positionContext = this.position.getPositionContext();
     if (!positionContext.isTable) return;
-    const { index } = positionContext;
-    const originalElementList = this.draw.getOriginalElementList();
-    const element = originalElementList[index];
-    if (!element.borderColor && payload === this.options.table.defaultBorderColor || element.borderColor === payload) {
+    const tableElements = this.getActiveTableElements();
+    if (!tableElements.length) return;
+    const isAllSame = tableElements.every(
+      (element) => !element.borderColor && payload === this.options.table.defaultBorderColor || element.borderColor === payload
+    );
+    if (isAllSame) {
       return;
     }
-    element.borderColor = payload;
+    tableElements.forEach((element) => {
+      element.borderColor = payload;
+    });
     const { endIndex } = this.range.getRange();
     this.draw.render({
       curIndex: endIndex,
@@ -19856,7 +20277,7 @@ var TableOperate = class {
     });
   }
   tableTdBorderType(payload) {
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     const tdList = rowCol.flat();
     const isSetBorderType = tdList.some(
@@ -19888,7 +20309,7 @@ var TableOperate = class {
     });
   }
   tableTdSlashType(payload) {
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     const tdList = rowCol.flat();
     const isSetTdSlashType = tdList.some(
@@ -19918,7 +20339,7 @@ var TableOperate = class {
     });
   }
   tableTdBackgroundColor(payload) {
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     for (let r = 0; r < rowCol.length; r++) {
       const row = rowCol[r];
@@ -19939,14 +20360,14 @@ var TableOperate = class {
     const { index } = positionContext;
     const originalElementList = this.draw.getOriginalElementList();
     const element = originalElementList[index];
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     const tdList = rowCol.flat();
     const totalCells = element.trList.reduce(
       (sum, tr) => sum + tr.tdList.length,
       0
     );
-    const allSelected = tdList.length >= totalCells;
+    const allSelected = !element.pagingId && !this.getSplitCellStyleSelection() && tdList.length >= totalCells;
     if (allSelected) {
       element.borderColor = payload || void 0;
       element.trList.forEach(
@@ -19966,7 +20387,7 @@ var TableOperate = class {
     });
   }
   tableTdPadding(payload) {
-    const rowCol = this.tableParticle.getRangeRowCol();
+    const rowCol = this.getStyleTargetRowCol();
     if (!rowCol) return;
     const tdList = rowCol.flat();
     tdList.forEach((td) => {
@@ -20001,6 +20422,46 @@ var TableOperate = class {
       isSubmitHistory: false
     });
   }
+  tableTdSelectAll() {
+    const originalElementList = this.draw.getOriginalElementList();
+    const resolved = this.draw.resolveTableCellContext(originalElementList);
+    if (!resolved) return;
+    const currentTr = resolved.element.trList?.[resolved.trIndex];
+    if (!currentTr) return;
+    const currentTd = resolved.td;
+    const currentElement = resolved.element;
+    const splitCellSelection = currentElement.pagingId && currentTr.id && currentTd.colIndex !== void 0 ? {
+      pagingId: currentElement.pagingId,
+      rootTrId: currentTr.splitRootId || currentTr.id,
+      colIndex: currentTd.colIndex
+    } : void 0;
+    const splitCellSelectionContext = this.draw.getSplitCellSelectionContext(
+      originalElementList,
+      splitCellSelection
+    );
+    if (splitCellSelectionContext) {
+      const endIndex = Math.max(
+        splitCellSelectionContext.positionList.length - 1,
+        0
+      );
+      this.range.setRange(0, endIndex);
+      this.range.setSplitCellSelection(splitCellSelection);
+      this.range.setTableCellSelection(splitCellSelection);
+    } else {
+      const endIndex = Math.max(currentTd.value.length - 1, 0);
+      this.range.setRange(0, endIndex);
+      this.range.setTableCellSelection({
+        tableId: currentElement.id,
+        trId: currentTr.id,
+        tdId: currentTd.id
+      });
+    }
+    this.draw.render({
+      isSetCursor: false,
+      isCompute: false,
+      isSubmitHistory: false
+    });
+  }
 };
 
 // src/dataset/enum/Area.ts
@@ -20495,6 +20956,7 @@ var Draw = class {
     this.intersectionPageNo = 0;
     this.lazyRenderIntersectionObserver = null;
     this.printModeData = null;
+    this.pendingTableCursorIndex = void 0;
     if (this.mode === "print" /* PRINT */) {
       this.setPrintData();
     }
@@ -20656,9 +21118,8 @@ var Draw = class {
   getContextInnerWidth() {
     const positionContext = this.position.getPositionContext();
     if (positionContext.isTable) {
-      const { index, trIndex, tdIndex } = positionContext;
-      const elementList = this.getOriginalElementList();
-      const td = elementList[index].trList[trIndex].tdList[tdIndex];
+      const td = this.resolveTableCellContext(this.getOriginalElementList())?.td;
+      if (!td) return this.getColumnWidth() / this.options.scale;
       const tdPadding = this.getTdPadding();
       return td.width - tdPadding[1] - tdPadding[3];
     }
@@ -20742,6 +21203,56 @@ var Draw = class {
   getPage(pageNo = -1) {
     return this.pageList[~pageNo ? pageNo : this.pageNo];
   }
+  resolveTableCellContext(sourceElementList = this.getOriginalElementList(), context = this.position.getPositionContext()) {
+    if (!context.isTable) return null;
+    const candidateIndexes = [];
+    if (context.index !== void 0 && sourceElementList[context.index]?.type === "table" /* TABLE */) {
+      candidateIndexes.push(context.index);
+    }
+    if (context.tableId) {
+      const tableIndex = sourceElementList.findIndex((el) => el.id === context.tableId);
+      if (~tableIndex && !candidateIndexes.includes(tableIndex)) {
+        candidateIndexes.push(tableIndex);
+      }
+    }
+    for (let i = 0; i < sourceElementList.length; i++) {
+      const element = sourceElementList[i];
+      if (element.type !== "table" /* TABLE */ || candidateIndexes.includes(i)) {
+        continue;
+      }
+      candidateIndexes.push(i);
+    }
+    for (const tableIndex of candidateIndexes) {
+      const element = sourceElementList[tableIndex];
+      const trList = element.trList;
+      if (!trList?.length) continue;
+      let resolvedTrIndex = -1;
+      if (context.trId) {
+        resolvedTrIndex = trList.findIndex((tr) => tr.id === context.trId);
+      }
+      if (resolvedTrIndex < 0 && context.trIndex !== void 0 && trList[context.trIndex]) {
+        resolvedTrIndex = context.trIndex;
+      }
+      if (resolvedTrIndex < 0) continue;
+      const tdList = trList[resolvedTrIndex].tdList;
+      let resolvedTdIndex = -1;
+      if (context.tdId) {
+        resolvedTdIndex = tdList.findIndex((td) => td.id === context.tdId);
+      }
+      if (resolvedTdIndex < 0 && context.tdIndex !== void 0 && tdList[context.tdIndex]) {
+        resolvedTdIndex = context.tdIndex;
+      }
+      if (resolvedTdIndex < 0) continue;
+      return {
+        index: tableIndex,
+        trIndex: resolvedTrIndex,
+        tdIndex: resolvedTdIndex,
+        element,
+        td: tdList[resolvedTdIndex]
+      };
+    }
+    return null;
+  }
   getPageList() {
     return this.pageList;
   }
@@ -20749,9 +21260,7 @@ var Draw = class {
     return this.pageList.length;
   }
   getTableRowList(sourceElementList) {
-    const positionContext = this.position.getPositionContext();
-    const { index, trIndex, tdIndex } = positionContext;
-    return sourceElementList[index].trList[trIndex].tdList[tdIndex].rowList;
+    return this.resolveTableCellContext(sourceElementList)?.td.rowList || [];
   }
   getOriginalRowList() {
     const zoneManager = this.getZone();
@@ -20810,9 +21319,155 @@ var Draw = class {
     return this.header.getElementList();
   }
   getTableElementList(sourceElementList) {
+    const splitCellSelectionContext = this.getSplitCellSelectionContext(
+      sourceElementList
+    );
+    if (splitCellSelectionContext) {
+      return splitCellSelectionContext.value;
+    }
+    return this.resolveTableCellContext(sourceElementList)?.td.value || [];
+  }
+  getSplitCellSelectionContext(sourceElementList = this.getOriginalElementList(), splitCellSelection = this.range.getSplitCellSelection()) {
+    if (!splitCellSelection) return null;
+    const { pagingId, rootTrId, colIndex } = splitCellSelection;
+    const cellContextList = [];
+    for (let i = 0; i < sourceElementList.length; i++) {
+      const element = sourceElementList[i];
+      if (element.type !== "table" /* TABLE */ || element.pagingId !== pagingId) {
+        continue;
+      }
+      const trList = element.trList;
+      if (!trList?.length) continue;
+      for (let t = 0; t < trList.length; t++) {
+        const tr = trList[t];
+        if (tr.id !== rootTrId && tr.splitRootId !== rootTrId) continue;
+        const tdIndex = tr.tdList.findIndex((td2) => td2.colIndex === colIndex);
+        if (tdIndex < 0) continue;
+        const td = tr.tdList[tdIndex];
+        cellContextList.push({
+          tableIndex: i,
+          trIndex: t,
+          tdIndex,
+          element,
+          tr,
+          td
+        });
+      }
+    }
+    if (cellContextList.length < 2) return null;
+    const value = [];
+    const positionList = [];
+    for (let c = 0; c < cellContextList.length; c++) {
+      const { td } = cellContextList[c];
+      const skipLeadingZero = !!td.splitSyntheticLeadingZero && td.value[0]?.value === ZERO ? 1 : 0;
+      value.push(...td.value.slice(skipLeadingZero));
+      if (td.positionList?.length) {
+        positionList.push(...td.positionList.slice(skipLeadingZero));
+      }
+    }
+    return {
+      value,
+      positionList,
+      cellContextList
+    };
+  }
+  syncTableElementContext(elementList, context) {
+    const { tableId, trId, tdId } = context;
+    for (let i = 0; i < elementList.length; i++) {
+      const element = elementList[i];
+      element.tableId = tableId;
+      element.trId = trId;
+      element.tdId = tdId;
+    }
+  }
+  getCollapsedSplitTableCursorContext(element) {
     const positionContext = this.position.getPositionContext();
-    const { index, trIndex, tdIndex } = positionContext;
-    return sourceElementList[index].trList?.[trIndex].tdList[tdIndex].value || [];
+    const { startIndex, endIndex } = this.range.getRange();
+    if (!element.pagingId || !positionContext.isTable || startIndex !== endIndex || positionContext.tableId !== element.id || !positionContext.trId) {
+      return null;
+    }
+    const trList = element.trList;
+    if (!trList?.length) return null;
+    const currentTr = trList.find((tr) => tr.id === positionContext.trId);
+    const currentTd = currentTr && (positionContext.tdId ? currentTr.tdList.find((td) => td.id === positionContext.tdId) : currentTr.tdList[positionContext.tdIndex]);
+    if (!currentTr?.id || !currentTd || currentTd.colIndex === void 0) {
+      return null;
+    }
+    const rootTrId = currentTr.splitRootId || currentTr.id;
+    let mergedIndex = 0;
+    for (let t = 0; t < trList.length; t++) {
+      const tr = trList[t];
+      if (tr.id !== rootTrId && tr.splitRootId !== rootTrId) {
+        continue;
+      }
+      const td = tr.tdList.find((cell) => cell.colIndex === currentTd.colIndex);
+      if (!td) continue;
+      const skipLeadingZero = !!td.splitSyntheticLeadingZero && td.value[0]?.value === ZERO ? 1 : 0;
+      if (tr.id === currentTr.id && td.id === currentTd.id) {
+        mergedIndex += Math.max(startIndex - skipLeadingZero, 0);
+        return {
+          rootTrId,
+          colIndex: currentTd.colIndex,
+          mergedIndex
+        };
+      }
+      mergedIndex += Math.max(td.value.length - skipLeadingZero, 0);
+    }
+    return null;
+  }
+  applyCollapsedSplitTableCursor(payload) {
+    const {
+      tableIndex,
+      tableId,
+      overflowTr,
+      overflowTrIdx,
+      continuationTr,
+      continuationTdList,
+      logicalCursor,
+      splits
+    } = payload;
+    const tdIndex = overflowTr.tdList.findIndex(
+      (td) => td.colIndex === logicalCursor.colIndex
+    );
+    if (tdIndex < 0) return false;
+    const splitIdx = splits[tdIndex]?.elemIdx;
+    if (splitIdx === void 0) return false;
+    const positionContext = this.position.getPositionContext();
+    if (logicalCursor.mergedIndex >= splitIdx) {
+      const continuationTd = continuationTdList[tdIndex];
+      if (!continuationTd) return false;
+      const hasPrependedZero = !!continuationTd.splitSyntheticLeadingZero && continuationTd.value[0]?.value === ZERO;
+      const continuationCursorIndex = logicalCursor.mergedIndex - splitIdx + (hasPrependedZero ? 1 : 0);
+      positionContext.index = tableIndex;
+      positionContext.trIndex = overflowTrIdx + 1;
+      positionContext.tdIndex = tdIndex;
+      positionContext.tdId = continuationTd.id;
+      positionContext.trId = continuationTr.id;
+      positionContext.tableId = tableId;
+      this.position.setPositionContext(positionContext);
+      this.range.setRange(
+        continuationCursorIndex,
+        continuationCursorIndex
+      );
+      this.pendingTableCursorIndex = continuationCursorIndex;
+      return true;
+    }
+    const rootTd = overflowTr.tdList[tdIndex];
+    if (!rootTd) return false;
+    const rootCursorIndex = Math.min(
+      logicalCursor.mergedIndex,
+      Math.max(rootTd.value.length - 1, 0)
+    );
+    positionContext.index = tableIndex;
+    positionContext.trIndex = overflowTrIdx;
+    positionContext.tdIndex = tdIndex;
+    positionContext.tdId = rootTd.id;
+    positionContext.trId = overflowTr.id;
+    positionContext.tableId = tableId;
+    this.position.setPositionContext(positionContext);
+    this.range.setRange(rootCursorIndex, rootCursorIndex);
+    this.pendingTableCursorIndex = rootCursorIndex;
+    return true;
   }
   getElementList() {
     const positionContext = this.position.getPositionContext();
@@ -20840,13 +21495,7 @@ var Draw = class {
     return this.footer.getElementList();
   }
   getTd() {
-    const positionContext = this.position.getPositionContext();
-    const { index, trIndex, tdIndex, isTable } = positionContext;
-    if (isTable) {
-      const elementList = this.getOriginalElementList();
-      return elementList[index].trList[trIndex].tdList[tdIndex];
-    }
-    return null;
+    return this.resolveTableCellContext(this.getOriginalElementList())?.td || null;
   }
   insertElementList(payload, options = {}) {
     if (!payload.length || !this.range.getIsCanInput()) return;
@@ -20857,6 +21506,18 @@ var Draw = class {
       isHandleFirstElement: false,
       editorOptions: this.options
     });
+    const splitCellSelection = this.range.getSplitCellSelection();
+    if (splitCellSelection) {
+      const curIndex2 = this.replaceSplitCellSelection(payload, splitCellSelection);
+      if (~curIndex2) {
+        this.range.setRange(curIndex2, curIndex2);
+        this.render({
+          curIndex: curIndex2,
+          isSubmitHistory
+        });
+      }
+      return;
+    }
     let curIndex = -1;
     let activeControl = this.control.getActiveControl();
     if (!activeControl && this.control.getIsRangeWithinControl()) {
@@ -20952,6 +21613,80 @@ var Draw = class {
       }
     }
   }
+  replaceSplitCellSelection(payload, splitCellSelection = this.range.getSplitCellSelection()) {
+    const splitCellSelectionContext = this.getSplitCellSelectionContext(
+      this.getOriginalElementList(),
+      splitCellSelection
+    );
+    if (!splitCellSelectionContext) return -1;
+    const [rootCellContext, ...continuationCellContextList] = splitCellSelectionContext.cellContextList;
+    const rootTd = rootCellContext.td;
+    const rootStartIndex = rootTd.value[0]?.value === ZERO ? 1 : 0;
+    if (!rootStartIndex) {
+      rootTd.value.unshift({
+        value: ZERO,
+        type: "text" /* TEXT */
+      });
+      this.syncTableElementContext([rootTd.value[0]], {
+        tableId: rootCellContext.element.id,
+        trId: rootCellContext.tr.id,
+        tdId: rootTd.id
+      });
+    }
+    this.syncTableElementContext(payload, {
+      tableId: rootCellContext.element.id,
+      trId: rootCellContext.tr.id,
+      tdId: rootTd.id
+    });
+    this.spliceElementList(
+      rootTd.value,
+      1,
+      rootTd.value.length - 1,
+      payload
+    );
+    rootTd.rowList = void 0;
+    rootTd.positionList = void 0;
+    rootTd.mainHeight = void 0;
+    rootTd.realHeight = void 0;
+    rootTd.realMinHeight = void 0;
+    for (let c = 0; c < continuationCellContextList.length; c++) {
+      const continuationTd = continuationCellContextList[c].td;
+      const startIndex = continuationTd.value[0]?.value === ZERO ? 1 : 0;
+      if (!startIndex) {
+        continuationTd.value.unshift({
+          value: ZERO,
+          type: "text" /* TEXT */
+        });
+        this.syncTableElementContext([continuationTd.value[0]], {
+          tableId: continuationCellContextList[c].element.id,
+          trId: continuationCellContextList[c].tr.id,
+          tdId: continuationTd.id
+        });
+      }
+      if (continuationTd.value.length > 1) {
+        this.spliceElementList(
+          continuationTd.value,
+          1,
+          continuationTd.value.length - 1
+        );
+      }
+      continuationTd.rowList = void 0;
+      continuationTd.positionList = void 0;
+      continuationTd.mainHeight = void 0;
+      continuationTd.realHeight = void 0;
+      continuationTd.realMinHeight = void 0;
+    }
+    this.position.setPositionContext({
+      isTable: true,
+      index: rootCellContext.tableIndex,
+      trIndex: rootCellContext.trIndex,
+      tdIndex: rootCellContext.tdIndex,
+      tdId: rootTd.id,
+      trId: rootCellContext.tr.id,
+      tableId: rootCellContext.element.id
+    });
+    return Math.max(rootTd.value.length - 1, 0);
+  }
   getCanvasEvent() {
     return this.canvasEvent;
   }
@@ -21362,6 +22097,72 @@ var Draw = class {
     }
     return defaultBasicRowMarginHeight * ratio * (el.rowMargin ?? defaultRowMargin) * scale;
   }
+  createListStateSeed(initialListState) {
+    const listLevelIndex = /* @__PURE__ */ new Map();
+    if (initialListState?.listLevelIndex) {
+      Object.entries(initialListState.listLevelIndex).forEach(
+        ([level, index]) => {
+          listLevelIndex.set(Number(level), index);
+        }
+      );
+    }
+    return {
+      listId: initialListState?.listId,
+      listIndex: initialListState?.listIndex ?? 0,
+      prevListLevel: initialListState?.prevListLevel ?? 0,
+      listLevelIndex
+    };
+  }
+  advanceListState(element, listState) {
+    if (element.listId) {
+      const curLevel = element.listLevel ?? 0;
+      if (element.listId !== listState.listId) {
+        listState.listIndex = 0;
+        listState.listLevelIndex = /* @__PURE__ */ new Map();
+        listState.listLevelIndex.set(curLevel, 0);
+        listState.prevListLevel = curLevel;
+      } else if (element.value === ZERO && !element.listWrap) {
+        if (curLevel !== listState.prevListLevel) {
+          if (curLevel > listState.prevListLevel) {
+            listState.listLevelIndex.set(curLevel, 0);
+          } else {
+            for (const [lvl] of listState.listLevelIndex) {
+              if (lvl > curLevel) {
+                listState.listLevelIndex.delete(lvl);
+              }
+            }
+            listState.listLevelIndex.set(
+              curLevel,
+              (listState.listLevelIndex.get(curLevel) ?? -1) + 1
+            );
+          }
+        } else {
+          listState.listLevelIndex.set(
+            curLevel,
+            (listState.listLevelIndex.get(curLevel) ?? -1) + 1
+          );
+        }
+        listState.listIndex = listState.listLevelIndex.get(curLevel) ?? 0;
+        listState.prevListLevel = curLevel;
+      }
+    }
+    listState.listId = element.listId;
+  }
+  getListStateBeforeIndex(elementList, endExclusive) {
+    const limit = Math.min(endExclusive, elementList.length);
+    if (limit <= 0) return;
+    const listState = this.createListStateSeed();
+    for (let i = 0; i < limit; i++) {
+      this.advanceListState(elementList[i], listState);
+    }
+    if (!listState.listId) return;
+    return {
+      listId: listState.listId,
+      listIndex: listState.listIndex,
+      prevListLevel: listState.prevListLevel,
+      listLevelIndex: Object.fromEntries(listState.listLevelIndex)
+    };
+  }
   computeRowList(payload) {
     const {
       innerWidth,
@@ -21372,7 +22173,8 @@ var Draw = class {
       startY = 0,
       pageHeight = 0,
       mainOuterHeight = 0,
-      surroundElementList = []
+      surroundElementList = [],
+      initialListState
     } = payload;
     const {
       defaultSize,
@@ -21399,10 +22201,7 @@ var Draw = class {
     let x = startX;
     let y = startY;
     let pageNo = 0;
-    let listId;
-    let listIndex = 0;
-    let listLevelIndex = /* @__PURE__ */ new Map();
-    let prevListLevel = 0;
+    const listState = this.createListStateSeed(initialListState);
     let controlRealWidth = 0;
     for (let i = 0; i < elementList.length; i++) {
       const curRow = rowList[rowList.length - 1];
@@ -21448,6 +22247,11 @@ var Draw = class {
         }
         metrics.boundingBoxAscent = 0;
       } else if (element.type === "table" /* TABLE */) {
+        let activeSplitRange;
+        let mergedSplitFallback;
+        const logicalSplitCursor = this.getCollapsedSplitTableCursorContext(
+          element
+        );
         if (element.pagingId) {
           let tableIndex = i + 1;
           let combineCount = 0;
@@ -21468,11 +22272,66 @@ var Draw = class {
           if (combineCount) {
             elementList.splice(i + 1, combineCount);
           }
+          const mergedTrList = element.trList;
+          for (let t = mergedTrList.length - 1; t >= 0; t--) {
+            const splitTr = mergedTrList[t];
+            if (!splitTr.splitParentId) continue;
+            const parentTrIdx = mergedTrList.findIndex(
+              (r) => r.id === splitTr.splitParentId
+            );
+            if (!~parentTrIdx) continue;
+            const parentTr = mergedTrList[parentTrIdx];
+            const posCtx = this.position.getPositionContext();
+            const { startIndex, endIndex } = this.range.getRange();
+            if (posCtx.isTable && posCtx.trId === splitTr.id && startIndex === endIndex && posCtx.tdIndex !== void 0) {
+              const splitTd = splitTr.tdList[posCtx.tdIndex];
+              const parentTd = parentTr.tdList[posCtx.tdIndex];
+              if (splitTd && parentTd) {
+                const hasSyntheticLeadingZero = !!splitTd.splitSyntheticLeadingZero && splitTd.value[0]?.value === ZERO;
+                const mergedIndex = parentTd.value.length + startIndex - (hasSyntheticLeadingZero ? 1 : 0);
+                activeSplitRange = {
+                  tdIndex: posCtx.tdIndex,
+                  mergedIndex,
+                  trId: splitTr.id
+                };
+                mergedSplitFallback = {
+                  tdIndex: posCtx.tdIndex,
+                  mergedIndex,
+                  trId: splitTr.id,
+                  parentTrId: parentTr.id,
+                  parentTdId: parentTd.id,
+                  parentTrIndex: parentTrIdx
+                };
+              }
+            }
+            for (let d = 0; d < parentTr.tdList.length; d++) {
+              const parentTd = parentTr.tdList[d];
+              const splitTd = splitTr.tdList[d];
+              if (!splitTd) continue;
+              const hasSyntheticLeadingZero = !!splitTd.splitSyntheticLeadingZero && splitTd.value[0]?.value === ZERO;
+              const splitValue = hasSyntheticLeadingZero ? splitTd.value.slice(1) : splitTd.value;
+              this.syncTableElementContext(splitValue, {
+                tableId: element.id,
+                trId: parentTr.id,
+                tdId: parentTd.id
+              });
+              parentTd.value.push(...splitValue);
+              parentTd.rowList = void 0;
+              parentTd.positionList = void 0;
+            }
+            if (posCtx.isTable && posCtx.trId === splitTr.id) {
+              posCtx.index = i;
+              this.position.setPositionContext(posCtx);
+            }
+            mergedTrList.splice(t, 1);
+          }
         }
         element.pagingIndex = element.pagingIndex ?? 0;
         const trList = element.trList;
         for (let t = 0; t < trList.length; t++) {
           const tr = trList[t];
+          delete tr.splitBoundaryTop;
+          delete tr.splitBoundaryBottom;
           tr.height = tr.minHeight || defaultTrMinHeight;
           tr.minHeight = tr.height;
         }
@@ -21487,6 +22346,7 @@ var Draw = class {
             const rowList2 = this.computeRowList({
               innerWidth: (td.width - cellPaddingWidth) * scale,
               elementList: td.value,
+              initialListState: td.splitListState,
               isFromTable: true,
               isPagingMode
             });
@@ -21569,6 +22429,7 @@ var Draw = class {
               const tdRowList = this.computeRowList({
                 innerWidth: (td.width - cellPaddingWidth) * scale,
                 elementList: td.value,
+                initialListState: td.splitListState,
                 isFromTable: true,
                 isPagingMode
               });
@@ -21662,6 +22523,197 @@ var Draw = class {
                 }
               }
             }
+            if (deleteCount === 0) {
+              let overflowTrIdx = -1;
+              let preHeightScaled = 0;
+              for (let r = 0; r < trList2.length; r++) {
+                const trHeight = trList2[r].height * scale;
+                if (curPagePreHeight + rowMarginHeight + preHeightScaled + trHeight > height2) {
+                  overflowTrIdx = r;
+                  break;
+                }
+                preHeightScaled += trHeight;
+              }
+              if (overflowTrIdx >= 0) {
+                const availableScaled = height2 - curPagePreHeight - rowMarginHeight - preHeightScaled;
+                const availableUnscaled = availableScaled / scale;
+                if (availableUnscaled >= defaultTrMinHeight) {
+                  const overflowTr = trList2[overflowTrIdx];
+                  const originalTrHeight = overflowTr.height;
+                  const {
+                    table: { tdPadding: defaultTdPadding, defaultTrMinHeight: defaultTrMinHeight2 }
+                  } = this.options;
+                  const splits = [];
+                  let anySplit = false;
+                  for (let d = 0; d < overflowTr.tdList.length; d++) {
+                    const td = overflowTr.tdList[d];
+                    const cellPadding = td.padding || defaultTdPadding;
+                    const cellPaddingH = cellPadding[0] + cellPadding[2];
+                    const contentAvailableScaled = (availableUnscaled - cellPaddingH) * scale;
+                    if (!td.rowList || td.rowList.length === 0) {
+                      splits.push({
+                        elemIdx: td.value.length,
+                        rowIdx: 0
+                      });
+                      continue;
+                    }
+                    let cumHeight = 0;
+                    let elemIdx = td.value.length;
+                    let rowIdx = td.rowList.length;
+                    for (let ri = 0; ri < td.rowList.length; ri++) {
+                      const row = td.rowList[ri];
+                      if (cumHeight + row.height > contentAvailableScaled) {
+                        elemIdx = row.startIndex;
+                        rowIdx = ri;
+                        break;
+                      }
+                      cumHeight += row.height;
+                    }
+                    if (elemIdx > 0 && elemIdx < td.value.length) {
+                      anySplit = true;
+                    }
+                    splits.push({ elemIdx, rowIdx });
+                  }
+                  if (anySplit) {
+                    if (!activeSplitRange) {
+                      const posCtx = this.position.getPositionContext();
+                      const { startIndex, endIndex } = this.range.getRange();
+                      if (posCtx.isTable && posCtx.trId === overflowTr.id && startIndex === endIndex && posCtx.tdIndex !== void 0) {
+                        const splitIdx = splits[posCtx.tdIndex]?.elemIdx;
+                        if (splitIdx !== void 0 && startIndex >= splitIdx && splitIdx < overflowTr.tdList[posCtx.tdIndex].value.length) {
+                          activeSplitRange = {
+                            tdIndex: posCtx.tdIndex,
+                            mergedIndex: startIndex,
+                            trId: overflowTr.id
+                          };
+                        }
+                      }
+                    }
+                    const continuationTrHeight = originalTrHeight - availableUnscaled;
+                    const splitRootId = overflowTr.splitRootId || overflowTr.id;
+                    const splitLevel = (overflowTr.splitLevel || 0) + 1;
+                    const newTrId = `${splitRootId}_c${splitLevel}`;
+                    const continuationTdList = overflowTr.tdList.map(
+                      (td, d) => {
+                        const splitIdx = splits[d].elemIdx;
+                        const newTdId = getUUID();
+                        const initialListState2 = this.getListStateBeforeIndex(
+                          td.value,
+                          splitIdx
+                        );
+                        const overflowElements = td.value.slice(splitIdx);
+                        const overflowStartElement = overflowElements[0];
+                        let splitSyntheticLeadingZero = false;
+                        if (!overflowElements.length || overflowElements[0]?.value !== ZERO) {
+                          overflowElements.unshift({
+                            value: ZERO,
+                            type: "text" /* TEXT */,
+                            listId: overflowStartElement?.listId,
+                            listType: overflowStartElement?.listType,
+                            listStyle: overflowStartElement?.listStyle,
+                            listLevel: overflowStartElement?.listLevel,
+                            listPreset: overflowStartElement?.listPreset,
+                            listWrap: !!overflowStartElement?.listId
+                          });
+                          splitSyntheticLeadingZero = true;
+                        }
+                        this.syncTableElementContext(overflowElements, {
+                          tableId: element.id,
+                          trId: newTrId,
+                          tdId: newTdId
+                        });
+                        const {
+                          id: _tdId,
+                          value: _v,
+                          rowList: _rl,
+                          positionList: _pl,
+                          splitSyntheticLeadingZero: _slz,
+                          splitListState: _sls,
+                          ...tdMeta
+                        } = td;
+                        return {
+                          ...deepClone(tdMeta),
+                          id: newTdId,
+                          value: overflowElements,
+                          splitSyntheticLeadingZero,
+                          splitListState: initialListState2,
+                          height: continuationTrHeight,
+                          rowList: void 0,
+                          positionList: void 0,
+                          mainHeight: void 0,
+                          realHeight: void 0,
+                          realMinHeight: void 0
+                        };
+                      }
+                    );
+                    const continuationTr = {
+                      id: newTrId,
+                      height: continuationTrHeight,
+                      minHeight: defaultTrMinHeight2,
+                      tdList: continuationTdList,
+                      splitParentId: overflowTr.id,
+                      splitRootId,
+                      splitLevel
+                    };
+                    let isLogicalSplitCursorHandled = false;
+                    if (logicalSplitCursor && logicalSplitCursor.rootTrId === splitRootId) {
+                      isLogicalSplitCursorHandled = this.applyCollapsedSplitTableCursor({
+                        tableIndex: i,
+                        tableId: element.id,
+                        overflowTr,
+                        overflowTrIdx,
+                        continuationTr,
+                        continuationTdList,
+                        logicalCursor: logicalSplitCursor,
+                        splits
+                      });
+                    }
+                    const positionContext = this.position.getPositionContext();
+                    if (!isLogicalSplitCursorHandled && activeSplitRange && positionContext.isTable && positionContext.trId === activeSplitRange.trId) {
+                      const splitIdx = splits[activeSplitRange.tdIndex]?.elemIdx;
+                      const continuationTd = continuationTdList[activeSplitRange.tdIndex];
+                      if (splitIdx !== void 0 && continuationTd && activeSplitRange.mergedIndex >= splitIdx) {
+                        const hasPrependedZero = !!continuationTd.splitSyntheticLeadingZero && continuationTd.value[0]?.value === ZERO;
+                        const continuationCursorIndex = activeSplitRange.mergedIndex - splitIdx + (hasPrependedZero ? 1 : 0);
+                        positionContext.index = i;
+                        positionContext.trIndex = overflowTrIdx + 1;
+                        positionContext.tdIndex = activeSplitRange.tdIndex;
+                        positionContext.tdId = continuationTd.id;
+                        positionContext.trId = continuationTr.id;
+                        positionContext.tableId = element.id;
+                        this.position.setPositionContext(positionContext);
+                        this.range.setRange(
+                          continuationCursorIndex,
+                          continuationCursorIndex
+                        );
+                        this.pendingTableCursorIndex = continuationCursorIndex;
+                      }
+                    }
+                    for (let d = 0; d < overflowTr.tdList.length; d++) {
+                      const td = overflowTr.tdList[d];
+                      const { elemIdx, rowIdx } = splits[d];
+                      td.value = td.value.slice(0, elemIdx);
+                      td.rowList = td.rowList ? td.rowList.slice(0, rowIdx) : void 0;
+                      td.positionList = void 0;
+                      td.height = availableUnscaled;
+                      td.mainHeight = void 0;
+                      td.realHeight = void 0;
+                      td.realMinHeight = void 0;
+                    }
+                    overflowTr.height = availableUnscaled;
+                    overflowTr.minHeight = Math.min(
+                      overflowTr.minHeight || defaultTrMinHeight2,
+                      availableUnscaled
+                    );
+                    overflowTr.splitBoundaryBottom = true;
+                    continuationTr.splitBoundaryTop = true;
+                    trList2.splice(overflowTrIdx + 1, 0, continuationTr);
+                    deleteStart = overflowTrIdx + 1;
+                    deleteCount = trList2.length - deleteStart;
+                  }
+                }
+              }
+            }
             if (deleteCount) {
               const cloneTrList = trList2.splice(deleteStart, deleteCount);
               const cloneTrHeight = cloneTrList.reduce(
@@ -21674,16 +22726,26 @@ var Draw = class {
               element.height -= cloneTrHeight;
               metrics.height -= cloneTrRealHeight;
               metrics.boundingBoxDescent -= cloneTrRealHeight;
-              const cloneElement = deepClone(element);
-              cloneElement.pagingId = pagingId;
-              cloneElement.pagingIndex = element.pagingIndex + 1;
+              const {
+                trList: _currentTrList,
+                id: _currentId,
+                height: _currentHeight,
+                pagingIndex: _currentPagingIndex,
+                ...cloneElementMeta
+              } = element;
+              const cloneElement = {
+                ...deepClone(cloneElementMeta),
+                trList: cloneTrList,
+                height: cloneTrHeight,
+                pagingId,
+                pagingIndex: element.pagingIndex + 1
+              };
               const repeatTrList = trList2.filter((tr) => tr.pagingRepeat);
               if (repeatTrList.length) {
                 const cloneRepeatTrList = deepClone(repeatTrList);
                 cloneRepeatTrList.forEach((tr) => tr.id = getUUID());
                 cloneTrList.unshift(...cloneRepeatTrList);
               }
-              cloneElement.trList = cloneTrList;
               cloneElement.id = getUUID();
               this.spliceElementList(elementList, i + 1, 0, [cloneElement]);
             }
@@ -21711,6 +22773,21 @@ var Draw = class {
                 positionContext.index = newPositionContextIndex;
                 positionContext.trIndex = newPositionContextTrIndex;
                 this.position.setPositionContext(positionContext);
+              } else if (mergedSplitFallback && positionContext.trId === mergedSplitFallback.trId) {
+                const fallbackTd = element.trList?.[mergedSplitFallback.parentTrIndex]?.tdList[mergedSplitFallback.tdIndex];
+                const fallbackCursorIndex = Math.min(
+                  mergedSplitFallback.mergedIndex,
+                  Math.max((fallbackTd?.value.length || 1) - 1, 0)
+                );
+                positionContext.index = i;
+                positionContext.trIndex = mergedSplitFallback.parentTrIndex;
+                positionContext.tdIndex = mergedSplitFallback.tdIndex;
+                positionContext.tdId = mergedSplitFallback.parentTdId;
+                positionContext.trId = mergedSplitFallback.parentTrId;
+                positionContext.tableId = element.id;
+                this.position.setPositionContext(positionContext);
+                this.range.setRange(fallbackCursorIndex, fallbackCursorIndex);
+                this.pendingTableCursorIndex = fallbackCursorIndex;
               }
             }
           }
@@ -21843,39 +22920,7 @@ var Draw = class {
           curRowWidth += punctuationWidth * scale;
         }
       }
-      if (element.listId) {
-        const curLevel = element.listLevel ?? 0;
-        if (element.listId !== listId) {
-          listIndex = 0;
-          listLevelIndex = /* @__PURE__ */ new Map();
-          listLevelIndex.set(curLevel, 0);
-          prevListLevel = curLevel;
-        } else if (element.value === ZERO && !element.listWrap) {
-          if (curLevel !== prevListLevel) {
-            if (curLevel > prevListLevel) {
-              listLevelIndex.set(curLevel, 0);
-            } else {
-              for (const [lvl] of listLevelIndex) {
-                if (lvl > curLevel) {
-                  listLevelIndex.delete(lvl);
-                }
-              }
-              listLevelIndex.set(
-                curLevel,
-                (listLevelIndex.get(curLevel) ?? -1) + 1
-              );
-            }
-          } else {
-            listLevelIndex.set(
-              curLevel,
-              (listLevelIndex.get(curLevel) ?? -1) + 1
-            );
-          }
-          listIndex = listLevelIndex.get(curLevel) ?? 0;
-          prevListLevel = curLevel;
-        }
-      }
-      listId = element.listId;
+      this.advanceListState(element, listState);
       const surroundPosition = this.position.setSurroundPosition({
         pageNo,
         rowElement,
@@ -21927,7 +22972,7 @@ var Draw = class {
           const baseListOffset = listStyleMap.get(element.listId) || 0;
           const rowListIndent = this.listParticle.getListIndentWidth(element);
           row.offsetX = baseListOffset + rowListIndent;
-          row.listIndex = listIndex;
+          row.listIndex = listState.listIndex;
         }
         row.offsetY = !isFromTable && element.area?.top && element.areaId !== elementList[i - 1]?.areaId ? element.area.top * scale : 0;
         rowList.push(row);
@@ -22148,6 +23193,27 @@ var Draw = class {
     const isPrintMode = this.isPrintMode();
     const isGraffitiMode = this.isGraffitiMode();
     const { isCrossRowCol, tableId } = this.range.getRange();
+    const splitCellSelection = this.range.getSplitCellSelection();
+    const tableCellSelection = this.range.getTableCellSelection();
+    const splitCellRenderOffsetMap = splitCellSelection ? (() => {
+      const splitCellContext = this.getSplitCellSelectionContext(
+        this.getOriginalElementList(),
+        splitCellSelection
+      );
+      if (!splitCellContext) return null;
+      const offsetMap = /* @__PURE__ */ new Map();
+      let offset = 0;
+      for (let c = 0; c < splitCellContext.cellContextList.length; c++) {
+        const { td } = splitCellContext.cellContextList[c];
+        const skipLeadingZero = !!td.splitSyntheticLeadingZero && td.value[0]?.value === ZERO ? 1 : 0;
+        offsetMap.set(td.id, {
+          offset,
+          skipLeadingZero
+        });
+        offset += Math.max(td.value.length - skipLeadingZero, 0);
+      }
+      return offsetMap;
+    })() : null;
     let index = startIndex;
     for (let i = 0; i < rowList.length; i++) {
       const curRow = rowList[i];
@@ -22179,6 +23245,9 @@ var Draw = class {
           this.textParticle.complete();
           this.laTexParticle.render(ctx, element, x, y + offsetY);
         } else if (element.type === "table" /* TABLE */) {
+          if (tableCellSelection) {
+            tableRangeElement = element;
+          }
           if (isCrossRowCol) {
             rangeRecord.x = x;
             rangeRecord.y = y;
@@ -22326,11 +23395,14 @@ var Draw = class {
           startIndex: startIndex2,
           endIndex
         } = this.range.getRange();
-        if (currentZone === zone && startIndex2 !== endIndex && startIndex2 <= index && index <= endIndex) {
+        const splitCellOffset = element.tdId ? splitCellRenderOffsetMap?.get(element.tdId) : void 0;
+        const splitCellIndex = splitCellOffset ? index - splitCellOffset.skipLeadingZero + splitCellOffset.offset : index;
+        const isSplitCellElement = !!splitCellOffset && index >= splitCellOffset.skipLeadingZero;
+        if (currentZone === zone && startIndex2 !== endIndex && startIndex2 <= splitCellIndex && splitCellIndex <= endIndex) {
           const positionContext = this.position.getPositionContext();
-          if (!positionContext.isTable && !element.tdId || positionContext.tdId === element.tdId) {
-            if (startIndex2 === index) {
-              const nextElement = elementList[startIndex2 + 1];
+          if (splitCellRenderOffsetMap && isSplitCellElement || !splitCellRenderOffsetMap && (!positionContext.isTable && !element.tdId || positionContext.tdId === element.tdId)) {
+            if (startIndex2 === splitCellIndex) {
+              const nextElement = splitCellRenderOffsetMap && isSplitCellElement ? this.getElementList()[startIndex2 + 1] : elementList[startIndex2 + 1];
               if (nextElement && nextElement.value === ZERO) {
                 rangeRecord.x = x + metrics.width;
                 rangeRecord.y = y - (curRow.spaceAbove || 0);
@@ -22395,7 +23467,7 @@ var Draw = class {
       this.strikeout.render(ctx);
       this.group.render(ctx);
       if (!isPrintMode && !isGraffitiMode) {
-        if (rangeRecord.width && rangeRecord.height) {
+        if (!tableCellSelection && rangeRecord.width && rangeRecord.height) {
           const { x, y, width, height } = rangeRecord;
           this.range.render(ctx, x, y, width, height);
         }
@@ -22407,6 +23479,20 @@ var Draw = class {
           } = positionList[curRow.startIndex];
           this.tableParticle.drawRange(ctx, tableRangeElement, x, y);
         }
+        if (tableCellSelection && tableRangeElement) {
+          const {
+            coordinate: {
+              leftTop: [x, y]
+            }
+          } = positionList[curRow.startIndex];
+          this.tableParticle.drawCellRange(
+            ctx,
+            tableRangeElement,
+            x,
+            y,
+            tableCellSelection
+          );
+        }
       }
     }
   }
@@ -22596,6 +23682,7 @@ var Draw = class {
       isFirstRender = false
     } = payload || {};
     let { curIndex } = payload || {};
+    this.pendingTableCursorIndex = void 0;
     const innerWidth = this.getInnerWidth();
     const columnWidth = this.getColumnWidth();
     const isPagingMode = this.getIsPagingMode();
@@ -22661,6 +23748,10 @@ var Draw = class {
     } else {
       this._immediateRender();
     }
+    if (this.pendingTableCursorIndex !== void 0) {
+      curIndex = this.pendingTableCursorIndex;
+      this.pendingTableCursorIndex = void 0;
+    }
     if (isSetCursor) {
       curIndex = this.setCursor(curIndex);
     } else if (this.range.getIsSelection()) {
@@ -22702,9 +23793,7 @@ var Draw = class {
     const positionContext = this.position.getPositionContext();
     const positionList = this.position.getPositionList();
     if (positionContext.isTable) {
-      const { index, trIndex, tdIndex } = positionContext;
-      const elementList = this.getOriginalElementList();
-      const tablePositionList = elementList[index].trList?.[trIndex].tdList[tdIndex].positionList;
+      const tablePositionList = this.resolveTableCellContext(this.getOriginalElementList())?.td.positionList;
       if (curIndex === void 0 && tablePositionList) {
         curIndex = tablePositionList.length - 1;
       }
@@ -23030,6 +24119,34 @@ var CommandAdapt = class {
     this.zone = draw.getZone();
     this.tableOperate = draw.getTableOperate();
   }
+  getStyleSelectionElementList(options = {}) {
+    const selection = this.range.getSelectionElementList();
+    if (!selection?.length) return null;
+    const { textLikeOnly = false } = options;
+    const result = [];
+    const collect = (elementList) => {
+      for (let i = 0; i < elementList.length; i++) {
+        const element = elementList[i];
+        if (element.type === "table" /* TABLE */ && element.trList?.length) {
+          for (let t = 0; t < element.trList.length; t++) {
+            const tr = element.trList[t];
+            for (let d = 0; d < tr.tdList.length; d++) {
+              collect(tr.tdList[d].value);
+            }
+          }
+          continue;
+        }
+        result.push(element);
+      }
+    };
+    collect(selection);
+    if (!textLikeOnly) {
+      return result;
+    }
+    return result.filter(
+      (element) => isTextLikeElement(element) || element.type === "label" /* LABEL */
+    );
+  }
   mode(payload) {
     this.draw.setMode(payload);
   }
@@ -23175,7 +24292,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     let renderOption = {};
     let changeElementList = [];
     if (selection?.length) {
@@ -23202,7 +24319,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       selection.forEach((el) => {
         el.font = payload;
@@ -23236,7 +24353,9 @@ var CommandAdapt = class {
     if (payload < minSize || payload > maxSize) return;
     let renderOption = {};
     let changeElementList = [];
-    const selection = this.range.getTextLikeSelectionElementList();
+    const selection = this.getStyleSelectionElementList({
+      textLikeOnly: true
+    });
     if (selection?.length) {
       changeElementList = selection;
       renderOption = { isSetCursor: false };
@@ -23276,7 +24395,9 @@ var CommandAdapt = class {
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
     const { defaultSize, maxSize } = this.options;
-    const selection = this.range.getTextLikeSelectionElementList();
+    const selection = this.getStyleSelectionElementList({
+      textLikeOnly: true
+    });
     let renderOption = {};
     let changeElementList = [];
     if (selection?.length) {
@@ -23325,7 +24446,9 @@ var CommandAdapt = class {
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
     const { defaultSize, minSize } = this.options;
-    const selection = this.range.getTextLikeSelectionElementList();
+    const selection = this.getStyleSelectionElementList({
+      textLikeOnly: true
+    });
     let renderOption = {};
     let changeElementList = [];
     if (selection?.length) {
@@ -23373,7 +24496,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       const noBoldIndex = selection.findIndex((s) => !s.bold);
       selection.forEach((el) => {
@@ -23405,7 +24528,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       const noItalicIndex = selection.findIndex((s) => !s.italic);
       selection.forEach((el) => {
@@ -23437,7 +24560,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       const isSetUnderline = selection.some(
         (s) => !s.underline || !textDecoration && s.textDecoration || textDecoration && !s.textDecoration || textDecoration && s.textDecoration && !isObjectEqual(s.textDecoration, textDecoration)
@@ -23479,7 +24602,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       const noStrikeoutIndex = selection.findIndex((s) => !s.strikeout);
       selection.forEach((el) => {
@@ -23514,7 +24637,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (!selection) return;
     const superscriptIndex = selection.findIndex(
       (s) => s.type === "superscript" /* SUPERSCRIPT */
@@ -23537,7 +24660,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (!selection) return;
     const subscriptIndex = selection.findIndex(
       (s) => s.type === "subscript" /* SUBSCRIPT */
@@ -23560,7 +24683,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       selection.forEach((el) => {
         if (payload) {
@@ -23601,7 +24724,7 @@ var CommandAdapt = class {
     const { isIgnoreDisabledRule = false } = options || {};
     const isDisabled = !isIgnoreDisabledRule && (this.draw.isReadonly() || this.draw.isDisabled());
     if (isDisabled) return;
-    const selection = this.range.getSelectionElementList();
+    const selection = this.getStyleSelectionElementList();
     if (selection?.length) {
       selection.forEach((el) => {
         if (payload) {
@@ -24232,25 +25355,39 @@ var CommandAdapt = class {
     const endElement = pickElementAttr(elementList[endIndex], {
       extraPickAttrs: ["id", "controlComponent"]
     });
-    const rowList = this.draw.getRowList();
     const positionList = this.position.getPositionList();
     const startPosition = positionList[startIndex];
     const endPosition = positionList[endIndex];
+    if (!startPosition || !endPosition) return null;
     const startPageNo = startPosition.pageNo;
     const endPageNo = endPosition.pageNo;
     const startRowNo = startPosition.rowIndex;
     const endRowNo = endPosition.rowIndex;
-    const startRow = rowList[startRowNo];
-    const endRow = rowList[endRowNo];
+    const getRowStartPositionIndex = (targetIndex) => {
+      let rowStartIndex = targetIndex;
+      const targetPosition = positionList[targetIndex];
+      while (rowStartIndex > 0) {
+        const prePosition = positionList[rowStartIndex - 1];
+        if (!prePosition || prePosition.pageNo !== targetPosition.pageNo || prePosition.rowNo !== targetPosition.rowNo || prePosition.columnNo !== targetPosition.columnNo) {
+          break;
+        }
+        rowStartIndex--;
+      }
+      return rowStartIndex;
+    };
+    const startRowStartIndex = getRowStartPositionIndex(startIndex);
+    const endRowStartIndex = getRowStartPositionIndex(endIndex);
+    const startRowStartsWithZero = elementList[startRowStartIndex]?.value === ZERO;
+    const endRowStartsWithZero = elementList[endRowStartIndex]?.value === ZERO;
     let startColNo = 0;
     let endColNo = 0;
     if (!this.draw.getCursor().getHitLineStartIndex()) {
-      startColNo = startRow.elementList[0]?.value === ZERO ? startPosition.index - startRow.startIndex : startPosition.index - startRow.startIndex + 1;
+      startColNo = startRowStartsWithZero ? startIndex - startRowStartIndex : startIndex - startRowStartIndex + 1;
     }
     if (startPosition === endPosition) {
       endColNo = startColNo;
     } else {
-      endColNo = endRow.elementList[0]?.value === ZERO ? endPosition.index - endRow.startIndex : endPosition.index - endRow.startIndex + 1;
+      endColNo = endRowStartsWithZero ? endIndex - endRowStartIndex : endIndex - endRowStartIndex + 1;
     }
     const rangeRects = [];
     const height = this.draw.getOriginalHeight();
@@ -24258,6 +25395,7 @@ var CommandAdapt = class {
     const selectionPositionList = this.position.getSelectionPositionList();
     if (selectionPositionList) {
       let currentRowNo = null;
+      let currentPageNo = null;
       let currentX = 0;
       let rangeRect = null;
       for (let p = 0; p < selectionPositionList.length; p++) {
@@ -24267,7 +25405,7 @@ var CommandAdapt = class {
           coordinate: { leftTop, rightTop },
           lineHeight
         } = selectionPositionList[p];
-        if (currentRowNo === null || currentRowNo !== rowNo) {
+        if (currentRowNo === null || currentPageNo === null || currentRowNo !== rowNo || currentPageNo !== pageNo) {
           if (rangeRect) {
             rangeRects.push(rangeRect);
           }
@@ -24278,6 +25416,7 @@ var CommandAdapt = class {
             height: lineHeight
           };
           currentRowNo = rowNo;
+          currentPageNo = pageNo;
           currentX = leftTop[0];
         } else {
           rangeRect.width = rightTop[0] - currentX;