@trops/dash-core 0.1.522 → 0.1.523

package/dist/index.esm.js

@@ -9271,7 +9271,7 @@ function _objectSpread$Z(e) { for (var r = 1; r < arguments.length; r++) { var t
  * multi-cell selections — that's a separate code path.
  */
 
-var META_KEYS = new Set(["rows", "cols", "gap"]);
+var META_KEYS$5 = new Set(["rows", "cols", "gap"]);
 
 /**
  * Merge `(row, col)` with the cell to its right. Skips empty
@@ -9290,7 +9290,7 @@ function mergeRightOp(grid, row, col) {
     var bestCol = Infinity;
     for (var _i = 0, _Object$keys = Object.keys(grid); _i < _Object$keys.length; _i++) {
       var k = _Object$keys[_i];
-      if (META_KEYS.has(k)) continue;
+      if (META_KEYS$5.has(k)) continue;
       var _k$split$map = k.split(".").map(function (n) {
           return parseInt(n, 10);
         }),
@@ -26616,6 +26616,497 @@ function mergeGridCellsOp(grid, cellNumbers, keepComponentId) {
 
 function ownKeys$D(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$D(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$D(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$D(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * splitGridCellOp
+ *
+ * Pure helper for `DashboardModel.splitGridCell`. Splits a single
+ * cell horizontally or vertically into `count` sub-cells.
+ *
+ * Two regimes (preserving original DashboardModel semantics):
+ *
+ *   CASE A — divisible span: when the target cell already has a span
+ *     in the split direction that's divisible by count, simply
+ *     subdivide the span into count pieces. No grid resolution change.
+ *
+ *   CASE B — non-divisible span (typical for an unspanned cell with
+ *     count=2): multiply the entire grid's resolution in the split
+ *     direction by count, reposition every visible cell to its
+ *     equivalent location, and place the count sub-cells at the
+ *     scaled target position.
+ *
+ * In both regimes the widget on the original target cell ends up on
+ * the FIRST sub-cell. The other sub-cells are empty.
+ *
+ * Pure — input grid is never mutated.
+ */
+
+var META_KEYS$4 = new Set(["rows", "cols", "gap", "rowHeights", "rowModes", "colModes", "colWidths"]);
+function _isCellKey$4(key) {
+  return /^\d+\.\d+$/.test(key);
+}
+function _cloneShallow(grid) {
+  var out = {};
+  for (var _i = 0, _Object$keys = Object.keys(grid); _i < _Object$keys.length; _i++) {
+    var k = _Object$keys[_i];
+    if (META_KEYS$4.has(k)) {
+      out[k] = grid[k];
+    } else if (_isCellKey$4(k)) {
+      var cell = grid[k];
+      out[k] = _objectSpread$D({}, cell);
+      if (cell.span) out[k].span = _objectSpread$D({}, cell.span);
+    }
+  }
+  return out;
+}
+function _stripSpan(span, removeKey) {
+  if (!span) return undefined;
+  var out = _objectSpread$D({}, span);
+  delete out[removeKey];
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function _splitCaseADivisibleSpan(grid, row, col, direction, count) {
+  var _targetCell$span, _targetCell$span2;
+  // direction: "horizontal" splits col span; "vertical" splits row span.
+  var isHorizontal = direction === "horizontal";
+  var targetCell = grid["".concat(row, ".").concat(col)];
+  var targetSpanCol = ((_targetCell$span = targetCell.span) === null || _targetCell$span === void 0 ? void 0 : _targetCell$span.col) || 1;
+  var targetSpanRow = ((_targetCell$span2 = targetCell.span) === null || _targetCell$span2 === void 0 ? void 0 : _targetCell$span2.row) || 1;
+  var splitSpan = isHorizontal ? targetSpanCol : targetSpanRow;
+  var otherSpan = isHorizontal ? targetSpanRow : targetSpanCol;
+  var subSpan = splitSpan / count;
+  var component = targetCell.component;
+  var out = _cloneShallow(grid);
+
+  // Unhide cells previously covered by the old span.
+  for (var sr = row; sr < row + targetSpanRow; sr++) {
+    for (var sc = col; sc < col + targetSpanCol; sc++) {
+      var k = "".concat(sr, ".").concat(sc);
+      if (out[k]) out[k] = _objectSpread$D(_objectSpread$D({}, out[k]), {}, {
+        hide: false
+      });
+    }
+  }
+
+  // Drop the old span on the target.
+  if (out["".concat(row, ".").concat(col)].span) {
+    delete out["".concat(row, ".").concat(col)].span;
+  }
+
+  // Create the count sub-cells.
+  for (var i = 0; i < count; i++) {
+    var subRow = isHorizontal ? row : row + i * subSpan;
+    var subCol = isHorizontal ? col + i * subSpan : col;
+    var key = "".concat(subRow, ".").concat(subCol);
+    var sub = {
+      component: i === 0 ? component : null,
+      hide: false
+    };
+    if (subSpan > 1 || otherSpan > 1) {
+      sub.span = {};
+      if (isHorizontal) {
+        if (subSpan > 1) sub.span.col = subSpan;
+        if (otherSpan > 1) sub.span.row = otherSpan;
+      } else {
+        if (subSpan > 1) sub.span.row = subSpan;
+        if (otherSpan > 1) sub.span.col = otherSpan;
+      }
+    }
+    out[key] = sub;
+  }
+  return out;
+}
+function _splitCaseBResolutionMultiply(grid, row, col, direction, count) {
+  var _targetCell$span3, _targetCell$span4, _targetCell$span5, _targetCell$span6;
+  var isHorizontal = direction === "horizontal";
+  var targetCell = grid["".concat(row, ".").concat(col)];
+  var oldRows = grid.rows || 1;
+  var oldCols = grid.cols || 1;
+  var component = targetCell.component;
+
+  // 1. Collect every visible cell's data + position + spans.
+  var visibleCells = [];
+  for (var r = 1; r <= oldRows; r++) {
+    for (var c = 1; c <= oldCols; c++) {
+      var key = "".concat(r, ".").concat(c);
+      var c0 = grid[key];
+      if (c0 && !c0.hide) {
+        var _c0$span, _c0$span2;
+        visibleCells.push({
+          row: r,
+          col: c,
+          data: _objectSpread$D({}, c0),
+          spanRow: ((_c0$span = c0.span) === null || _c0$span === void 0 ? void 0 : _c0$span.row) || 1,
+          spanCol: ((_c0$span2 = c0.span) === null || _c0$span2 === void 0 ? void 0 : _c0$span2.col) || 1
+        });
+      }
+    }
+  }
+
+  // 2. Build the new grid: copy meta keys, drop all cell keys.
+  var out = {};
+  for (var _i2 = 0, _Object$keys2 = Object.keys(grid); _i2 < _Object$keys2.length; _i2++) {
+    var k = _Object$keys2[_i2];
+    if (META_KEYS$4.has(k)) out[k] = grid[k];
+  }
+  if (isHorizontal) {
+    out.cols = oldCols * count;
+    out.rows = oldRows;
+  } else {
+    out.rows = oldRows * count;
+    out.cols = oldCols;
+  }
+
+  // 3. Reposition every visible cell to its scaled position with the
+  //    span scaled in the split direction.
+  for (var _i3 = 0, _visibleCells = visibleCells; _i3 < _visibleCells.length; _i3++) {
+    var vc = _visibleCells[_i3];
+    var newRow = isHorizontal ? vc.row : (vc.row - 1) * count + 1;
+    var newCol = isHorizontal ? (vc.col - 1) * count + 1 : vc.col;
+    var _key = "".concat(newRow, ".").concat(newCol);
+    var repositioned = _objectSpread$D(_objectSpread$D({}, vc.data), {}, {
+      hide: false,
+      span: {
+        row: isHorizontal ? vc.spanRow : vc.spanRow * count,
+        col: isHorizontal ? vc.spanCol * count : vc.spanCol
+      }
+    });
+    out[_key] = repositioned;
+  }
+
+  // 4. Replace the target cell's repositioned entry with count sub-cells.
+  var newTargetRow = isHorizontal ? row : (row - 1) * count + 1;
+  var newTargetCol = isHorizontal ? (col - 1) * count + 1 : col;
+  var newTargetSpanInSplitDir = isHorizontal ? (((_targetCell$span3 = targetCell.span) === null || _targetCell$span3 === void 0 ? void 0 : _targetCell$span3.col) || 1) * count : (((_targetCell$span4 = targetCell.span) === null || _targetCell$span4 === void 0 ? void 0 : _targetCell$span4.row) || 1) * count;
+  var subSpan = newTargetSpanInSplitDir / count;
+  var otherSpan = isHorizontal ? ((_targetCell$span5 = targetCell.span) === null || _targetCell$span5 === void 0 ? void 0 : _targetCell$span5.row) || 1 : ((_targetCell$span6 = targetCell.span) === null || _targetCell$span6 === void 0 ? void 0 : _targetCell$span6.col) || 1;
+  for (var i = 0; i < count; i++) {
+    var subRow = isHorizontal ? newTargetRow : newTargetRow + i * subSpan;
+    var subCol = isHorizontal ? newTargetCol + i * subSpan : newTargetCol;
+    var _key2 = "".concat(subRow, ".").concat(subCol);
+    var sub = {
+      component: i === 0 ? component : null,
+      hide: false
+    };
+    if (subSpan > 1 || otherSpan > 1) {
+      sub.span = {};
+      if (isHorizontal) {
+        if (subSpan > 1) sub.span.col = subSpan;
+        if (otherSpan > 1) sub.span.row = otherSpan;
+      } else {
+        if (subSpan > 1) sub.span.row = subSpan;
+        if (otherSpan > 1) sub.span.col = otherSpan;
+      }
+    }
+    out[_key2] = sub;
+  }
+  return out;
+}
+function splitGridCellOp(grid, cellNumber, direction) {
+  var _targetCell$span7, _targetCell$span8;
+  var count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2;
+  if (!grid) return grid;
+  var targetCell = grid[cellNumber];
+  if (!targetCell) return grid;
+  if (direction !== "horizontal" && direction !== "vertical") return grid;
+  if (!Number.isFinite(count) || count < 2) return grid;
+  var _cellNumber$split$map = cellNumber.split(".").map(Number),
+    _cellNumber$split$map2 = _slicedToArray(_cellNumber$split$map, 2),
+    row = _cellNumber$split$map2[0],
+    col = _cellNumber$split$map2[1];
+  var targetSpanInSplitDir = direction === "horizontal" ? ((_targetCell$span7 = targetCell.span) === null || _targetCell$span7 === void 0 ? void 0 : _targetCell$span7.col) || 1 : ((_targetCell$span8 = targetCell.span) === null || _targetCell$span8 === void 0 ? void 0 : _targetCell$span8.row) || 1;
+  if (targetSpanInSplitDir % count === 0) {
+    return _splitCaseADivisibleSpan(grid, row, col, direction, count);
+  }
+  return _splitCaseBResolutionMultiply(grid, row, col, direction, count);
+}
+
+// Exposed for tests / DashboardModel utility (kept private until needed).
+splitGridCellOp._stripSpan = _stripSpan;
+
+/**
+ * addGridRowOp
+ *
+ * Pure helper for `DashboardModel.addGridRow`. Inserts a new empty row
+ * after the supplied row number (afterRow=0 inserts at the top). All
+ * rows at or after the insertion point shift down by one. rowHeights
+ * and rowModes maps shift correspondingly so that per-row sizing/mode
+ * state tracks the original rows.
+ *
+ * Pure — input grid is never mutated.
+ */
+
+var META_KEYS$3 = new Set(["rows", "cols", "gap", "rowHeights", "rowModes", "colWidths"]);
+function _isCellKey$3(key) {
+  return /^\d+\.\d+$/.test(key);
+}
+function _shiftKeyMap$1(map, insertAt) {
+  if (!map) return undefined;
+  var shifted = {};
+  for (var _i = 0, _Object$entries = Object.entries(map); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var n = Number(key);
+    shifted[String(n >= insertAt ? n + 1 : n)] = value;
+  }
+  return Object.keys(shifted).length > 0 ? shifted : undefined;
+}
+function addGridRowOp(grid) {
+  var afterRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (!grid) return grid;
+  var newRowNumber = afterRow + 1;
+  var out = {};
+  // Copy meta keys forward.
+  for (var _i2 = 0, _Object$keys = Object.keys(grid); _i2 < _Object$keys.length; _i2++) {
+    var k = _Object$keys[_i2];
+    if (META_KEYS$3.has(k)) out[k] = grid[k];
+  }
+  out.rows = (grid.rows || 0) + 1;
+  out.cols = grid.cols;
+
+  // Walk every cell. Cells at row >= insertion point shift down by 1.
+  for (var _i3 = 0, _Object$keys2 = Object.keys(grid); _i3 < _Object$keys2.length; _i3++) {
+    var _k = _Object$keys2[_i3];
+    if (!_isCellKey$3(_k)) continue;
+    var _k$split$map = _k.split(".").map(Number),
+      _k$split$map2 = _slicedToArray(_k$split$map, 2),
+      r = _k$split$map2[0],
+      c = _k$split$map2[1];
+    var newRow = r >= newRowNumber ? r + 1 : r;
+    out["".concat(newRow, ".").concat(c)] = grid[_k];
+  }
+
+  // Insert empty cells in the new row.
+  var cols = grid.cols || 0;
+  for (var _c = 1; _c <= cols; _c++) {
+    out["".concat(newRowNumber, ".").concat(_c)] = {
+      component: null,
+      hide: false
+    };
+  }
+
+  // Shift rowHeights / rowModes keys to track original rows.
+  var newRowHeights = _shiftKeyMap$1(grid.rowHeights, newRowNumber);
+  if (newRowHeights) out.rowHeights = newRowHeights;else delete out.rowHeights;
+  var newRowModes = _shiftKeyMap$1(grid.rowModes, newRowNumber);
+  if (newRowModes) out.rowModes = newRowModes;else delete out.rowModes;
+  return out;
+}
+
+/**
+ * deleteGridRowOp
+ *
+ * Pure helper for `DashboardModel.deleteGridRow`. Removes the row at
+ * `rowNumber`, shifts everything below up by one, and **returns the
+ * list of widget component ids that lived on the deleted row** so the
+ * caller can remove them from the layout (or surface them to a
+ * confirm-before-delete UX in the future).
+ *
+ * Refuses to delete the only remaining row (returns the input grid
+ * unchanged + empty orphans list — same fail-safe the model had).
+ */
+
+var META_KEYS$2 = new Set(["rows", "cols", "gap", "rowHeights", "rowModes", "colModes", "colWidths"]);
+function _isCellKey$2(key) {
+  return /^\d+\.\d+$/.test(key);
+}
+function _shiftKeyMapDown$1(map, deletedAt) {
+  if (!map) return undefined;
+  var shifted = {};
+  for (var _i = 0, _Object$entries = Object.entries(map); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var n = Number(key);
+    if (n === deletedAt) continue;
+    shifted[String(n > deletedAt ? n - 1 : n)] = value;
+  }
+  return Object.keys(shifted).length > 0 ? shifted : undefined;
+}
+function deleteGridRowOp(grid, rowNumber) {
+  if (!grid) return {
+    grid: grid,
+    orphanedComponents: []
+  };
+  if ((grid.rows || 0) <= 1) {
+    // Can't delete the only row — fail-safe no-op.
+    return {
+      grid: grid,
+      orphanedComponents: []
+    };
+  }
+  var out = {};
+  var orphanedComponents = [];
+  for (var _i2 = 0, _Object$keys = Object.keys(grid); _i2 < _Object$keys.length; _i2++) {
+    var k = _Object$keys[_i2];
+    if (META_KEYS$2.has(k)) {
+      out[k] = grid[k];
+      continue;
+    }
+    if (!_isCellKey$2(k)) continue;
+    var _k$split$map = k.split(".").map(Number),
+      _k$split$map2 = _slicedToArray(_k$split$map, 2),
+      r = _k$split$map2[0],
+      c = _k$split$map2[1];
+    if (r === rowNumber) {
+      // Cell is in the row being deleted — collect its component (if
+      // any) as an orphan, drop the cell entirely.
+      var comp = grid[k] && grid[k].component;
+      if (comp != null) orphanedComponents.push(comp);
+      continue;
+    }
+    if (r > rowNumber) {
+      // Cells below the deleted row shift up by one.
+      out["".concat(r - 1, ".").concat(c)] = grid[k];
+    } else {
+      // Cells above the deleted row are unchanged.
+      out[k] = grid[k];
+    }
+  }
+  out.rows = (grid.rows || 0) - 1;
+  out.cols = grid.cols;
+  var newRowHeights = _shiftKeyMapDown$1(grid.rowHeights, rowNumber);
+  if (newRowHeights) out.rowHeights = newRowHeights;else delete out.rowHeights;
+  var newRowModes = _shiftKeyMapDown$1(grid.rowModes, rowNumber);
+  if (newRowModes) out.rowModes = newRowModes;else delete out.rowModes;
+  return {
+    grid: out,
+    orphanedComponents: orphanedComponents
+  };
+}
+
+/**
+ * addGridColumnOp
+ *
+ * Pure helper for `DashboardModel.addGridColumn`. Symmetric to
+ * `addGridRowOp` but for columns. Inserts an empty column after the
+ * supplied column number (afterCol=0 inserts at the left edge).
+ * colModes shifts to track its original columns. (Original code
+ * doesn't track colWidths, so we don't either; can be added later.)
+ */
+
+var META_KEYS$1 = new Set(["rows", "cols", "gap", "rowHeights", "rowModes", "colModes", "colWidths"]);
+function _isCellKey$1(key) {
+  return /^\d+\.\d+$/.test(key);
+}
+function _shiftKeyMap(map, insertAt) {
+  if (!map) return undefined;
+  var shifted = {};
+  for (var _i = 0, _Object$entries = Object.entries(map); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var n = Number(key);
+    shifted[String(n >= insertAt ? n + 1 : n)] = value;
+  }
+  return Object.keys(shifted).length > 0 ? shifted : undefined;
+}
+function addGridColumnOp(grid) {
+  var afterCol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (!grid) return grid;
+  var newColNumber = afterCol + 1;
+  var out = {};
+  for (var _i2 = 0, _Object$keys = Object.keys(grid); _i2 < _Object$keys.length; _i2++) {
+    var k = _Object$keys[_i2];
+    if (META_KEYS$1.has(k)) out[k] = grid[k];
+  }
+  out.cols = (grid.cols || 0) + 1;
+  out.rows = grid.rows;
+  for (var _i3 = 0, _Object$keys2 = Object.keys(grid); _i3 < _Object$keys2.length; _i3++) {
+    var _k = _Object$keys2[_i3];
+    if (!_isCellKey$1(_k)) continue;
+    var _k$split$map = _k.split(".").map(Number),
+      _k$split$map2 = _slicedToArray(_k$split$map, 2),
+      r = _k$split$map2[0],
+      c = _k$split$map2[1];
+    var newCol = c >= newColNumber ? c + 1 : c;
+    out["".concat(r, ".").concat(newCol)] = grid[_k];
+  }
+  var rows = grid.rows || 0;
+  for (var _r = 1; _r <= rows; _r++) {
+    out["".concat(_r, ".").concat(newColNumber)] = {
+      component: null,
+      hide: false
+    };
+  }
+  var newColModes = _shiftKeyMap(grid.colModes, newColNumber);
+  if (newColModes) out.colModes = newColModes;else delete out.colModes;
+  return out;
+}
+
+/**
+ * deleteGridColumnOp
+ *
+ * Pure helper for `DashboardModel.deleteGridColumn`. Symmetric to
+ * `deleteGridRowOp` — removes the column at `colNumber`, shifts
+ * everything to the right left by one, returns orphaned widget ids.
+ *
+ * Refuses to delete the only remaining column (returns input grid
+ * unchanged + empty orphans list).
+ */
+
+var META_KEYS = new Set(["rows", "cols", "gap", "rowHeights", "rowModes", "colModes", "colWidths"]);
+function _isCellKey(key) {
+  return /^\d+\.\d+$/.test(key);
+}
+function _shiftKeyMapDown(map, deletedAt) {
+  if (!map) return undefined;
+  var shifted = {};
+  for (var _i = 0, _Object$entries = Object.entries(map); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var n = Number(key);
+    if (n === deletedAt) continue;
+    shifted[String(n > deletedAt ? n - 1 : n)] = value;
+  }
+  return Object.keys(shifted).length > 0 ? shifted : undefined;
+}
+function deleteGridColumnOp(grid, colNumber) {
+  if (!grid) return {
+    grid: grid,
+    orphanedComponents: []
+  };
+  if ((grid.cols || 0) <= 1) {
+    return {
+      grid: grid,
+      orphanedComponents: []
+    };
+  }
+  var out = {};
+  var orphanedComponents = [];
+  for (var _i2 = 0, _Object$keys = Object.keys(grid); _i2 < _Object$keys.length; _i2++) {
+    var k = _Object$keys[_i2];
+    if (META_KEYS.has(k)) {
+      out[k] = grid[k];
+      continue;
+    }
+    if (!_isCellKey(k)) continue;
+    var _k$split$map = k.split(".").map(Number),
+      _k$split$map2 = _slicedToArray(_k$split$map, 2),
+      r = _k$split$map2[0],
+      c = _k$split$map2[1];
+    if (c === colNumber) {
+      var comp = grid[k] && grid[k].component;
+      if (comp != null) orphanedComponents.push(comp);
+      continue;
+    }
+    if (c > colNumber) {
+      out["".concat(r, ".").concat(c - 1)] = grid[k];
+    } else {
+      out[k] = grid[k];
+    }
+  }
+  out.cols = (grid.cols || 0) - 1;
+  out.rows = grid.rows;
+  var newColModes = _shiftKeyMapDown(grid.colModes, colNumber);
+  if (newColModes) out.colModes = newColModes;else delete out.colModes;
+  return {
+    grid: out,
+    orphanedComponents: orphanedComponents
+  };
+}
+
 function _createForOfIteratorHelper$m(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$m(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray$m(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$m(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$m(r, a) : void 0; } }
 function _arrayLikeToArray$m(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
@@ -27897,210 +28388,18 @@ var DashboardModel = /*#__PURE__*/function () {
         if (!gridContainer || !gridContainer.grid) {
           return null;
         }
-        var grid = gridContainer.grid;
-        var _cellNumber$split$map = cellNumber.split(".").map(Number),
-          _cellNumber$split$map2 = _slicedToArray(_cellNumber$split$map, 2),
-          row = _cellNumber$split$map2[0],
-          col = _cellNumber$split$map2[1];
-        var targetCell = grid[cellNumber];
-        if (direction === "horizontal") {
-          var _targetCell$span, _targetCell$span2;
-          var targetSpanCol = (targetCell === null || targetCell === void 0 || (_targetCell$span = targetCell.span) === null || _targetCell$span === void 0 ? void 0 : _targetCell$span.col) || 1;
-          var targetSpanRow = (targetCell === null || targetCell === void 0 || (_targetCell$span2 = targetCell.span) === null || _targetCell$span2 === void 0 ? void 0 : _targetCell$span2.row) || 1;
-          if (targetSpanCol % count === 0) {
-            // CASE A: Span is divisible — simple subdivision, no grid resize
-            var subSpan = targetSpanCol / count;
-            var component = targetCell === null || targetCell === void 0 ? void 0 : targetCell.component;
-
-            // Unhide cells covered by the old span
-            for (var sr = row; sr < row + targetSpanRow; sr++) {
-              for (var sc = col; sc < col + targetSpanCol; sc++) {
-                var k = "".concat(sr, ".").concat(sc);
-                if (grid[k]) grid[k].hide = false;
-              }
-            }
-            delete targetCell.span;
-
-            // Create subdivided cells
-            for (var i = 0; i < count; i++) {
-              var key = "".concat(row, ".").concat(col + i * subSpan);
-              grid[key] = {
-                component: i === 0 ? component : null,
-                hide: false
-              };
-              if (subSpan > 1 || targetSpanRow > 1) {
-                grid[key].span = {};
-                if (subSpan > 1) grid[key].span.col = subSpan;
-                if (targetSpanRow > 1) grid[key].span.row = targetSpanRow;
-              }
-            }
-          } else {
-            var _targetCell$span3, _targetCell$span4;
-            // CASE B: Multiply grid resolution by count
-            var oldCols = grid.cols;
-
-            // 1. Collect all visible cells
-            var visibleCells = [];
-            for (var r = 1; r <= grid.rows; r++) {
-              for (var c = 1; c <= oldCols; c++) {
-                var _key5 = "".concat(r, ".").concat(c);
-                var cell = grid[_key5];
-                if (cell && !cell.hide) {
-                  var _cell$span, _cell$span2;
-                  visibleCells.push({
-                    row: r,
-                    col: c,
-                    data: _objectSpread$D({}, cell),
-                    spanCol: ((_cell$span = cell.span) === null || _cell$span === void 0 ? void 0 : _cell$span.col) || 1,
-                    spanRow: ((_cell$span2 = cell.span) === null || _cell$span2 === void 0 ? void 0 : _cell$span2.row) || 1
-                  });
-                }
-              }
-            }
-
-            // 2. Clear all cell keys
-            for (var _i4 = 0, _Object$keys3 = Object.keys(grid); _i4 < _Object$keys3.length; _i4++) {
-              var _key6 = _Object$keys3[_i4];
-              if (/^\d+\.\d+$/.test(_key6)) delete grid[_key6];
-            }
-
-            // 3. Update grid dimensions
-            grid.cols = oldCols * count;
-
-            // 4. Reposition all cells with scaled positions and spans
-            for (var _i5 = 0, _visibleCells = visibleCells; _i5 < _visibleCells.length; _i5++) {
-              var vc = _visibleCells[_i5];
-              var newCol = (vc.col - 1) * count + 1;
-              var _key7 = "".concat(vc.row, ".").concat(newCol);
-              grid[_key7] = _objectSpread$D(_objectSpread$D({}, vc.data), {}, {
-                hide: false,
-                span: {
-                  row: vc.spanRow,
-                  col: vc.spanCol * count
-                }
-              });
-            }
-
-            // 5. Split the target cell into count sub-cells
-            var newTargetCol = (col - 1) * count + 1;
-            var newTargetSpan = ((targetCell === null || targetCell === void 0 || (_targetCell$span3 = targetCell.span) === null || _targetCell$span3 === void 0 ? void 0 : _targetCell$span3.col) || 1) * count;
-            var _subSpan = newTargetSpan / count;
-            var _component = targetCell === null || targetCell === void 0 ? void 0 : targetCell.component;
-            var rowSpan = (targetCell === null || targetCell === void 0 || (_targetCell$span4 = targetCell.span) === null || _targetCell$span4 === void 0 ? void 0 : _targetCell$span4.row) || 1;
-            for (var _i6 = 0; _i6 < count; _i6++) {
-              var _key8 = "".concat(row, ".").concat(newTargetCol + _i6 * _subSpan);
-              grid[_key8] = {
-                component: _i6 === 0 ? _component : null,
-                hide: false
-              };
-              if (_subSpan > 1 || rowSpan > 1) {
-                grid[_key8].span = {};
-                if (_subSpan > 1) grid[_key8].span.col = _subSpan;
-                if (rowSpan > 1) grid[_key8].span.row = rowSpan;
-              }
-            }
-          }
-        } else if (direction === "vertical") {
-          var _targetCell$span5, _targetCell$span6;
-          var _targetSpanRow = (targetCell === null || targetCell === void 0 || (_targetCell$span5 = targetCell.span) === null || _targetCell$span5 === void 0 ? void 0 : _targetCell$span5.row) || 1;
-          var _targetSpanCol = (targetCell === null || targetCell === void 0 || (_targetCell$span6 = targetCell.span) === null || _targetCell$span6 === void 0 ? void 0 : _targetCell$span6.col) || 1;
-          if (_targetSpanRow % count === 0) {
-            // CASE A: Span is divisible — simple subdivision, no grid resize
-            var _subSpan2 = _targetSpanRow / count;
-            var _component2 = targetCell === null || targetCell === void 0 ? void 0 : targetCell.component;
-
-            // Unhide cells covered by the old span
-            for (var _sr2 = row; _sr2 < row + _targetSpanRow; _sr2++) {
-              for (var _sc2 = col; _sc2 < col + _targetSpanCol; _sc2++) {
-                var _k = "".concat(_sr2, ".").concat(_sc2);
-                if (grid[_k]) grid[_k].hide = false;
-              }
-            }
-            delete targetCell.span;
-
-            // Create subdivided cells
-            for (var _i7 = 0; _i7 < count; _i7++) {
-              var _key9 = "".concat(row + _i7 * _subSpan2, ".").concat(col);
-              grid[_key9] = {
-                component: _i7 === 0 ? _component2 : null,
-                hide: false
-              };
-              if (_subSpan2 > 1 || _targetSpanCol > 1) {
-                grid[_key9].span = {};
-                if (_subSpan2 > 1) grid[_key9].span.row = _subSpan2;
-                if (_targetSpanCol > 1) grid[_key9].span.col = _targetSpanCol;
-              }
-            }
-          } else {
-            var _targetCell$span7, _targetCell$span8;
-            // CASE B: Multiply grid resolution by count
-            var oldRows = grid.rows;
-
-            // 1. Collect all visible cells
-            var _visibleCells2 = [];
-            for (var _r1 = 1; _r1 <= oldRows; _r1++) {
-              for (var _c10 = 1; _c10 <= grid.cols; _c10++) {
-                var _key0 = "".concat(_r1, ".").concat(_c10);
-                var _cell6 = grid[_key0];
-                if (_cell6 && !_cell6.hide) {
-                  var _cell6$span, _cell6$span2;
-                  _visibleCells2.push({
-                    row: _r1,
-                    col: _c10,
-                    data: _objectSpread$D({}, _cell6),
-                    spanRow: ((_cell6$span = _cell6.span) === null || _cell6$span === void 0 ? void 0 : _cell6$span.row) || 1,
-                    spanCol: ((_cell6$span2 = _cell6.span) === null || _cell6$span2 === void 0 ? void 0 : _cell6$span2.col) || 1
-                  });
-                }
-              }
-            }
-
-            // 2. Clear all cell keys
-            for (var _i8 = 0, _Object$keys4 = Object.keys(grid); _i8 < _Object$keys4.length; _i8++) {
-              var _key1 = _Object$keys4[_i8];
-              if (/^\d+\.\d+$/.test(_key1)) delete grid[_key1];
-            }
-
-            // 3. Update grid dimensions
-            grid.rows = oldRows * count;
-
-            // 4. Reposition all cells with scaled positions and spans
-            for (var _i9 = 0, _visibleCells3 = _visibleCells2; _i9 < _visibleCells3.length; _i9++) {
-              var _vc = _visibleCells3[_i9];
-              var newRow = (_vc.row - 1) * count + 1;
-              var _key10 = "".concat(newRow, ".").concat(_vc.col);
-              grid[_key10] = _objectSpread$D(_objectSpread$D({}, _vc.data), {}, {
-                hide: false,
-                span: {
-                  row: _vc.spanRow * count,
-                  col: _vc.spanCol
-                }
-              });
-            }
-
-            // 5. Split the target cell into count sub-cells
-            var newTargetRow = (row - 1) * count + 1;
-            var _newTargetSpan = ((targetCell === null || targetCell === void 0 || (_targetCell$span7 = targetCell.span) === null || _targetCell$span7 === void 0 ? void 0 : _targetCell$span7.row) || 1) * count;
-            var _subSpan3 = _newTargetSpan / count;
-            var _component3 = targetCell === null || targetCell === void 0 ? void 0 : targetCell.component;
-            var colSpan = (targetCell === null || targetCell === void 0 || (_targetCell$span8 = targetCell.span) === null || _targetCell$span8 === void 0 ? void 0 : _targetCell$span8.col) || 1;
-            for (var _i0 = 0; _i0 < count; _i0++) {
-              var _key11 = "".concat(newTargetRow + _i0 * _subSpan3, ".").concat(col);
-              grid[_key11] = {
-                component: _i0 === 0 ? _component3 : null,
-                hide: false
-              };
-              if (_subSpan3 > 1 || colSpan > 1) {
-                grid[_key11].span = {};
-                if (_subSpan3 > 1) grid[_key11].span.row = _subSpan3;
-                if (colSpan > 1) grid[_key11].span.col = colSpan;
-              }
-            }
-          }
+        // Slice 11: pure helper handles both CASE A (divisible span)
+        // and CASE B (resolution multiply). Falls through to the legacy
+        // inline path below if the helper somehow returns the same
+        // grid (defensive — shouldn't happen for a valid cellNumber +
+        // direction).
+        var newGrid = splitGridCellOp(gridContainer.grid, cellNumber, direction, count);
+        if (newGrid !== gridContainer.grid) {
+          gridContainer.grid = newGrid;
+          this._normalizeGrid(gridContainer.grid);
+          this.updateLayoutItem(gridContainer);
         }
-        this._normalizeGrid(grid);
-        this.updateLayoutItem(gridContainer);
-        return grid;
+        return gridContainer.grid;
       } catch (e) {
         return null;
       }
@@ -28249,55 +28548,8 @@ var DashboardModel = /*#__PURE__*/function () {
         if (!gridContainer || !gridContainer.grid) {
           return null;
         }
-        var newRowNumber = afterRow + 1;
-        gridContainer.grid.rows += 1;
-
-        // Shift existing rows down
-        for (var r = gridContainer.grid.rows; r > newRowNumber; r--) {
-          for (var c = 1; c <= gridContainer.grid.cols; c++) {
-            var oldCell = "".concat(r - 1, ".").concat(c);
-            var newCell = "".concat(r, ".").concat(c);
-            if (oldCell in gridContainer.grid) {
-              gridContainer.grid[newCell] = gridContainer.grid[oldCell];
-              delete gridContainer.grid[oldCell];
-            }
-          }
-        }
-
-        // Create new empty cells for the new row
-        for (var _c11 = 1; _c11 <= gridContainer.grid.cols; _c11++) {
-          var cellNumber = "".concat(newRowNumber, ".").concat(_c11);
-          gridContainer.grid[cellNumber] = {
-            component: null,
-            hide: false
-          };
-        }
-
-        // Shift rowHeights keys down (rows after insertion point move +1)
-        if (gridContainer.grid.rowHeights) {
-          var shifted = {};
-          for (var _i1 = 0, _Object$entries2 = Object.entries(gridContainer.grid.rowHeights); _i1 < _Object$entries2.length; _i1++) {
-            var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i1], 2),
-              key = _Object$entries2$_i[0],
-              mult = _Object$entries2$_i[1];
-            var rowNum = Number(key);
-            shifted[String(rowNum >= newRowNumber ? rowNum + 1 : rowNum)] = mult;
-          }
-          gridContainer.grid.rowHeights = Object.keys(shifted).length > 0 ? shifted : undefined;
-        }
-
-        // Shift rowModes keys down (rows after insertion point move +1)
-        if (gridContainer.grid.rowModes) {
-          var _shifted = {};
-          for (var _i10 = 0, _Object$entries3 = Object.entries(gridContainer.grid.rowModes); _i10 < _Object$entries3.length; _i10++) {
-            var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i10], 2),
-              _key12 = _Object$entries3$_i[0],
-              mode = _Object$entries3$_i[1];
-            var _rowNum = Number(_key12);
-            _shifted[String(_rowNum >= newRowNumber ? _rowNum + 1 : _rowNum)] = mode;
-          }
-          gridContainer.grid.rowModes = Object.keys(_shifted).length > 0 ? _shifted : undefined;
-        }
+        // Slice 11: pure helper handles the row-insertion + shifting.
+        gridContainer.grid = addGridRowOp(gridContainer.grid, afterRow);
         this._normalizeGrid(gridContainer.grid);
         this.updateLayoutItem(gridContainer);
         return gridContainer.grid;
@@ -28323,55 +28575,23 @@ var DashboardModel = /*#__PURE__*/function () {
         if (gridContainer.grid.rows <= 1) {
           return null;
         }
-
-        // Remove components in the deleted row
-        for (var c = 1; c <= gridContainer.grid.cols; c++) {
-          var cellNumber = "".concat(rowNumber, ".").concat(c);
-          if (gridContainer.grid[cellNumber] && gridContainer.grid[cellNumber].component) {
-            this.removeItemFromLayout(gridContainer.grid[cellNumber].component);
-          }
-          delete gridContainer.grid[cellNumber];
-        }
-
-        // Shift rows up
-        for (var r = rowNumber + 1; r <= gridContainer.grid.rows; r++) {
-          for (var _c12 = 1; _c12 <= gridContainer.grid.cols; _c12++) {
-            var oldCell = "".concat(r, ".").concat(_c12);
-            var newCell = "".concat(r - 1, ".").concat(_c12);
-            if (oldCell in gridContainer.grid) {
-              gridContainer.grid[newCell] = gridContainer.grid[oldCell];
-              delete gridContainer.grid[oldCell];
-            }
+        // Slice 11: pure helper returns the updated grid + the list of
+        // widget components that lived on the deleted row. We remove
+        // those from the layout here to preserve the original
+        // destructive-delete behavior.
+        var result = deleteGridRowOp(gridContainer.grid, rowNumber);
+        gridContainer.grid = result.grid;
+        var _iterator2 = _createForOfIteratorHelper$m(result.orphanedComponents),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var componentId = _step2.value;
+            this.removeItemFromLayout(componentId);
           }
-        }
-        gridContainer.grid.rows -= 1;
-
-        // Shift rowHeights keys up and remove the deleted row's entry
-        if (gridContainer.grid.rowHeights) {
-          var shifted = {};
-          for (var _i11 = 0, _Object$entries4 = Object.entries(gridContainer.grid.rowHeights); _i11 < _Object$entries4.length; _i11++) {
-            var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i11], 2),
-              key = _Object$entries4$_i[0],
-              mult = _Object$entries4$_i[1];
-            var rowNum = Number(key);
-            if (rowNum === rowNumber) continue;
-            shifted[String(rowNum > rowNumber ? rowNum - 1 : rowNum)] = mult;
-          }
-          gridContainer.grid.rowHeights = Object.keys(shifted).length > 0 ? shifted : undefined;
-        }
-
-        // Shift rowModes keys up and remove the deleted row's entry
-        if (gridContainer.grid.rowModes) {
-          var _shifted2 = {};
-          for (var _i12 = 0, _Object$entries5 = Object.entries(gridContainer.grid.rowModes); _i12 < _Object$entries5.length; _i12++) {
-            var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i12], 2),
-              _key13 = _Object$entries5$_i[0],
-              mode = _Object$entries5$_i[1];
-            var _rowNum2 = Number(_key13);
-            if (_rowNum2 === rowNumber) continue;
-            _shifted2[String(_rowNum2 > rowNumber ? _rowNum2 - 1 : _rowNum2)] = mode;
-          }
-          gridContainer.grid.rowModes = Object.keys(_shifted2).length > 0 ? _shifted2 : undefined;
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
         }
         this._normalizeGrid(gridContainer.grid);
         this.updateLayoutItem(gridContainer);
@@ -28430,42 +28650,8 @@ var DashboardModel = /*#__PURE__*/function () {
         if (!gridContainer || !gridContainer.grid) {
           return null;
         }
-        var newColNumber = afterCol + 1;
-        gridContainer.grid.cols += 1;
-
-        // Shift existing columns right
-        for (var r = 1; r <= gridContainer.grid.rows; r++) {
-          for (var c = gridContainer.grid.cols; c > newColNumber; c--) {
-            var oldCell = "".concat(r, ".").concat(c - 1);
-            var newCell = "".concat(r, ".").concat(c);
-            if (oldCell in gridContainer.grid) {
-              gridContainer.grid[newCell] = gridContainer.grid[oldCell];
-              delete gridContainer.grid[oldCell];
-            }
-          }
-        }
-
-        // Create new empty cells for the new column
-        for (var _r10 = 1; _r10 <= gridContainer.grid.rows; _r10++) {
-          var cellNumber = "".concat(_r10, ".").concat(newColNumber);
-          gridContainer.grid[cellNumber] = {
-            component: null,
-            hide: false
-          };
-        }
-
-        // Shift colModes keys right (columns after insertion point move +1)
-        if (gridContainer.grid.colModes) {
-          var shifted = {};
-          for (var _i13 = 0, _Object$entries6 = Object.entries(gridContainer.grid.colModes); _i13 < _Object$entries6.length; _i13++) {
-            var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i13], 2),
-              key = _Object$entries6$_i[0],
-              mode = _Object$entries6$_i[1];
-            var colNum = Number(key);
-            shifted[String(colNum >= newColNumber ? colNum + 1 : colNum)] = mode;
-          }
-          gridContainer.grid.colModes = Object.keys(shifted).length > 0 ? shifted : undefined;
-        }
+        // Slice 11: pure helper.
+        gridContainer.grid = addGridColumnOp(gridContainer.grid, afterCol);
         this._normalizeGrid(gridContainer.grid);
         this.updateLayoutItem(gridContainer);
         return gridContainer.grid;
@@ -28491,41 +28677,20 @@ var DashboardModel = /*#__PURE__*/function () {
         if (gridContainer.grid.cols <= 1) {
           return null;
         }
-
-        // Remove components in the deleted column
-        for (var r = 1; r <= gridContainer.grid.rows; r++) {
-          var cellNumber = "".concat(r, ".").concat(colNumber);
-          if (gridContainer.grid[cellNumber] && gridContainer.grid[cellNumber].component) {
-            this.removeItemFromLayout(gridContainer.grid[cellNumber].component);
-          }
-          delete gridContainer.grid[cellNumber];
-        }
-
-        // Shift columns left
-        for (var _r11 = 1; _r11 <= gridContainer.grid.rows; _r11++) {
-          for (var c = colNumber + 1; c <= gridContainer.grid.cols; c++) {
-            var oldCell = "".concat(_r11, ".").concat(c);
-            var newCell = "".concat(_r11, ".").concat(c - 1);
-            if (oldCell in gridContainer.grid) {
-              gridContainer.grid[newCell] = gridContainer.grid[oldCell];
-              delete gridContainer.grid[oldCell];
-            }
-          }
-        }
-        gridContainer.grid.cols -= 1;
-
-        // Shift colModes keys left and remove the deleted column's entry
-        if (gridContainer.grid.colModes) {
-          var shifted = {};
-          for (var _i14 = 0, _Object$entries7 = Object.entries(gridContainer.grid.colModes); _i14 < _Object$entries7.length; _i14++) {
-            var _Object$entries7$_i = _slicedToArray(_Object$entries7[_i14], 2),
-              key = _Object$entries7$_i[0],
-              mode = _Object$entries7$_i[1];
-            var colNum = Number(key);
-            if (colNum === colNumber) continue;
-            shifted[String(colNum > colNumber ? colNum - 1 : colNum)] = mode;
+        // Slice 11: pure helper.
+        var result = deleteGridColumnOp(gridContainer.grid, colNumber);
+        gridContainer.grid = result.grid;
+        var _iterator3 = _createForOfIteratorHelper$m(result.orphanedComponents),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var componentId = _step3.value;
+            this.removeItemFromLayout(componentId);
           }
-          gridContainer.grid.colModes = Object.keys(shifted).length > 0 ? shifted : undefined;
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
         }
         this._normalizeGrid(gridContainer.grid);
         this.updateLayoutItem(gridContainer);
@@ -28610,14 +28775,14 @@ var DashboardModel = /*#__PURE__*/function () {
       try {
         // Collect all item IDs actively referenced by grid cells
         var activeItemIds = new Set();
-        var _iterator2 = _createForOfIteratorHelper$m(this.layout),
-          _step2;
+        var _iterator4 = _createForOfIteratorHelper$m(this.layout),
+          _step4;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var item = _step2.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var item = _step4.value;
             if (item.grid && _typeof(item.grid) === "object") {
-              for (var _i15 = 0, _Object$keys5 = Object.keys(item.grid); _i15 < _Object$keys5.length; _i15++) {
-                var key = _Object$keys5[_i15];
+              for (var _i4 = 0, _Object$keys3 = Object.keys(item.grid); _i4 < _Object$keys3.length; _i4++) {
+                var key = _Object$keys3[_i4];
                 var cell = item.grid[key];
                 if (cell && _typeof(cell) === "object" && cell.component) {
                   activeItemIds.add(cell.component);
@@ -28630,9 +28795,9 @@ var DashboardModel = /*#__PURE__*/function () {
 
           // If no grid containers exist, nothing to clean
         } catch (err) {
-          _iterator2.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator2.f();
+          _iterator4.f();
         }
         if (activeItemIds.size === 0) return;
 
@@ -28650,17 +28815,17 @@ var DashboardModel = /*#__PURE__*/function () {
         });
 
         // Clean listener references on remaining items for each removed orphan
-        var _iterator3 = _createForOfIteratorHelper$m(orphanedIds),
-          _step3;
+        var _iterator5 = _createForOfIteratorHelper$m(orphanedIds),
+          _step5;
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var id = _step3.value;
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var id = _step5.value;
             this._cleanupListenerReferencesForId(id);
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator5.e(err);
         } finally {
-          _iterator3.f();
+          _iterator5.f();
         }
       } catch (e) {
       }