@windoc/core 0.3.19 → 0.3.21

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.3.19";
+var version = "0.3.21";
 
 // src/dataset/enum/Common.ts
 var MaxHeightRatio = /* @__PURE__ */ ((MaxHeightRatio2) => {
@@ -7324,6 +7324,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();
@@ -7365,6 +7430,18 @@ 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);
   }
@@ -7510,6 +7587,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();
@@ -9205,8 +9294,7 @@ var Position = class {
     return this.floatPositionList;
   }
   getTablePositionList(sourceElementList) {
-    const { index, trIndex, tdIndex } = this.positionContext;
-    return sourceElementList[index].trList[trIndex].tdList[tdIndex].positionList || [];
+    return this.draw.resolveTableCellContext(sourceElementList, this.positionContext)?.td.positionList || [];
   }
   getPositionList() {
     return this.positionContext.isTable ? this.getTablePositionList(this.draw.getOriginalElementList()) : this.getOriginalPositionList();
@@ -9860,6 +9948,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,
@@ -11576,13 +11704,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) {
@@ -11590,20 +11723,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();
@@ -11644,6 +11789,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++) {
@@ -11654,10 +11801,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;
@@ -11665,29 +11812,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;
@@ -11697,13 +11848,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;
@@ -11719,12 +11871,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();
@@ -11736,6 +11888,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) {
@@ -11748,12 +11916,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();
       }
     }
@@ -15163,7 +15331,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];
@@ -20416,6 +20589,7 @@ var Draw = class {
     this.intersectionPageNo = 0;
     this.lazyRenderIntersectionObserver = null;
     this.printModeData = null;
+    this.pendingTableCursorIndex = void 0;
     if (this.mode === "print" /* PRINT */) {
       this.setPrintData();
     }
@@ -20577,9 +20751,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];
     }
@@ -20663,6 +20836,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;
   }
@@ -20670,9 +20893,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();
@@ -20731,9 +20952,7 @@ var Draw = class {
     return this.header.getElementList();
   }
   getTableElementList(sourceElementList) {
-    const positionContext = this.position.getPositionContext();
-    const { index, trIndex, tdIndex } = positionContext;
-    return sourceElementList[index].trList?.[trIndex].tdList[tdIndex].value || [];
+    return this.resolveTableCellContext(sourceElementList)?.td.value || [];
   }
   getElementList() {
     const positionContext = this.position.getPositionContext();
@@ -20761,13 +20980,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;
@@ -21106,25 +21319,14 @@ var Draw = class {
   setPaperSize(width, height) {
     this.options.width = width;
     this.options.height = height;
-    const dpr = this.getPagePixelRatio();
-    const realWidth = this.getWidth();
-    const realHeight = this.getHeight();
-    this.container.style.width = `${realWidth}px`;
-    this.pageList.forEach((p, i) => {
-      p.width = realWidth * dpr;
-      p.height = realHeight * dpr;
-      p.style.width = `${realWidth}px`;
-      p.style.height = `${realHeight}px`;
-      this._initPageContext(this.ctxList[i]);
-    });
-    this.render({
-      isSubmitHistory: false,
-      isSetCursor: false
-    });
+    this.refreshPageSize();
   }
   setPaperDirection(payload) {
-    const dpr = this.getPagePixelRatio();
     this.options.paperDirection = payload;
+    this.refreshPageSize();
+  }
+  refreshPageSize() {
+    const dpr = this.getPagePixelRatio();
     const width = this.getWidth();
     const height = this.getHeight();
     this.container.style.width = `${width}px`;
@@ -21294,6 +21496,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,
@@ -21304,7 +21572,8 @@ var Draw = class {
       startY = 0,
       pageHeight = 0,
       mainOuterHeight = 0,
-      surroundElementList = []
+      surroundElementList = [],
+      initialListState
     } = payload;
     const {
       defaultSize,
@@ -21331,10 +21600,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];
@@ -21380,6 +21646,8 @@ var Draw = class {
         }
         metrics.boundingBoxAscent = 0;
       } else if (element.type === "table" /* TABLE */) {
+        let activeSplitRange;
+        let mergedSplitFallback;
         if (element.pagingId) {
           let tableIndex = i + 1;
           let combineCount = 0;
@@ -21400,11 +21668,61 @@ 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;
+              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;
         }
@@ -21419,6 +21737,7 @@ var Draw = class {
             const rowList2 = this.computeRowList({
               innerWidth: (td.width - cellPaddingWidth) * scale,
               elementList: td.value,
+              initialListState: td.splitListState,
               isFromTable: true,
               isPagingMode
             });
@@ -21501,6 +21820,7 @@ var Draw = class {
               const tdRowList = this.computeRowList({
                 innerWidth: (td.width - cellPaddingWidth) * scale,
                 elementList: td.value,
+                initialListState: td.splitListState,
                 isFromTable: true,
                 isPagingMode
               });
@@ -21594,6 +21914,178 @@ 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 initialListState2 = this.getListStateBeforeIndex(
+                          td.value,
+                          splitIdx
+                        );
+                        const overflowElements = deepClone(
+                          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;
+                        }
+                        const {
+                          value: _v,
+                          rowList: _rl,
+                          positionList: _pl,
+                          splitSyntheticLeadingZero: _slz,
+                          splitListState: _sls,
+                          ...tdMeta
+                        } = td;
+                        return {
+                          ...deepClone(tdMeta),
+                          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
+                    };
+                    const positionContext = this.position.getPositionContext();
+                    if (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(
@@ -21643,6 +22135,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;
               }
             }
           }
@@ -21775,39 +22282,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,
@@ -21859,7 +22334,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);
@@ -22528,6 +23003,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();
@@ -22593,6 +23069,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()) {
@@ -22634,9 +23114,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;
       }
@@ -24787,7 +25265,12 @@ var CommandAdapt = class {
     Object.keys(payload).forEach((key) => {
       Reflect.set(this.options, key, newOption[key]);
     });
-    this.forceUpdate();
+    const layoutKeys = ["paperDirection", "width", "height"];
+    if (layoutKeys.some((k) => k in payload)) {
+      this.draw.refreshPageSize();
+    } else {
+      this.forceUpdate();
+    }
     const { scale, paperDirection, width, height } = this.options;
     this.draw.getListener().optionsChange?.({ scale, paperDirection, width, height });
   }