quill-table-up 2.3.1 → 2.4.1

package/src/formats/table-main-format.ts

@@ -2,6 +2,7 @@ import type TypeScroll from 'quill/blots/scroll';
 import type { TableValue } from '../utils';
 import { blotName, tableUpSize } from '../utils';
 import { ContainerFormat } from './container-format';
+import { TableCellInnerFormat } from './table-cell-inner-format';
 import { TableColFormat } from './table-col-format';
 import { TableRowFormat } from './table-row-format';
 
@@ -128,7 +129,9 @@ export class TableMainFormat extends ContainerFormat {
   }
 
   getRows() {
-    return this.descendants(TableRowFormat);
+    return Array.from(this.domNode.querySelectorAll(`${TableRowFormat.tagName}`))
+      .map(el => this.scroll.find(el) as TableRowFormat)
+      .filter(Boolean);
   }
 
   getRowIds() {
@@ -159,6 +162,94 @@ export class TableMainFormat extends ContainerFormat {
     }
 
     super.optimize(context);
+    this.mergeRow();
+  }
+
+  // ensure row id unique in same table
+  mergeRow() {
+    if (!this.parent) return;
+    const rows = this.getRows();
+    const rowGroup: Record<string, TableRowFormat[]> = {};
+    for (const row of rows) {
+      if (!rowGroup[row.rowId]) rowGroup[row.rowId] = [];
+      rowGroup[row.rowId].push(row);
+    }
+
+    for (const rowList of Object.values(rowGroup)) {
+      for (let i = 1; i < rowList.length; i++) {
+        const row = rowList[i];
+        row.moveChildren(rowList[0]);
+        row.remove();
+      }
+    }
+  }
+
+  checkEmptyCol(autoMerge: boolean) {
+    if (autoMerge) {
+      const rowCount = this.getRows().length;
+      const cols = this.getCols();
+      const cells = this.descendants(TableCellInnerFormat);
+      for (const cell of cells) {
+        if (cell.colspan > 1 && cell.rowspan >= rowCount) {
+          const index = cols.findIndex(col => col.colId === cell.colId);
+          const currentCol = cols[index];
+          for (let i = index + 1; i < index + cell.colspan; i++) {
+            cols[i].remove();
+            currentCol.width += cols[i].width;
+          }
+          cell.colspan = 1;
+        }
+      }
+    }
+  }
+
+  checkEmptyRow(autoMerge: boolean) {
+    const rows = this.getRows();
+    const rowIds = new Set(rows.map(row => row.rowId));
+    for (let i = rows.length - 1; i >= 0; i--) {
+      const row = rows[i];
+      if (autoMerge) {
+        // reduce rowspan previou row
+        if (row.children.length === 0) {
+          for (let gap = 1, j = i - 1; j >= 0; j--, gap++) {
+            const prev = rows[j];
+            prev.foreachCellInner((cell) => {
+              if (cell.rowspan > gap) {
+                cell.rowspan -= 1;
+                const emptyRow = new Set(cell.emptyRow);
+                emptyRow.delete(row.rowId);
+                cell.emptyRow = Array.from(emptyRow);
+              }
+            });
+          }
+          row.remove();
+        }
+      }
+      else {
+        if (row.children.length === 0 && row.prev) {
+          // find the not empty row
+          let prev: TableRowFormat = row.prev as TableRowFormat;
+          while (prev && prev.children.length === 0) {
+            prev = prev.prev as TableRowFormat;
+          }
+          prev.foreachCellInner((cell) => {
+            const emptyRowIds = new Set(cell.emptyRow);
+            // prevent order change. like currnet emptyRow ['1', '2'] add rowId '2' will be ['2', '1']
+            if (!emptyRowIds.has(row.rowId)) {
+              // the loop is from back to front, and the rowId should be added to the head
+              cell.emptyRow = [row.rowId, ...emptyRowIds];
+            }
+          });
+        }
+        row.foreachCellInner((cell) => {
+          for (const emptyRow of cell.emptyRow) {
+            if (!rowIds.has(emptyRow)) {
+              row.parent.insertBefore(this.scroll.create(blotName.tableRow, { tableId: this.tableId, rowId: emptyRow }), row.next);
+            }
+          }
+        });
+      }
+    }
   }
 
   sortMergeChildren() {

package/src/formats/table-row-format.ts

@@ -157,13 +157,24 @@ export class TableRowFormat extends ContainerFormat {
     );
   }
 
-  optimize(context: Record<string, any>) {
+  optimize(_context: Record<string, any>) {
     const parent = this.parent;
     const { tableId } = this;
     if (parent !== null && parent.statics.blotName !== blotName.tableBody) {
       this.wrap(blotName.tableBody, tableId);
     }
 
-    super.optimize(context);
+    if (
+      this.statics.requiredContainer
+      && !(this.parent instanceof this.statics.requiredContainer)
+    ) {
+      this.wrap(this.statics.requiredContainer.blotName);
+    }
+
+    this.enforceAllowedChildren();
+    if (this.children.length > 0 && this.next != null && this.checkMerge()) {
+      this.next.moveChildren(this);
+      this.next.remove();
+    }
   }
 }

package/src/modules/table-clipboard.ts

@@ -46,9 +46,7 @@ function calculateCols(tableNode: HTMLElement, colNums: number): number[] {
 export class TableClipboard extends Clipboard {
   tableId = randomId();
   rowId = randomId();
-  rowIds: string[] = [];
   colIds: string[] = [];
-  emptyRowCount: number[] = [];
   rowspanCount: { rowspan: number; colspan: number }[] = [];
   cellCount = 0;
   colCount = 0;
@@ -69,16 +67,17 @@ export class TableClipboard extends Clipboard {
   matchTable(node: Node, delta: TypeDelta) {
     if (delta.ops.length === 0) return delta;
 
-    const preSumEmptyRowCount = this.emptyRowCount.reduce((acc, cur) => {
-      acc.push((acc[acc.length - 1] ?? 0) + cur);
-      return acc;
-    }, [] as number[]);
-
     const ops: Record<string, any>[] = [];
     const cols: Record<string, any>[] = [];
     let bodyStartIndex = -1;
     for (let i = 0; i < delta.ops.length; i++) {
       const { attributes, insert } = delta.ops[i];
+      // if attribute doesn't have tableCellInner, treat it as a blank line(emptyRow)
+      if (!isObject(insert) && attributes && !attributes[blotName.tableCellInner] && !attributes[blotName.tableCaption]) {
+        delta.ops.splice(i, 1);
+        i -= 1;
+        continue;
+      }
       // remove quill origin table format and tableCell format
       const { table, [blotName.tableCell]: tableCell, ...attrs } = attributes || {};
       const hasCol = isObject(insert) && insert[blotName.tableCol];
@@ -86,19 +85,7 @@ export class TableClipboard extends Clipboard {
         cols.push({ insert });
       }
       else {
-        if (attrs[blotName.tableCellInner]) {
-          const tableCellInner = attrs[blotName.tableCellInner] as TableCellValue;
-          const rowNum = this.rowIds.indexOf(tableCellInner.rowId);
-          // reduce cell rowspan by counting empty rows
-          if (rowNum !== -1) {
-            const rowspan = tableCellInner.rowspan;
-            tableCellInner.rowspan -= (preSumEmptyRowCount[rowNum + rowspan - 1] - preSumEmptyRowCount[rowNum]);
-          }
-          ops.push({ attributes: { ...attrs, [blotName.tableCellInner]: tableCellInner }, insert });
-        }
-        else {
-          ops.push({ attributes: attrs, insert });
-        }
+        ops.push({ attributes: attrs, insert });
       }
       // record col insert index
       if (
@@ -135,9 +122,7 @@ export class TableClipboard extends Clipboard {
 
     // reset variable to avoid conflict with other table
     this.tableId = randomId();
-    this.rowIds = [];
     this.colIds = [];
-    this.emptyRowCount = [];
     this.rowspanCount = [];
     this.cellCount = 0;
     this.colCount = 0;
@@ -158,6 +143,28 @@ export class TableClipboard extends Clipboard {
         }
       }
     }
+    // add `emptyRow`
+    let emptyRows = [];
+    for (let i = delta.ops.length - 1; i >= 0; i--) {
+      const op = delta.ops[i];
+      if (op.attributes) {
+        if (!op.attributes[blotName.tableCellInner]) {
+          emptyRows = [];
+          emptyRows.push(randomId());
+        }
+        else {
+          if ((op.attributes[blotName.tableCellInner] as TableCellValue).rowspan === 1) {
+            emptyRows = [];
+          }
+          else if (emptyRows.length > 0) {
+            if (!(op.attributes[blotName.tableCellInner] as TableCellValue).emptyRow) {
+              (op.attributes[blotName.tableCellInner] as TableCellValue).emptyRow = [];
+            }
+            (op.attributes[blotName.tableCellInner] as TableCellValue).emptyRow!.push(...emptyRows);
+          }
+        }
+      }
+    }
     return delta;
   }
 
@@ -173,6 +180,7 @@ export class TableClipboard extends Clipboard {
   }
 
   matchCol(node: Node, _delta: TypeDelta) {
+    // split col by span
     let span = Number((node as HTMLElement).getAttribute('span') || 1);
     if (Number.isNaN(span)) span = 1;
 
@@ -194,7 +202,6 @@ export class TableClipboard extends Clipboard {
   }
 
   matchTr(node: Node, delta: TypeDelta) {
-    this.rowIds.push(this.rowId);
     this.rowId = randomId();
     this.cellCount = 0;
     // minus rowspan
@@ -206,11 +213,9 @@ export class TableClipboard extends Clipboard {
         this.rowspanCount[i] = { rowspan: 0, colspan: 0 };
       }
     }
-    let hasTd = true;
     for (const op of delta.ops) {
       if (op.attributes) {
         const { background, [blotName.tableCellInner]: tableCellInner } = op.attributes;
-        if (!tableCellInner) hasTd = false;
         if (tableCellInner && background) {
           const { style = '' } = tableCellInner as TableCellValue;
           const styleObj = cssTextToObject(style);
@@ -218,17 +223,7 @@ export class TableClipboard extends Clipboard {
           (op.attributes![blotName.tableCellInner] as TableCellValue).style = objectToCssText(styleObj);
         }
       }
-      else {
-        hasTd = false;
-      }
-    }
-    // record if row doesn't have any cell. It's happen in excel. https://github.com/zzxming/quill-table-up/issues/165
-    let rowspanCount = 0;
-    if (!hasTd) {
-      rowspanCount = 1;
-      delta = new Delta();
     }
-    this.emptyRowCount.push(rowspanCount);
     return delta;
   }
 

package/src/modules/table-resize/table-resize-box.ts

@@ -187,7 +187,7 @@ export class TableResizeBox extends TableResizeCommon {
 
   update() {
     const { rect: tableRect, body: tableBodyBlot } = getTableMainRect(this.tableMain);
-    if (!tableBodyBlot) return;
+    if (!tableBodyBlot || !tableRect) return;
     const tableWrapperRect = this.tableWrapper.domNode.getBoundingClientRect();
     const rootRect = this.quill.root.getBoundingClientRect();
     Object.assign(this.root.style, {
@@ -238,7 +238,7 @@ export class TableResizeBox extends TableResizeCommon {
     this.tableRows = this.tableMain.getRows();
     this.root.innerHTML = '';
     const { rect: tableRect, body: tableBodyBlot } = getTableMainRect(this.tableMain);
-    if (!tableBodyBlot) return;
+    if (!tableBodyBlot || !tableRect) return;
     const tableWrapperRect = this.tableWrapper.domNode.getBoundingClientRect();
 
     if (this.tableCols.length > 0 && this.tableRows.length > 0) {

package/src/modules/table-resize/table-resize-common.ts

@@ -255,7 +255,7 @@ export class TableResizeCommon {
     e.preventDefault();
     if (!this.tableMain) return;
     const { rect: tableRect, body: tableBodyBlot } = getTableMainRect(this.tableMain);
-    if (!tableBodyBlot) return;
+    if (!tableBodyBlot || !tableRect) return;
     // set drag init width
     const cols = this.tableMain.getCols();
     this.colIndex = this.findCurrentColIndex(e);
@@ -269,8 +269,7 @@ export class TableResizeCommon {
     this.dragging = true;
 
     const divDom = document.createElement('div');
-    divDom.classList.add(this.dragBEM.b());
-    divDom.classList.add(this.dragBEM.is('col'));
+    divDom.classList.add(this.dragBEM.b(), this.dragBEM.is('col'));
     divDom.dataset.w = String(width);
 
     const styleValue = {
@@ -350,8 +349,7 @@ export class TableResizeCommon {
     const tableMainRect = this.tableMain.domNode.getBoundingClientRect();
 
     const divDom = document.createElement('div');
-    divDom.classList.add(this.dragBEM.b());
-    divDom.classList.add(this.dragBEM.is('row'));
+    divDom.classList.add(this.dragBEM.b(), this.dragBEM.is('row'));
     divDom.dataset.h = String(height);
 
     const styleValue = {

package/src/modules/table-resize/table-resize-line.ts

@@ -64,7 +64,7 @@ export class TableResizeLine extends TableResizeCommon {
   }
 
   findCurrentColIndex() {
-    return this.curColIndex;
+    return this.curColIndex + (this.tableCellBlot?.colspan || 1) - 1;
   }
 
   handleColMouseUpFunc = async function (this: TableResizeLine) {

package/src/modules/table-resize/table-resize-scale.ts

@@ -116,7 +116,7 @@ export class TableResizeScale {
       return;
     }
     const { rect: tableRect, body: tableBodyBlot } = getTableMainRect(this.tableMainBlot);
-    if (!tableBodyBlot) return;
+    if (!tableBodyBlot || !tableRect) return;
     const tableWrapperRect = this.tableWrapperBlot.domNode.getBoundingClientRect();
     const editorRect = this.quill.root.getBoundingClientRect();
     const { scrollTop, scrollLeft } = this.tableWrapperBlot.domNode;

package/src/modules/table-scrollbar.ts

@@ -19,9 +19,9 @@ export class Scrollbar {
     X: number;
     Y: number;
   } = {
-      X: 0,
-      Y: 0,
-    };
+    X: 0,
+    Y: 0,
+  };
 
   ob: ResizeObserver;
   container: HTMLElement;
@@ -70,8 +70,8 @@ export class Scrollbar {
   }
 
   setScrollbarPosition() {
-    const { rect: { width: tableWidth, height: tableHeight }, body: tableBodyBlot } = getTableMainRect(this.tableMainBlot);
-    if (!tableBodyBlot) return;
+    const { rect: tableRect, body: tableBodyBlot } = getTableMainRect(this.tableMainBlot);
+    if (!tableBodyBlot || !tableRect) return;
     const { scrollLeft: editorScrollX, scrollTop: editorScrollY, offsetLeft: rootOffsetLeft, offsetTop: rootOffsetTop } = this.quill.root;
     const { offsetLeft: containerOffsetLeft, offsetTop: containerOffsetTop } = this.container;
     const { offsetLeft: bodyOffsetLeft, offsetTop: bodyOffsetTop } = tableBodyBlot.domNode;
@@ -80,10 +80,10 @@ export class Scrollbar {
     let x = containerOffsetLeft + bodyOffsetLeft - rootOffsetLeft;
     let y = containerOffsetTop + bodyOffsetTop - rootOffsetTop;
     if (this.isVertical) {
-      x += Math.min(containerWidth, tableWidth);
+      x += Math.min(containerWidth, tableRect.width);
     }
     else {
-      y += Math.min(containerHeight, tableHeight);
+      y += Math.min(containerHeight, tableRect.height);
     }
 
     // table align right effect
@@ -92,7 +92,7 @@ export class Scrollbar {
     }
 
     Object.assign(this.scrollbar.style, {
-      [this.propertyMap.size]: `${this.isVertical ? Math.min(containerHeight, tableHeight) : containerWidth}px`,
+      [this.propertyMap.size]: `${this.isVertical ? Math.min(containerHeight, tableRect.height) : containerWidth}px`,
       transform: `translate(${x - editorScrollX}px, ${y - editorScrollY}px)`,
     });
     this.containerScrollHandler(this.container);
@@ -115,8 +115,7 @@ export class Scrollbar {
 
   createScrollbar() {
     const scrollbar = document.createElement('div');
-    scrollbar.classList.add(this.bem.b());
-    scrollbar.classList.add(this.isVertical ? this.bem.is('vertical') : this.bem.is('horizontal'), this.bem.is('transparent'));
+    scrollbar.classList.add(this.bem.b(), this.isVertical ? this.bem.is('vertical') : this.bem.is('horizontal'), this.bem.is('transparent'));
     Object.assign(scrollbar.style, {
       display: 'none',
     });

package/src/modules/table-selection.ts

@@ -4,7 +4,7 @@ import type { TableUp } from '../table-up';
 import type { InternalTableMenuModule, RelactiveRect, TableSelectionOptions } from '../utils';
 import Quill from 'quill';
 import { getTableMainRect, TableBodyFormat, TableCellFormat, TableCellInnerFormat } from '../formats';
-import { addScrollEvent, blotName, clearScrollEvent, createBEM, createResizeObserver, findAllParentBlot, findParentBlot, getRelativeRect, isRectanglesIntersect, tableUpEvent } from '../utils';
+import { addScrollEvent, blotName, clearScrollEvent, createBEM, createResizeObserver, findAllParentBlot, findParentBlot, getElementScroll, getRelativeRect, isRectanglesIntersect, tableUpEvent } from '../utils';
 
 const ERROR_LIMIT = 0;
 
@@ -18,8 +18,8 @@ export interface SelectionData {
 export class TableSelection {
   options: TableSelectionOptions;
   boundary: RelactiveRect | null = null;
-  startScrollX: number = 0;
-  startScrollY: number = 0;
+  scrollRecordEls: HTMLElement[] = [];
+  startScrollRecordPosition: { x: number; y: number }[] = [];
   selectedTableScrollX: number = 0;
   selectedTableScrollY: number = 0;
   selectedEditorScrollX: number = 0;
@@ -43,6 +43,7 @@ export class TableSelection {
 
   constructor(public tableModule: TableUp, public quill: Quill, options: Partial<TableSelectionOptions> = {}) {
     this.options = this.resolveOptions(options);
+    this.scrollRecordEls = [this.quill.root, document.documentElement];
 
     this.cellSelectWrap = tableModule.addContainer(this.bem.b());
     this.cellSelect = this.helpLinesInitial();
@@ -310,17 +311,12 @@ export class TableSelection {
       }),
     );
 
-    const { x: tableScrollX, y: tableScrollY } = this.getTableViewScroll();
-    const { x: editorScrollX, y: editorScrollY } = this.getQuillViewScroll();
-    this.selectedTableScrollX = tableScrollX;
-    this.selectedTableScrollY = tableScrollY;
-    this.selectedEditorScrollX = editorScrollX;
-    this.selectedEditorScrollY = editorScrollY;
-
+    const scrollDiff = this.getScrollPositionDiff();
     // set boundary to initially mouse move rectangle
     const { rect: tableRect } = getTableMainRect(tableMainBlot);
-    const startPointX = startPoint.x - tableScrollX + this.startScrollX;
-    const startPointY = startPoint.y - tableScrollY + this.startScrollY;
+    if (!tableRect) return [];
+    const startPointX = startPoint.x + scrollDiff.x;
+    const startPointY = startPoint.y + scrollDiff.y;
     let boundary = {
       x: Math.max(tableRect.left, Math.min(endPoint.x, startPointX)),
       y: Math.max(tableRect.top, Math.min(endPoint.y, startPointY)),
@@ -379,15 +375,44 @@ export class TableSelection {
     });
   }
 
+  getScrollPositionDiff() {
+    const { x: tableScrollX, y: tableScrollY } = this.getTableViewScroll();
+    const { x: editorScrollX, y: editorScrollY } = getElementScroll(this.quill.root);
+    this.selectedTableScrollX = tableScrollX;
+    this.selectedTableScrollY = tableScrollY;
+    this.selectedEditorScrollX = editorScrollX;
+    this.selectedEditorScrollY = editorScrollY;
+
+    return this.startScrollRecordPosition.reduce((pre, { x, y }, i) => {
+      const { x: currentX, y: currentY } = getElementScroll(this.scrollRecordEls[i]);
+      pre.x += x - currentX;
+      pre.y += y - currentY;
+      return pre;
+    }, { x: 0, y: 0 });
+  }
+
+  recordScrollPosition() {
+    this.clearRecordScrollPosition();
+    for (const el of this.scrollRecordEls) {
+      this.startScrollRecordPosition.push(getElementScroll(el));
+    }
+  }
+
+  clearRecordScrollPosition() {
+    this.startScrollRecordPosition = [];
+  }
+
   mouseDownHandler = (mousedownEvent: MouseEvent) => {
     const { button, target, clientX, clientY } = mousedownEvent;
     const closestTable = (target as HTMLElement).closest<HTMLTableElement>('.ql-table');
-    const closestTableBody = (target as HTMLElement).closest<HTMLTableSectionElement>('tbody');
-    if (button !== 0 || !closestTable || !closestTableBody) return;
+    const closestTableCaption = (target as HTMLElement).closest('caption');
+    if (button !== 0 || !closestTable || closestTableCaption) return;
 
     this.setSelectionTable(closestTable);
     const startTableId = closestTable.dataset.tableId;
     const startPoint = { x: clientX, y: clientY };
+
+    this.recordScrollPosition();
     this.selectedTds = this.computeSelectedTds(startPoint, startPoint);
     this.dragging = true;
     this.show();
@@ -400,11 +425,12 @@ export class TableSelection {
         this.tableModule.tableResize.hide();
       }
       const { button, target, clientX, clientY } = mousemoveEvent;
-      const closestTableBody = (target as HTMLElement).closest<HTMLTableSectionElement>('tbody');
+      const closestTable = (target as HTMLElement).closest<HTMLTableElement>('.ql-table');
+      const closestTableCaption = (target as HTMLElement).closest('caption');
       if (
         button !== 0
-        || !closestTableBody
-        || closestTableBody.dataset.tableId !== startTableId
+        || closestTableCaption
+        || !closestTable || closestTable.dataset.tableId !== startTableId
       ) {
         return;
       }
@@ -420,6 +446,7 @@ export class TableSelection {
       document.body.removeEventListener('mousemove', mouseMoveHandler, false);
       document.body.removeEventListener('mouseup', mouseUpHandler, false);
       this.dragging = false;
+      this.clearRecordScrollPosition();
       if (this.tableMenu && this.selectedTds.length > 0) {
         this.tableMenu.show();
       }
@@ -451,14 +478,12 @@ export class TableSelection {
 
   update() {
     if (this.selectedTds.length === 0 || !this.boundary || !this.table) return;
-    const { x: editorScrollX, y: editorScrollY } = this.getQuillViewScroll();
+    const { x: editorScrollX, y: editorScrollY } = getElementScroll(this.quill.root);
     const { x: tableScrollX, y: tableScrollY } = this.getTableViewScroll();
     const tableWrapperRect = this.table.parentElement!.getBoundingClientRect();
     const rootRect = this.quill.root.getBoundingClientRect();
     const wrapLeft = tableWrapperRect.x - rootRect.x;
     const wrapTop = tableWrapperRect.y - rootRect.y;
-    this.startScrollX = tableScrollX;
-    this.startScrollY = tableScrollY;
 
     Object.assign(this.cellSelect.style, {
       left: `${this.selectedEditorScrollX * 2 - editorScrollX + this.boundary.x + this.selectedTableScrollX - tableScrollX - wrapLeft}px`,
@@ -477,13 +502,6 @@ export class TableSelection {
     }
   }
 
-  getQuillViewScroll() {
-    return {
-      x: this.quill.root.scrollLeft,
-      y: this.quill.root.scrollTop,
-    };
-  }
-
   getTableViewScroll() {
     if (!this.table) {
       return {
@@ -491,15 +509,18 @@ export class TableSelection {
         y: 0,
       };
     }
-    return {
-      x: this.table.parentElement!.scrollLeft,
-      y: this.table.parentElement!.scrollTop,
-    };
+    return getElementScroll(this.table.parentElement!);
   }
 
   setSelectionTable(table: HTMLTableElement | undefined) {
     if (this.table === table) return;
     this.table = table;
+    if (this.table) {
+      this.scrollRecordEls.push(this.table.parentElement!);
+    }
+    else {
+      this.scrollRecordEls.pop();
+    }
   }
 
   removeCell = (e: KeyboardEvent) => {

package/src/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +1 @@
-{"version":"3.2.3","results":[[":__tests__/unit/utils.test-d.ts",{"duration":0,"failed":false}],[":__tests__/unit/table-clipboard.test.ts",{"duration":4809.0661,"failed":false}],[":__tests__/unit/table-redo-undo.test.ts",{"duration":7201.539700000008,"failed":false}],[":__tests__/unit/table-hack.test.ts",{"duration":2535.698,"failed":false}],[":__tests__/unit/table-insert.test.ts",{"duration":4301.950499999992,"failed":false}],[":__tests__/unit/table-cell-merge.test.ts",{"duration":2150.3714999999997,"failed":false}],[":__tests__/unit/table-blots.test.ts",{"duration":1530.4263,"failed":false}],[":__tests__/unit/utils.test.ts",{"duration":606.7640000000001,"failed":false}],[":__tests__/unit/table-remove.test.ts",{"duration":1883.1297999999997,"failed":false}],[":__tests__/unit/table-caption.test.ts",{"duration":863.3289,"failed":false}]]}
+{"version":"3.2.3","results":[[":__tests__/unit/utils.test-d.ts",{"duration":0,"failed":false}],[":__tests__/unit/table-clipboard.test.ts",{"duration":3198.3800000000047,"failed":false}],[":__tests__/unit/table-redo-undo.test.ts",{"duration":8473.984600000002,"failed":false}],[":__tests__/unit/table-hack.test.ts",{"duration":2830.0276,"failed":false}],[":__tests__/unit/table-insert.test.ts",{"duration":4750.2608,"failed":false}],[":__tests__/unit/table-cell-merge.test.ts",{"duration":3491.4125,"failed":false}],[":__tests__/unit/table-blots.test.ts",{"duration":2240.7780000000002,"failed":false}],[":__tests__/unit/utils.test.ts",{"duration":640.7419,"failed":false}],[":__tests__/unit/table-remove.test.ts",{"duration":2719.4262,"failed":false}],[":__tests__/unit/table-caption.test.ts",{"duration":1264.7592,"failed":false}]]}