@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/es2019/utils/changed-descendants.js

@@ -0,0 +1,27 @@
+// Helper for iterating through the nodes in a document that changed
+// compared to the given previous document. Useful for avoiding
+// duplicate work on each transaction.
+export function changedDescendants(old, cur, offsetStart, f) {
+  let offset = offsetStart;
+  const oldSize = old.childCount;
+  const curSize = cur.childCount;
+  // eslint-disable-next-line no-labels
+  outer: for (let i = 0, j = 0; i < curSize; i++) {
+    const child = cur.child(i);
+    for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
+      if (old.child(scan) === child) {
+        j = scan + 1;
+        offset += child.nodeSize;
+        // eslint-disable-next-line no-continue, no-labels
+        continue outer;
+      }
+    }
+    f(child, offset);
+    if (j < oldSize && old.child(j).sameMarkup(child)) {
+      changedDescendants(old.child(j), child, offset + 1, f);
+    } else {
+      child.nodesBetween(0, child.content.size, f, offset + 1);
+    }
+    offset += child.nodeSize;
+  }
+}

package/dist/es2019/utils/clip-cells.js

@@ -0,0 +1,75 @@
+// Utilities used for copy/paste handling.
+//
+// This module handles pasting cell content into tables, or pasting
+// anything into a cell selection, as replacing a block of cells with
+// the content of the selection. When pasting cells into a cell, that
+// involves placing the block of pasted content so that its top left
+// aligns with the selection cell, optionally extending the table to
+// the right or bottom to make sure it is large enough. Pasting into a
+// cell selection is different, here the cells in the selection are
+// clipped to the selection's rectangle, optionally repeating the
+// pasted cells when they are smaller than the selection.
+
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { removeColSpan } from './remove-col-span';
+
+// : ({width: number, height: number, rows: [Fragment]}, number, number) → {width: number, height: number, rows: [Fragment]}
+// Clip or extend (repeat) the given set of cells to cover the given
+// width and height. Will clip rowspan/colspan cells at the edges when
+// they stick out.
+export function clipCells({
+  width: currentWidth,
+  height: currentHeight,
+  rows: currentRows
+}, newWidth, newHeight) {
+  let rows = currentRows;
+  let width = currentWidth;
+  let height = currentHeight;
+  if (width !== newWidth) {
+    const added = [];
+    const newRows = [];
+    for (let row = 0; row < rows.length; row++) {
+      const frag = rows[row];
+      const cells = [];
+      for (let col = added[row] || 0, i = 0; col < newWidth; i++) {
+        let cell = frag.child(i % frag.childCount);
+        if (col + cell.attrs.colspan > newWidth) {
+          cell = cell.type.create(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
+        }
+        cells.push(cell);
+        col += cell.attrs.colspan;
+        for (let j = 1; j < cell.attrs.rowspan; j++) {
+          added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
+        }
+      }
+      newRows.push(Fragment.from(cells));
+    }
+    rows = newRows;
+    width = newWidth;
+  }
+  if (height !== newHeight) {
+    const newRows = [];
+    for (let row = 0, i = 0; row < newHeight; row++, i++) {
+      const cells = [];
+      const source = rows[i % height];
+      for (let j = 0; j < source.childCount; j++) {
+        let cell = source.child(j);
+        if (row + cell.attrs.rowspan > newHeight) {
+          cell = cell.type.create({
+            ...cell.attrs,
+            rowspan: Math.max(1, newHeight - cell.attrs.rowspan)
+          }, cell.content);
+        }
+        cells.push(cell);
+      }
+      newRows.push(Fragment.from(cells));
+    }
+    rows = newRows;
+    height = newHeight;
+  }
+  return {
+    width,
+    height,
+    rows
+  };
+}

package/dist/es2019/utils/clone-column.js

@@ -2,9 +2,9 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { determineTableHeaderStateFromTableNode } from './analyse-table';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
+import { findTable } from './find-table';
 import { getSelectionRangeInColumn } from './get-selection-range-in-column';
-import { isValidReorder } from './reorder-utils';
+import { isValidReorder } from './is-valid-reorder';
 import { tableNodeTypes } from './table-node-types';
 function normalizeDirection(targetDirection, options) {
   var _options$direction;

package/dist/es2019/utils/clone-row-at.js

@@ -0,0 +1,71 @@
+import { safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { TableMap } from '../table-map';
+import { findTable } from './find-table';
+import { getCellsInRow } from './get-cells-in-row';
+import { setCellAttrs } from './set-cell-attrs';
+import { tableNodeTypes } from './table-node-types';
+const filterCellsInRow = (rowIndex, predicate) => tr => {
+  const foundCells = [];
+  const cells = getCellsInRow(rowIndex)(tr.selection);
+  if (cells) {
+    for (let j = cells.length - 1; j >= 0; j--) {
+      if (predicate(cells[j], tr)) {
+        foundCells.push(cells[j]);
+      }
+    }
+  }
+  return foundCells;
+};
+
+// Returns a new transaction that adds a new row after `cloneRowIndex`, cloning the row attributes at `cloneRowIndex`.
+export const cloneRowAt = rowIndex => tr => {
+  const table = findTable(tr.selection);
+  if (table) {
+    const map = TableMap.get(table.node);
+    if (rowIndex >= 0 && rowIndex <= map.height) {
+      const tableNode = table.node;
+      const tableNodes = tableNodeTypes(tableNode.type.schema);
+      let rowPos = table.start;
+      for (let i = 0; i < rowIndex + 1; i++) {
+        rowPos += tableNode.child(i).nodeSize;
+      }
+      const cloneRow = tableNode.child(rowIndex);
+      // Re-create the same nodes with same attrs, dropping the node content.
+      const cells = [];
+      let rowWidth = 0;
+      cloneRow.forEach(cell => {
+        // If we're copying a row with rowspan somewhere, we dont want to copy that cell
+        // We'll increment its span below.
+        if (cell.attrs.rowspan === 1) {
+          rowWidth += cell.attrs.colspan;
+          const node = tableNodes[cell.type.spec.tableRole].createAndFill(cell.attrs, [], cell.marks);
+          if (node) {
+            cells.push(node);
+          }
+        }
+      });
+
+      // If a higher row spans past our clone row, bump the higher row to cover this new row too.
+      if (rowWidth < map.width) {
+        const rowSpanCells = [];
+        for (let i = rowIndex; i >= 0; i--) {
+          const foundCells = filterCellsInRow(i, (cell, _tr) => {
+            const rowspan = cell.node.attrs.rowspan;
+            const spanRange = i + rowspan;
+            return rowspan > 1 && spanRange > rowIndex;
+          })(tr);
+          rowSpanCells.push(...foundCells);
+        }
+        if (rowSpanCells.length) {
+          rowSpanCells.forEach(cell => {
+            tr = setCellAttrs(cell, {
+              rowspan: cell.node.attrs.rowspan + 1
+            })(tr);
+          });
+        }
+      }
+      return safeInsert(tableNodes.row.create(cloneRow.attrs, cells), rowPos)(tr);
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/clone-row.js

@@ -2,9 +2,9 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { determineTableHeaderStateFromTableNode } from './analyse-table';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
+import { findTable } from './find-table';
 import { getSelectionRangeInRow } from './get-selection-range-in-row';
-import { isValidReorder } from './reorder-utils';
+import { isValidReorder } from './is-valid-reorder';
 import { tableNodeTypes } from './table-node-types';
 function normalizeDirection(targetDirection, options) {
   var _options$direction;

package/dist/es2019/utils/colspan.js

@@ -1,41 +1,17 @@
-export function removeColSpan(attrs, pos, n = 1) {
-  if (!attrs.colspan) {
-    throw new Error('removeColSpan(): attrs.colspan not defined');
-  }
-  const result = {
-    ...attrs,
-    colspan: attrs.colspan - n
-  };
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-    result.colwidth.splice(pos, n);
-    if (!result.colwidth.some(w => w > 0)) {
-      result.colwidth = undefined;
-    }
-  }
-  return result;
-}
-export function assertColspan(attrs) {
-  if (typeof attrs.colspan === 'undefined') {
-    throw new Error('addColSpan: attrs.colspan is not defined');
-  }
-  if (typeof attrs.colspan !== 'number' || Number.isNaN(attrs.colspan) || attrs.colspan < 1) {
-    throw new Error(`addColSpan: attrs.colspan must be number >= 1, received: ${attrs.colspan}`);
-  }
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// TODO: ED-26961 - replace "addColSpan" from table plugin with this function
-export function addColSpan(attrs, pos, n = 1) {
-  assertColspan(attrs);
-  const result = {
-    ...attrs,
-    colspan: attrs.colspan + n
-  };
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-    for (let i = 0; i < n; i++) {
-      result.colwidth.splice(pos, 0, 0);
-    }
-  }
-  return result;
-}
+/**
+ * @deprecated Use `import { removeColSpan } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { removeColSpan } from './remove-col-span';
+/**
+ * @deprecated Use `import { assertColspan } from '@atlaskit/editor-tables/utils/colspan'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { assertColspan } from './assert-colspan';
+/**
+ * @deprecated Use `import { addColSpan } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { addColSpan } from './add-col-span';

package/dist/es2019/utils/column-is-header.js

@@ -0,0 +1,11 @@
+import { tableNodeTypes } from './table-node-types';
+export function columnIsHeader(map, table, col) {
+  const headerCell = tableNodeTypes(table.type.schema).header_cell;
+  for (let row = 0; row < map.height; row++) {
+    const cell = table.nodeAt(map.map[col + row * map.width]);
+    if (cell && cell.type !== headerCell) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/es2019/utils/convert-array-of-rows-to-table-node.js

@@ -0,0 +1,51 @@
+import { TableMap } from '../table-map';
+// :: (tableNode: Node, tableArray: Array<Node>) -> Node
+// This function will transform a matrix of nodes
+// into table node respecting merged cells and rows configurations,
+// for example this array will be convert to the table below:
+//
+// ```javascript
+// array = [
+//   [A1, B1, C1, null],
+//   [A2, B2, null, D1],
+//   [A3. B3, C2, null],
+// ]
+// ```
+//
+// ```
+//  ____________________________
+// |      |      |             |
+// |  A1  |  B1  |     C1      |
+// |______|______|______ ______|
+// |      |             |      |
+// |  A2  |     B2      |      |
+// |______|______ ______|      |
+// |      |      |      |  D1  |
+// |  A3  |  B3  |  C2  |      |
+// |______|______|______|______|
+// ```
+//
+export const convertArrayOfRowsToTableNode = (tableNode, arrayOfNodes) => {
+  const rowsPM = [];
+  const map = TableMap.get(tableNode);
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const row = tableNode.child(rowIndex);
+    const rowCells = [];
+    for (let colIndex = 0; colIndex < map.width; colIndex++) {
+      if (!arrayOfNodes[rowIndex][colIndex]) {
+        continue;
+      }
+      const cellPos = map.map[rowIndex * map.width + colIndex];
+      const cell = arrayOfNodes[rowIndex][colIndex];
+      const oldCell = tableNode.nodeAt(cellPos);
+      if (!cell || !oldCell) {
+        continue;
+      }
+      const newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
+      rowCells.push(newCell);
+    }
+    rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+  }
+  const newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
+  return newTable;
+};

package/dist/es2019/utils/convert-table-node-to-array-of-rows.js

@@ -0,0 +1,48 @@
+import { TableMap } from '../table-map';
+// :: (tableNode: Node) -> Array<Node>
+// This function will transform the table node
+// into a matrix of rows and columns respecting merged cells,
+// for example this table will be convert to the below:
+//
+// ```
+//  ____________________________
+// |      |      |             |
+// |  A1  |  B1  |     C1      |
+// |______|______|______ ______|
+// |      |             |      |
+// |  A2  |     B2      |      |
+// |______|______ ______|      |
+// |      |      |      |  D1  |
+// |  A3  |  B3  |  C2  |      |
+// |______|______|______|______|
+// ```
+//
+//
+// ```javascript
+// array = [
+//   [A1, B1, C1, null],
+//   [A2, B2, null, D1],
+//   [A3. B3, C2, null],
+// ]
+// ```
+export const convertTableNodeToArrayOfRows = tableNode => {
+  const map = TableMap.get(tableNode);
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const rowCells = [];
+    const seen = {};
+    for (let colIndex = 0; colIndex < map.width; colIndex++) {
+      const cellPos = map.map[rowIndex * map.width + colIndex];
+      const cell = tableNode.nodeAt(cellPos);
+      const rect = map.findCell(cellPos);
+      if (!cell || seen[cellPos] || rect.top !== rowIndex) {
+        rowCells.push(null);
+        continue;
+      }
+      seen[cellPos] = true;
+      rowCells.push(cell);
+    }
+    rows.push(rowCells);
+  }
+  return rows;
+};

package/dist/es2019/utils/find-cell-closest-to-pos.js

@@ -0,0 +1,10 @@
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+// Ignored via go/ees005
+// eslint-disable-next-line require-unicode-regexp
+const CELL_ROLE_REGEX = /cell/i;
+
+// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
+export const findCellClosestToPos = $pos => {
+  const predicate = node => node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
+  return findParentNodeClosestToPos($pos, predicate);
+};

package/dist/es2019/utils/find-cell-rect-closest-to-pos.js

@@ -0,0 +1,16 @@
+import { TableMap } from '../table-map';
+import { findCellClosestToPos } from './find-cell-closest-to-pos';
+import { findTableClosestToPos } from './find-table-closest-to-pos';
+
+// Returns the rectangle spanning a cell closest to a given `$pos`.
+export const findCellRectClosestToPos = $pos => {
+  const cell = findCellClosestToPos($pos);
+  if (cell) {
+    const table = findTableClosestToPos($pos);
+    if (table) {
+      const map = TableMap.get(table.node);
+      const cellPos = cell.pos - table.start;
+      return map.rectBetween(cellPos, cellPos);
+    }
+  }
+};

package/dist/es2019/utils/find-table-closest-to-pos.js

@@ -0,0 +1,6 @@
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+// Iterates over parent nodes, returning a table node closest to a given `$pos`.
+export const findTableClosestToPos = $pos => {
+  const predicate = node => node.type.spec.tableRole && node.type.spec.tableRole === 'table';
+  return findParentNodeClosestToPos($pos, predicate);
+};

package/dist/es2019/utils/find-table.js

@@ -0,0 +1,3 @@
+import { findParentNode } from '@atlaskit/editor-prosemirror/utils';
+// Iterates over parent nodes, returning the closest table node.
+export const findTable = selection => findParentNode(node => node.type.spec.tableRole && node.type.spec.tableRole === 'table')(selection);

package/dist/es2019/utils/find.js

@@ -1,33 +1,22 @@
-import { findParentNode, findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
-import { TableMap } from '../table-map';
-// Ignored via go/ees005
-// eslint-disable-next-line require-unicode-regexp
-const CELL_ROLE_REGEX = /cell/i;
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// Iterates over parent nodes, returning the closest table node.
-export const findTable = selection => findParentNode(node => node.type.spec.tableRole && node.type.spec.tableRole === 'table')(selection);
-
-// Iterates over parent nodes, returning a table node closest to a given `$pos`.
-export const findTableClosestToPos = $pos => {
-  const predicate = node => node.type.spec.tableRole && node.type.spec.tableRole === 'table';
-  return findParentNodeClosestToPos($pos, predicate);
-};
-
-// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
-export const findCellClosestToPos = $pos => {
-  const predicate = node => node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
-  return findParentNodeClosestToPos($pos, predicate);
-};
-
-// Returns the rectangle spanning a cell closest to a given `$pos`.
-export const findCellRectClosestToPos = $pos => {
-  const cell = findCellClosestToPos($pos);
-  if (cell) {
-    const table = findTableClosestToPos($pos);
-    if (table) {
-      const map = TableMap.get(table.node);
-      const cellPos = cell.pos - table.start;
-      return map.rectBetween(cellPos, cellPos);
-    }
-  }
-};
+/**
+ * @deprecated Use `import { findTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findTable } from './find-table';
+/**
+ * @deprecated Use `import { findTableClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findTableClosestToPos } from './find-table-closest-to-pos';
+/**
+ * @deprecated Use `import { findCellClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findCellClosestToPos } from './find-cell-closest-to-pos';
+/**
+ * @deprecated Use `import { findCellRectClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findCellRectClosestToPos } from './find-cell-rect-closest-to-pos';

package/dist/es2019/utils/fit-slice.js

@@ -0,0 +1,21 @@
+// Utilities used for copy/paste handling.
+//
+// This module handles pasting cell content into tables, or pasting
+// anything into a cell selection, as replacing a block of cells with
+// the content of the selection. When pasting cells into a cell, that
+// involves placing the block of pasted content so that its top left
+// aligns with the selection cell, optionally extending the table to
+// the right or bottom to make sure it is large enough. Pasting into a
+// cell selection is different, here the cells in the selection are
+// clipped to the selection's rectangle, optionally repeating the
+// pasted cells when they are smaller than the selection.
+
+import { Transform } from '@atlaskit/editor-prosemirror/transform';
+export function fitSlice(nodeType, slice) {
+  const node = nodeType.createAndFill();
+  if (!node) {
+    throw new Error(`fitSlice: unable to create node`);
+  }
+  const tr = new Transform(node).replace(0, node.content.size, slice);
+  return tr.doc;
+}

package/dist/es2019/utils/fix-table.js

@@ -0,0 +1,105 @@
+import { fixTablesKey } from '../pm-plugins/plugin-key';
+import { TableMap, TableProblemTypes } from '../table-map';
+import { removeColSpan } from './remove-col-span';
+import { tableNodeTypes } from './table-node-types';
+
+// : (EditorState, Node, number, ?Transaction) → ?Transaction
+// Fix the given table, if necessary. Will append to the transaction
+// it was given, if non-null, or create a new one if necessary.
+export function fixTable(state, table, tablePos, transaction, reportFixedTable) {
+  let tr = transaction;
+  const map = TableMap.get(table);
+  if (!map.problems) {
+    return tr;
+  }
+  if (!tr) {
+    tr = state.tr;
+  }
+
+  // Track which rows we must add cells to, so that we can adjust that
+  // when fixing collisions.
+  const mustAdd = [];
+  for (let i = 0; i < map.height; i++) {
+    mustAdd.push(0);
+  }
+  for (let i = 0; i < map.problems.length; i++) {
+    const prob = map.problems[i];
+    if (reportFixedTable) {
+      reportFixedTable({
+        state,
+        tr,
+        reason: prob.type || 'unknown'
+      });
+    }
+    if (prob.type === TableProblemTypes.COLLISION) {
+      const collision = prob;
+      const cell = table.nodeAt(prob.pos);
+      if (!cell) {
+        throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
+      }
+      for (let j = 0; j < cell.attrs.rowspan; j++) {
+        mustAdd[collision.row + j] += collision.n;
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, removeColSpan(cell.attrs, cell.attrs.colspan - collision.n, collision.n));
+    } else if (prob.type === TableProblemTypes.MISSING) {
+      const missing = prob;
+      mustAdd[missing.row] += missing.n;
+    } else if (prob.type === TableProblemTypes.OVERLONG_ROWSPAN) {
+      const overlong = prob;
+      const cell = table.nodeAt(overlong.pos);
+      if (!cell) {
+        throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + overlong.pos), undefined, {
+        ...cell.attrs,
+        rowspan: cell.attrs.rowspan - overlong.n
+      });
+    } else if (prob.type === TableProblemTypes.COLWIDTH_MISMATCH) {
+      const cell = table.nodeAt(prob.pos);
+      if (!cell) {
+        throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, {
+        ...cell.attrs,
+        colwidth: prob.colwidth
+      });
+    }
+  }
+  let first;
+  let last;
+  for (let i = 0; i < mustAdd.length; i++) {
+    if (mustAdd[i]) {
+      if (first == null) {
+        first = i;
+      }
+      last = i;
+    }
+  }
+  // Add the necessary cells, using a heuristic for whether to add the
+  // cells at the start or end of the rows (if it looks like a 'bite'
+  // was taken out of the table, add cells at the start of the row
+  // after the bite. Otherwise add them at the end).
+  for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
+    const row = table.child(i);
+    const end = pos + row.nodeSize;
+    const add = mustAdd[i];
+    if (add > 0) {
+      let tableNodeType = 'cell';
+      if (row.firstChild) {
+        tableNodeType = row.firstChild.type.spec.tableRole;
+      }
+      const nodes = [];
+      for (let j = 0; j < add; j++) {
+        // Ignored via go/ees005
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill());
+      }
+      const side = (i === 0 || first === i - 1) && last === i ? pos + 1 : end - 1;
+      tr.insert(tr.mapping.map(side), nodes);
+    }
+    pos = end;
+  }
+  return tr.setMeta(fixTablesKey, {
+    fixTables: true
+  });
+}