WebSVN – oidplus – Diff – /trunk/vendor/tinymce/tinymce/plugins/table/plugin.js

  * Copyright (c) Tiny Technologies, Inc. All rights reserved.
  * Licensed under the LGPL or a commercial license.
  * For LGPL see License.txt in the project root for license information.
  * For commercial licenses see https://www.tiny.cloud/
+ *
- * Version: 5.9.2 (2021-09-08)
+ * Version: 5.10.2 (2021-11-17)
  */
 (function () {
     'use strict';
     var typeOf = function (x) {
       return s.length > 0;
     };
     var isEmpty$1 = function (s) {
       return !isNotEmpty(s);
     };
+    var toFloat = function (value) {
+      var num = parseFloat(value);
+      return isNaN(num) ? Optional.none() : Optional.some(num);
+    };
     var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
     var checkContains = function (target) {
       return function (uastring) {
         return contains$1(uastring, target);
       return SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
     };
     var parent = function (element) {
       return Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
     };
+    var parentElement = function (element) {
+      return Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
+    };
     var parents = function (element, isRoot) {
       var stop = isFunction(isRoot) ? isRoot : never;
       var dom = element.dom;
       var ret = [];
       while (dom.parentNode !== null && dom.parentNode !== undefined) {
           dom = rawParent;
+        }
+      }
       return ret;
     };
-    var offsetParent = function (element) {
-      return Optional.from(element.dom.offsetParent).map(SugarElement.fromDom);
-    };
     var prevSibling = function (element) {
       return Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
     };
     var nextSibling = function (element) {
       return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
       var dom = element.dom;
       each$1(attrs, function (v, k) {
         rawSet(dom, k, v);
       });
     };
+    var setOptions = function (element, attrs) {
+      each$1(attrs, function (v, k) {
+        v.fold(function () {
+          remove$7(element, k);
+        }, function (value) {
+          rawSet(element.dom, k, value);
+        });
+      });
+    };
     var get$b = function (element, key) {
       var v = element.dom.getAttribute(key);
       return v === null ? undefined : v;
     };
     var getOpt = function (element, key) {
       }).getOr(fallback);
     };
     var getSpan = function (cell, type) {
       return getAttrValue(cell, type, 1);
     };
-    var hasColspan = function (cell) {
+    var hasColspan = function (cellOrCol) {
+      if (isTag('col')(cellOrCol)) {
+        return getAttrValue(cellOrCol, 'span', 1) > 1;
+      } else {
-      return getSpan(cell, 'colspan') > 1;
+        return getSpan(cellOrCol, 'colspan') > 1;
+      }
     };
     var hasRowspan = function (cell) {
       return getSpan(cell, 'rowspan') > 1;
     };
     var getCssValue = function (element, property) {
       }).getOr('tbody');
     };
     var fromTable$1 = function (table) {
       var rows = rows$1(table);
       var columnGroups$1 = columnGroups(table);
-      var elems = __spreadArray(__spreadArray([], columnGroups$1), rows);
+      var elems = __spreadArray(__spreadArray([], columnGroups$1, true), rows, true);
       return fromRowsOrColGroups(elems, getParentSection);
     };
     var fromPastedRows = function (elems, section) {
       return fromRowsOrColGroups(elems, function () {
         return section;
       return columnsGroup;
     };
     var generate$1 = function (list) {
       var access = {};
       var cells = [];
-      var columns = {};
-      var colgroups = [];
       var tableOpt = head(list).map(function (rowData) {
         return rowData.element;
       }).bind(table);
       var lockedColumns = tableOpt.bind(getLockedColumnsFromTable).getOr({});
       var maxRows = 0;
       var maxColumns = 0;
       var rowCount = 0;
-      each$2(list, function (rowData) {
+      var _a = partition(list, function (rowData) {
-        if (rowData.section === 'colgroup') {
+          return rowData.section === 'colgroup';
-          columns = generateColumns(rowData);
+        }), colgroupRows = _a.pass, rows = _a.fail;
-          colgroups = [colgroup(rowData.element, values(columns))];
+      each$2(rows, function (rowData) {
-        } else {
-          var currentRow_1 = [];
+        var currentRow = [];
-          each$2(rowData.cells, function (rowCell) {
+        each$2(rowData.cells, function (rowCell) {
-            var start = 0;
+          var start = 0;
-            while (access[key(rowCount, start)] !== undefined) {
+          while (access[key(rowCount, start)] !== undefined) {
-              start++;
+            start++;
+          }
-                var newpos = key(rowPosition, columnPosition);
+              var newpos = key(rowPosition, columnPosition);
-                access[newpos] = current;
+              access[newpos] = current;
-                maxColumns = Math.max(maxColumns, columnPosition + 1);
+              maxColumns = Math.max(maxColumns, columnPosition + 1);
+            }
+          }
-            currentRow_1.push(current);
+          currentRow.push(current);
-          });
+        });
-          maxRows++;
+        maxRows++;
-          cells.push(rowdetail(rowData.element, currentRow_1, rowData.section));
+        cells.push(rowdetail(rowData.element, currentRow, rowData.section));
-          rowCount++;
+        rowCount++;
-        }
       });
+      var _b = last$2(colgroupRows).map(function (rowData) {
+          var columns = generateColumns(rowData);
+          var colgroup$1 = colgroup(rowData.element, values(columns));
+          return {
+            colgroups: [colgroup$1],
+            columns: columns
+          };
+        }).getOrThunk(function () {
+          return {
+            colgroups: [],
+            columns: {}
+          };
+        }), columns = _b.columns, colgroups = _b.colgroups;
       var grid$1 = grid(maxRows, maxColumns);
       return {
         grid: grid$1,
         access: access,
         all: cells,
         aggregate: aggregate,
         max: max
       };
     };
+    var needManualCalc = function () {
+      var browser = detect$3().browser;
+      return browser.isIE() || browser.isEdge();
+    };
+    var toNumber = function (px, fallback) {
+      return toFloat(px).getOr(fallback);
+    };
+    var getProp = function (element, name, fallback) {
+      return toNumber(get$a(element, name), fallback);
+    };
+    var getBoxSizing = function (element) {
+      return get$a(element, 'box-sizing');
+    };
+    var calcContentBoxSize = function (element, size, upper, lower) {
+      var paddingUpper = getProp(element, 'padding-' + upper, 0);
+      var paddingLower = getProp(element, 'padding-' + lower, 0);
+      var borderUpper = getProp(element, 'border-' + upper + '-width', 0);
+      var borderLower = getProp(element, 'border-' + lower + '-width', 0);
+      return size - paddingUpper - paddingLower - borderUpper - borderLower;
+    };
+    var getCalculatedHeight = function (element, boxSizing) {
+      var dom = element.dom;
+      var height = dom.getBoundingClientRect().height || dom.offsetHeight;
+      return boxSizing === 'border-box' ? height : calcContentBoxSize(element, height, 'top', 'bottom');
+    };
+    var getCalculatedWidth = function (element, boxSizing) {
+      var dom = element.dom;
+      var width = dom.getBoundingClientRect().width || dom.offsetWidth;
+      return boxSizing === 'border-box' ? width : calcContentBoxSize(element, width, 'left', 'right');
+    };
+    var getHeight$1 = function (element) {
+      return needManualCalc() ? getCalculatedHeight(element, getBoxSizing(element)) : getProp(element, 'height', element.dom.offsetHeight);
+    };
+    var getWidth = function (element) {
+      return needManualCalc() ? getCalculatedWidth(element, getBoxSizing(element)) : getProp(element, 'width', element.dom.offsetWidth);
+    };
+    var getInnerWidth = function (element) {
+      return getCalculatedWidth(element, 'content-box');
+    };
     var api$1 = Dimension('width', function (element) {
       return element.dom.offsetWidth;
     });
     var get$8 = function (element) {
       return api$1.get(element);
     };
     var getOuter$2 = function (element) {
       return api$1.getOuter(element);
     };
+    var getInner = getInnerWidth;
+    var getRuntime$1 = getWidth;
     var columns = function (warehouse, isValidCell) {
       if (isValidCell === void 0) {
         isValidCell = always;
+      }
       return api.get(element);
     };
     var getOuter$1 = function (element) {
       return api.getOuter(element);
     };
+    var getRuntime = getHeight$1;
     var r = function (left, top) {
       var translate = function (x, y) {
         return r(left + x, top + y);
       };
           return Optional.none();
+        }
       });
     };
-    var needManualCalc = function () {
-      var browser = detect$3().browser;
-      return browser.isIE() || browser.isEdge();
-    };
-    var toNumber = function (px, fallback) {
-      var num = parseFloat(px);
-      return isNaN(num) ? fallback : num;
-    };
-    var getProp = function (elm, name, fallback) {
-      return toNumber(get$a(elm, name), fallback);
-    };
-    var getCalculatedHeight = function (cell) {
-      var height = cell.dom.getBoundingClientRect().height;
-      var boxSizing = get$a(cell, 'box-sizing');
-      if (boxSizing === 'border-box') {
-        return height;
-      } else {
-        var paddingTop = getProp(cell, 'padding-top', 0);
-        var paddingBottom = getProp(cell, 'padding-bottom', 0);
-        var borderTop = getProp(cell, 'border-top-width', 0);
-        var borderBottom = getProp(cell, 'border-bottom-width', 0);
-        var borders = borderTop + borderBottom;
-        return height - paddingTop - paddingBottom - borders;
-      }
-    };
-    var getCalculatedWidth = function (cell) {
-      var width = cell.dom.getBoundingClientRect().width;
-      var boxSizing = get$a(cell, 'box-sizing');
-      if (boxSizing === 'border-box') {
-        return width;
-      } else {
-        var paddingLeft = getProp(cell, 'padding-left', 0);
-        var paddingRight = getProp(cell, 'padding-right', 0);
-        var borderLeft = getProp(cell, 'border-left-width', 0);
-        var borderRight = getProp(cell, 'border-right-width', 0);
-        var borders = borderLeft + borderRight;
-        return width - paddingLeft - paddingRight - borders;
-      }
-    };
-    var getHeight$1 = function (cell) {
-      return needManualCalc() ? getCalculatedHeight(cell) : getProp(cell, 'height', get$7(cell));
-    };
-    var getWidth = function (cell) {
-      return needManualCalc() ? getCalculatedWidth(cell) : getProp(cell, 'width', get$8(cell));
-    };
     var rPercentageBasedSizeRegex = /(\d+(\.\d+)?)%/;
     var rPixelBasedSizeRegex = /(\d+(\.\d+)?)px|em/;
+    var isCol$2 = isTag('col');
-    var getPercentSize = function (elm, getter) {
+    var getPercentSize = function (elm, outerGetter, innerGetter) {
-      var relativeParent = offsetParent(elm).getOr(getBody$1(owner(elm)));
+      var relativeParent = parentElement(elm).getOrThunk(function () {
+        return getBody$1(owner(elm));
+      });
-      return getter(elm) / getter(relativeParent) * 100;
+      return outerGetter(elm) / innerGetter(relativeParent) * 100;
     };
     var setPixelWidth = function (cell, amount) {
       set$1(cell, 'width', amount + 'px');
     };
     var setPercentageWidth = function (cell, amount) {
     };
     var setHeight = function (cell, amount) {
       set$1(cell, 'height', amount + 'px');
     };
     var getHeightValue = function (cell) {
-      return getRaw$2(cell, 'height').getOrThunk(function () {
-        return getHeight$1(cell) + 'px';
+      return getRuntime(cell) + 'px';
-      });
     };
     var convert = function (cell, number, getter, setter) {
       var newSize = table(cell).map(function (table) {
         var total = getter(table);
         return Math.floor(number / 100 * total);
       }).getOr(number);
       setter(cell, newSize);
       return newSize;
     };
     var normalizePixelSize = function (value, cell, getter, setter) {
-      var number = parseInt(value, 10);
+      var number = parseFloat(value);
       return endsWith(value, '%') && name(cell) !== 'table' ? convert(cell, number, getter, setter) : number;
     };
     var getTotalHeight = function (cell) {
       var value = getHeightValue(cell);
       if (!value) {
     var get$6 = function (cell, type, f) {
       var v = f(cell);
       var span = getSpan(cell, type);
       return v / span;
     };
-    var getRawWidth$1 = function (element) {
+    var getRaw$1 = function (element, prop) {
-      var cssWidth = getRaw$2(element, 'width');
-      return cssWidth.fold(function () {
+      return getRaw$2(element, prop).orThunk(function () {
-        return Optional.from(get$b(element, 'width'));
+        return getOpt(element, prop).map(function (val) {
-      }, function (width) {
-        return Optional.some(width);
+          return val + 'px';
-      });
+        });
-    };
-    var normalizePercentageWidth = function (cellWidth, tableSize) {
-      return cellWidth / tableSize.pixelWidth() * 100;
-    };
-    var choosePercentageSize = function (element, width, tableSize) {
-      var percentMatch = rPercentageBasedSizeRegex.exec(width);
-      if (percentMatch !== null) {
-        return parseFloat(percentMatch[1]);
-      } else {
-        var intWidth = getWidth(element);
-        return normalizePercentageWidth(intWidth, tableSize);
-      }
-    };
-    var getPercentageWidth = function (cell, tableSize) {
-      var width = getRawWidth$1(cell);
-      return width.fold(function () {
-        var intWidth = get$8(cell);
-        return normalizePercentageWidth(intWidth, tableSize);
-      }, function (w) {
-        return choosePercentageSize(cell, w, tableSize);
       });
     };
-    var normalizePixelWidth = function (cellWidth, tableSize) {
+    var getRawWidth$1 = function (element) {
-      return cellWidth / 100 * tableSize.pixelWidth();
+      return getRaw$1(element, 'width');
     };
-    var choosePixelSize = function (element, width, tableSize) {
+    var getRawHeight = function (element) {
-      var pixelMatch = rPixelBasedSizeRegex.exec(width);
-      if (pixelMatch !== null) {
-        return parseInt(pixelMatch[1], 10);
-      }
-      var percentMatch = rPercentageBasedSizeRegex.exec(width);
-      if (percentMatch !== null) {
-        var floatWidth = parseFloat(percentMatch[1]);
-        return normalizePixelWidth(floatWidth, tableSize);
-      }
-      return getWidth(element);
+      return getRaw$1(element, 'height');
     };
-    var getPixelWidth$1 = function (cell, tableSize) {
+    var getPercentageWidth = function (cell) {
-      var width = getRawWidth$1(cell);
-      return width.fold(function () {
+      return getPercentSize(cell, get$8, getInner);
-        return getWidth(cell);
+    };
-      }, function (w) {
+    var getPixelWidth$1 = function (cell) {
-        return choosePixelSize(cell, w, tableSize);
+      return isCol$2(cell) ? get$8(cell) : getRuntime$1(cell);
-      });
     };
     var getHeight = function (cell) {
       return get$6(cell, 'rowspan', getTotalHeight);
     };
     var getGenericWidth = function (cell) {
       set$1(cell, 'width', amount + unit);
     };
     var getPixelTableWidth = function (table) {
       return get$8(table) + 'px';
     };
-    var getPercentTableWidth$1 = function (table) {
+    var getPercentTableWidth = function (table) {
-      return getPercentSize(table, get$8) + '%';
+      return getPercentSize(table, get$8, getInner) + '%';
     };
     var isPercentSizing$1 = function (table) {
       return getRawWidth$1(table).exists(function (size) {
         return rPercentageBasedSizeRegex.test(size);
       });
     };
     var isNoneSizing$1 = function (table) {
       return getRawWidth$1(table).isNone();
     };
     var percentageBasedSizeRegex = constant(rPercentageBasedSizeRegex);
-    var pixelBasedSizeRegex = constant(rPixelBasedSizeRegex);
     var isCol$1 = isTag('col');
-    var getRaw$1 = function (cell, property, getter) {
+    var getRawW = function (cell) {
-      return getRaw$2(cell, property).getOrThunk(function () {
+      return getRawWidth$1(cell).getOrThunk(function () {
-        return getter(cell) + 'px';
+        return getPixelWidth$1(cell) + 'px';
       });
     };
-    var getRawW = function (cell, tableSize) {
-      var fallback = function (e) {
-        return isCol$1(e) ? get$8(e) : getPixelWidth$1(e, tableSize);
-      };
-      return getRaw$1(cell, 'width', fallback);
-    };
     var getRawH = function (cell) {
-      return getRaw$1(cell, 'height', getHeight);
+      return getRawHeight(cell).getOrThunk(function () {
+        return getHeight(cell) + 'px';
+      });
     };
     var justCols = function (warehouse) {
       return map$1(Warehouse.justColumns(warehouse), function (column) {
         return Optional.from(column.element);
       });
     };
-    var hasRawStyle = function (cell, prop) {
-      return getRaw$2(cell, prop).isSome();
-    };
     var isValidColumn = function (cell) {
+      var browser = detect$3().browser;
+      var supportsColWidths = browser.isChrome() || browser.isFirefox();
-      return !isCol$1(cell) || hasRawStyle(cell, 'width');
+      return isCol$1(cell) ? supportsColWidths : true;
     };
     var getDimension = function (cellOpt, index, backups, filter, getter, fallback) {
       return cellOpt.filter(filter).fold(function () {
         return fallback(deduce(backups, index));
       }, function (cell) {
         return getter(cell);
       });
     };
-    var getWidthFrom = function (warehouse, table, getWidth, fallback, tableSize) {
+    var getWidthFrom = function (warehouse, table, getWidth, fallback) {
-      var columnCells = columns(warehouse, function (cell) {
+      var columnCells = columns(warehouse);
-        return hasRawStyle(cell, 'width');
-      });
       var columns$1 = Warehouse.hasColumns(warehouse) ? justCols(warehouse) : columnCells;
       var backups = [Optional.some(width.edge(table))].concat(map$1(width.positions(columnCells, table), function (pos) {
         return pos.map(function (p) {
           return p.x;
         });
       }));
       var colFilter = not(hasColspan);
       return map$1(columns$1, function (cellOption, c) {
         return getDimension(cellOption, c, backups, colFilter, function (column) {
           if (isValidColumn(column)) {
-            return getWidth(column, tableSize);
+            return getWidth(column);
           } else {
             var cell = bindFrom(columnCells[c], identity);
             return getDimension(cell, c, backups, colFilter, function (cell) {
               return fallback(Optional.some(get$8(cell)));
             }, fallback);
     var getDeduced = function (deduced) {
       return deduced.map(function (d) {
         return d + 'px';
       }).getOr('');
     };
-    var getRawWidths = function (warehouse, table, tableSize) {
+    var getRawWidths = function (warehouse, table) {
-      return getWidthFrom(warehouse, table, getRawW, getDeduced, tableSize);
+      return getWidthFrom(warehouse, table, getRawW, getDeduced);
     };
     var getPercentageWidths = function (warehouse, table, tableSize) {
       return getWidthFrom(warehouse, table, getPercentageWidth, function (deduced) {
         return deduced.fold(function () {
           return tableSize.minCellWidth();
         }, function (cellWidth) {
           return cellWidth / tableSize.pixelWidth() * 100;
         });
-      }, tableSize);
+      });
     };
     var getPixelWidths = function (warehouse, table, tableSize) {
       return getWidthFrom(warehouse, table, getPixelWidth$1, function (deduced) {
         return deduced.getOrThunk(tableSize.minCellWidth);
-      }, tableSize);
+      });
     };
     var getHeightFrom = function (warehouse, table, direction, getHeight, fallback) {
       var rows$1 = rows(warehouse);
       var backups = [Optional.some(direction.edge(table))].concat(map$1(direction.positions(rows$1, table), function (pos) {
         return pos.map(function (p) {
     };
     var getRawHeights = function (warehouse, table, direction) {
       return getHeightFrom(warehouse, table, direction, getRawH, getDeduced);
     };
-    var Cell = function (initial) {
+    var widthLookup = function (table, getter) {
-      var value = initial;
-      var get = function () {
+      return function () {
-        return value;
+        if (inBody(table)) {
-      };
-      var set = function (v) {
+          return getter(table);
-        value = v;
+        } else {
-      };
-      return {
-        get: get,
+          return parseFloat(getRaw$2(table, 'width').getOr('0'));
-        set: set
+        }
       };
     };
     var noneSize = function (table) {
-      var getWidth = function () {
+      var getWidth = widthLookup(table, get$8);
-        return get$8(table);
-      };
       var zero = constant(0);
       var getWidths = function (warehouse, tableSize) {
         return getPixelWidths(warehouse, table, tableSize);
       };
       return {
         adjustTableWidth: noop,
         isRelative: true,
         label: 'none'
       };
     };
-    var percentageSize = function (initialWidth, table) {
+    var percentageSize = function (table) {
-      var floatWidth = Cell(parseFloat(initialWidth));
+      var getFloatWidth = widthLookup(table, function (elem) {
+        return parseFloat(getPercentTableWidth(elem));
+      });
-      var pixelWidth = Cell(get$8(table));
+      var getWidth = widthLookup(table, get$8);
       var getCellDelta = function (delta) {
-        return delta / pixelWidth.get() * 100;
+        return delta / getWidth() * 100;
       };
       var singleColumnWidth = function (w, _delta) {
         return [100 - w];
       };
       var minCellWidth = function () {
-        return minWidth() / pixelWidth.get() * 100;
+        return minWidth() / getWidth() * 100;
       };
       var adjustTableWidth = function (delta) {
-        var currentWidth = floatWidth.get();
+        var currentWidth = getFloatWidth();
         var change = delta / 100 * currentWidth;
         var newWidth = currentWidth + change;
         setPercentageWidth(table, newWidth);
-        floatWidth.set(newWidth);
-        pixelWidth.set(get$8(table));
       };
       var getWidths = function (warehouse, tableSize) {
         return getPercentageWidths(warehouse, table, tableSize);
       };
       return {
-        width: floatWidth.get,
+        width: getFloatWidth,
-        pixelWidth: pixelWidth.get,
+        pixelWidth: getWidth,
         getWidths: getWidths,
         getCellDelta: getCellDelta,
         singleColumnWidth: singleColumnWidth,
         minCellWidth: minCellWidth,
         setElementWidth: setPercentageWidth,
         adjustTableWidth: adjustTableWidth,
         isRelative: true,
         label: 'percent'
       };
     };
-    var pixelSize = function (initialWidth, table) {
+    var pixelSize = function (table) {
-      var width = Cell(initialWidth);
-      var getWidth = width.get;
+      var getWidth = widthLookup(table, get$8);
       var getCellDelta = identity;
       var singleColumnWidth = function (w, delta) {
         var newNext = Math.max(minWidth(), w + delta);
         return [newNext - w];
       };
       var adjustTableWidth = function (delta) {
         var newWidth = getWidth() + delta;
         setPixelWidth(table, newWidth);
-        width.set(newWidth);
       };
       var getWidths = function (warehouse, tableSize) {
         return getPixelWidths(warehouse, table, tableSize);
       };
       return {
       };
     };
     var chooseSize = function (element, width) {
       var percentMatch = percentageBasedSizeRegex().exec(width);
       if (percentMatch !== null) {
-        return percentageSize(percentMatch[1], element);
+        return percentageSize(element);
-      }
+      } else {
-      var pixelMatch = pixelBasedSizeRegex().exec(width);
-      if (pixelMatch !== null) {
-        var intWidth = parseInt(pixelMatch[1], 10);
-        return pixelSize(intWidth, element);
+        return pixelSize(element);
+      }
-      var fallbackWidth = get$8(element);
-      return pixelSize(fallbackWidth, element);
     };
     var getTableSize = function (table) {
       var width = getRawWidth$1(table);
       return width.fold(function () {
         return noneSize(table);
         col: newCol,
         colgroup: createColgroup(doc),
         row: createRow$1(doc),
         cell: newCell,
         replace: replace$1,
+        colGap: createCol(doc),
         gap: createCell(doc)
       };
     };
     var paste$1 = function (doc) {
       return {
         col: createCol(doc),
         colgroup: createColgroup(doc),
         row: createRow$1(doc),
         cell: createCell(doc),
         replace: pasteReplace,
+        colGap: createCol(doc),
         gap: createCell(doc)
       };
     };
     var fromHtml = function (html, scope) {
       var removeStyleAttribute = function (element) {
         return remove$7(element, 'data-mce-style');
       };
       each$2(cells$1(table), removeStyleAttribute);
       each$2(columns$1(table), removeStyleAttribute);
+      each$2(rows$1(table), removeStyleAttribute);
     };
     var getRawWidth = function (editor, elm) {
       var raw = editor.dom.getStyle(elm, 'width') || editor.dom.getAttrib(elm, 'width');
       return Optional.from(raw).filter(isNotEmpty);
     };
       });
     };
     var getUnit = function (newSize) {
       return validate(newSize).fold(constant('px'), constant('px'), constant('%'));
     };
-    var redistribute = function (table, optWidth, optHeight, tableSize) {
+    var redistribute = function (table, optWidth, optHeight) {
       var warehouse = Warehouse.fromTable(table);
       var rows = warehouse.all;
       var cells = Warehouse.justCells(warehouse);
       var columns = Warehouse.justColumns(warehouse);
       optWidth.each(function (newWidth) {
         var widthUnit = getUnit(newWidth);
         var totalWidth = get$8(table);
-        var oldWidths = getRawWidths(warehouse, table, tableSize);
+        var oldWidths = getRawWidths(warehouse, table);
         var nuWidths = redistribute$1(oldWidths, totalWidth, newWidth);
         if (Warehouse.hasColumns(warehouse)) {
           redistributeToColumns(nuWidths, columns, widthUnit);
         } else {
           redistributeToW(nuWidths, cells, widthUnit);
       });
     };
     var isPercentSizing = isPercentSizing$1;
     var isPixelSizing = isPixelSizing$1;
     var isNoneSizing = isNoneSizing$1;
-    var getPercentTableWidth = getPercentTableWidth$1;
     var getGridSize = function (table) {
       var warehouse = Warehouse.fromTable(table);
       return warehouse.grid;
     };
         title: type,
         value: type.toLowerCase()
       };
     });
     var determineDefaultStyles = function (editor) {
+      var _a;
       if (isPixelsForced(editor)) {
-        var editorWidth = editor.getBody().offsetWidth;
+        var dom = editor.dom;
+        var parentBlock = (_a = dom.getParent(editor.selection.getStart(), dom.isBlock)) !== null && _a !== void 0 ? _a : editor.getBody();
+        var contentWidth = getInner(SugarElement.fromDom(parentBlock));
-        return __assign(__assign({}, defaultStyles), { width: editorWidth + 'px' });
+        return __assign(__assign({}, defaultStyles), { width: contentWidth + 'px' });
       } else if (isResponsiveForced(editor)) {
         return filter$1(defaultStyles, function (_value, key) {
           return key !== 'width';
         });
       } else {
       return editor.getParam('table_border_color_map', [], 'array');
     };
     var get$4 = function (editor, table) {
       if (isPercentagesForced(editor)) {
-        var width = getRawWidth(editor, table.dom).filter(isPercentage$1).getOrThunk(function () {
-          return getPercentTableWidth(table);
-        });
-        return TableSize.percentageSize(width, table);
+        return TableSize.percentageSize(table);
       } else if (isPixelsForced(editor)) {
-        return TableSize.pixelSize(get$8(table), table);
+        return TableSize.pixelSize(table);
       } else {
         return TableSize.getTableSize(table);
+      }
     };
     var cleanupLegacyAttributes = function (element) {
       remove$7(element, 'width');
     };
-    var convertToPercentSize = function (table, tableSize) {
+    var convertToPercentSize = function (table) {
-      var newWidth = getPercentTableWidth$1(table);
+      var newWidth = getPercentTableWidth(table);
-      redistribute(table, Optional.some(newWidth), Optional.none(), tableSize);
+      redistribute(table, Optional.some(newWidth), Optional.none());
       cleanupLegacyAttributes(table);
     };
-    var convertToPixelSize = function (table, tableSize) {
+    var convertToPixelSize = function (table) {
       var newWidth = getPixelTableWidth(table);
-      redistribute(table, Optional.some(newWidth), Optional.none(), tableSize);
+      redistribute(table, Optional.some(newWidth), Optional.none());
       cleanupLegacyAttributes(table);
     };
     var convertToNoneSize = function (table) {
       remove$6(table, 'width');
       var columns = columns$1(table);
         cleanupLegacyAttributes(cell);
       });
       cleanupLegacyAttributes(table);
     };
-    var enforcePercentage = function (editor, table) {
+    var enforcePercentage = convertToPercentSize;
-      var tableSizing = get$4(editor, table);
-      convertToPercentSize(table, tableSizing);
-    };
-    var enforcePixels = function (editor, table) {
+    var enforcePixels = convertToPixelSize;
-      var tableSizing = get$4(editor, table);
-      convertToPixelSize(table, tableSizing);
-    };
     var enforceNone = convertToNoneSize;
     var syncPixels = function (table) {
       var warehouse = Warehouse.fromTable(table);
       if (!Warehouse.hasColumns(warehouse)) {
         each$2(cells$1(table), function (cell) {
         return getGridSize(table).columns;
       };
       var afterCornerResize = function (table, origin, width) {
         var isRightEdgeResize = endsWith(origin, 'e');
         if (startRawW === '') {
-          enforcePercentage(editor, table);
+          enforcePercentage(table);
+        }
         if (width !== startW && startRawW !== '') {
           set$1(table, 'width', startRawW);
           var resizing = lazyResizingBehaviour();
           var tableSize = lazySizing(table);
           var table = SugarElement.fromDom(targetElm);
           each$2(editor.dom.select('.mce-clonedresizable'), function (clone) {
             editor.dom.addClass(clone, 'mce-' + getColumnResizingBehaviour(editor) + '-columns');
           });
           if (!isPixelSizing(table) && isPixelsForced(editor)) {
-            enforcePixels(editor, table);
+            enforcePixels(table);
           } else if (!isPercentSizing(table) && isPercentagesForced(editor)) {
-            enforcePercentage(editor, table);
+            enforcePercentage(table);
+          }
           if (isNoneSizing(table) && startsWith(e.origin, barResizerPrefix)) {
-            enforcePercentage(editor, table);
+            enforcePercentage(table);
+          }
           startW = e.width;
           startRawW = isResponsiveForced(editor) ? '' : getRawWidth(editor, targetElm).getOr('');
+        }
       });
           setGenericWidth(other, newWidth, w.unit);
         });
+      }
     };
-    var isTableHeaderCell = isTag('th');
+    var isHeaderCell = isTag('th');
+    var isHeaderCells = function (cells) {
+      return forall(cells, function (cell) {
+        return isHeaderCell(cell.element);
+      });
+    };
     var getRowHeaderType = function (isHeaderRow, isHeaderCells) {
       if (isHeaderRow && isHeaderCells) {
         return 'sectionCells';
       } else if (isHeaderRow) {
         return 'section';
         return { type: 'body' };
+      }
     };
     var findCommonCellType = function (cells) {
       var headerCells = filter$2(cells, function (cell) {
-        return isTableHeaderCell(cell.element);
+        return isHeaderCell(cell.element);
       });
       if (headerCells.length === 0) {
         return Optional.some('td');
       } else if (headerCells.length === cells.length) {
         return Optional.some('th');
         return !comp(first.element, x.element);
       });
       return index.getOr(xs.length);
     };
     var subgrid = function (grid, row, column, comparator) {
-      var restOfRow = getRow(grid, row).cells.slice(column);
+      var gridRow = getRow(grid, row);
-      var endColIndex = findDiff(restOfRow, comparator);
+      var isColRow = gridRow.section === 'colgroup';
-      var restOfColumn = getColumn(grid, column).slice(row);
+      var colspan = findDiff(gridRow.cells.slice(column), comparator);
-      var endRowIndex = findDiff(restOfColumn, comparator);
+      var rowspan = isColRow ? 1 : findDiff(getColumn(grid.slice(row), column), comparator);
       return {
-        colspan: endColIndex,
+        colspan: colspan,
-        rowspan: endRowIndex
+        rowspan: rowspan
       };
     };
     var toDetails = function (grid, comparator) {
       var seen = map$1(grid, function (row) {
       });
     };
     var toGrid = function (warehouse, generators, isNew) {
       var grid = [];
       each$2(warehouse.colgroups, function (colgroup) {
+        var colgroupCols = [];
+        for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) {
-        var cols = map$1(colgroup.columns, function (column) {
+          var element = Warehouse.getColumnAt(warehouse, columnIndex).map(function (column) {
-          return elementnew(column.element, isNew, false);
+            return elementnew(column.element, isNew, false);
+          }).getOrThunk(function () {
+            return elementnew(generators.colGap(), true, false);
-        });
+          });
+          colgroupCols.push(element);
+        }
-        grid.push(rowcells(colgroup.element, cols, 'colgroup', isNew));
+        grid.push(rowcells(colgroup.element, colgroupCols, 'colgroup', isNew));
       });
       for (var rowIndex = 0; rowIndex < warehouse.grid.rows; rowIndex++) {
         var rowCells = [];
         for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) {
           var element = Warehouse.getAt(warehouse, rowIndex, columnIndex).map(function (item) {
     var deleteRowsAt = function (grid, start, finish) {
       var _a = extractGridDetails(grid), rows = _a.rows, cols = _a.cols;
       return cols.concat(rows.slice(0, start)).concat(rows.slice(finish + 1));
     };
+    var notInStartRow = function (grid, rowIndex, colIndex, comparator) {
+      return getCellElement(grid[rowIndex], colIndex) !== undefined && (rowIndex > 0 && comparator(getCellElement(grid[rowIndex - 1], colIndex), getCellElement(grid[rowIndex], colIndex)));
+    };
+    var notInStartColumn = function (row, index, comparator) {
+      return index > 0 && comparator(getCellElement(row, index - 1), getCellElement(row, index));
+    };
+    var isDuplicatedCell = function (grid, rowIndex, colIndex, comparator) {
+      return notInStartRow(grid, rowIndex, colIndex, comparator) || notInStartColumn(grid[rowIndex], colIndex, comparator);
+    };
+    var rowReplacerPredicate = function (targetRow, columnHeaders) {
+      var entireTableIsHeader = forall(columnHeaders, identity) && isHeaderCells(targetRow.cells);
+      return entireTableIsHeader ? always : function (cell, _rowIndex, colIndex) {
+        var type = name(cell.element);
+        return !(type === 'th' && columnHeaders[colIndex]);
+      };
+    };
+    var columnReplacePredicate = function (targetColumn, rowHeaders) {
+      var entireTableIsHeader = forall(rowHeaders, identity) && isHeaderCells(targetColumn);
+      return entireTableIsHeader ? always : function (cell, rowIndex, _colIndex) {
+        var type = name(cell.element);
+        return !(type === 'th' && rowHeaders[rowIndex]);
+      };
+    };
+    var determineScope = function (applyScope, element, newScope, isInHeader) {
+      var hasSpan = function (scope) {
+        return scope === 'row' ? hasRowspan(element) : hasColspan(element);
+      };
+      var getScope = function (scope) {
+        return hasSpan(scope) ? scope + 'group' : scope;
+      };
+      if (applyScope) {
+        return isHeaderCell(element) ? getScope(newScope) : null;
+      } else if (isInHeader && isHeaderCell(element)) {
+        var oppositeScope = newScope === 'row' ? 'col' : 'row';
+        return getScope(oppositeScope);
+      } else {
+        return null;
+      }
+    };
+    var rowScopeGenerator = function (applyScope, columnHeaders) {
+      return function (cell, rowIndex, columnIndex) {
+        return Optional.some(determineScope(applyScope, cell.element, 'col', columnHeaders[columnIndex]));
+      };
+    };
+    var columnScopeGenerator = function (applyScope, rowHeaders) {
+      return function (cell, rowIndex) {
+        return Optional.some(determineScope(applyScope, cell.element, 'row', rowHeaders[rowIndex]));
+      };
+    };
     var replace = function (cell, comparator, substitute) {
       return elementnew(substitute(cell.element, comparator), true, cell.isLocked);
     };
-    var replaceIn = function (grid, targets, comparator, substitute, replacer) {
+    var replaceIn = function (grid, targets, comparator, substitute, replacer, genScope, shouldReplace) {
       var isTarget = function (cell) {
         return exists(targets, function (target) {
           return comparator(cell.element, target.element);
         });
       };
-      return map$1(grid, function (row) {
+      return map$1(grid, function (row, rowIndex) {
-        return mapCells(row, function (cell) {
+        return mapCells(row, function (cell, colIndex) {
+          if (isTarget(cell)) {
-          return isTarget(cell) ? replacer(cell, comparator, substitute) : cell;
+            var newCell_1 = shouldReplace(cell, rowIndex, colIndex) ? replacer(cell, comparator, substitute) : cell;
+            genScope(newCell_1, rowIndex, colIndex).each(function (scope) {
+              setOptions(newCell_1.element, { scope: Optional.from(scope) });
+            });
+            return newCell_1;
+          } else {
+            return cell;
+          }
         });
       });
     };
-    var notStartRow = function (grid, rowIndex, colIndex, comparator) {
+    var getColumnCells = function (rows, columnIndex, comparator) {
+      return bind$2(rows, function (row, i) {
-      return getCellElement(grid[rowIndex], colIndex) !== undefined && (rowIndex > 0 && comparator(getCellElement(grid[rowIndex - 1], colIndex), getCellElement(grid[rowIndex], colIndex)));
+        return isDuplicatedCell(rows, i, columnIndex, comparator) ? [] : [getCell(row, columnIndex)];
+      });
     };
-    var notStartColumn = function (row, index, comparator) {
+    var getRowCells = function (rows, rowIndex, comparator) {
+      var targetRow = rows[rowIndex];
+      return bind$2(targetRow.cells, function (item, i) {
-      return index > 0 && comparator(getCellElement(row, index - 1), getCellElement(row, index));
+        return isDuplicatedCell(rows, rowIndex, i, comparator) ? [] : [item];
+      });
     };
-    var replaceColumn = function (grid, index, comparator, substitution) {
+    var replaceColumns = function (grid, indexes, applyScope, comparator, substitution) {
       var rows = extractGridDetails(grid).rows;
-      var targets = bind$2(rows, function (row, i) {
+      var targets = bind$2(indexes, function (index) {
-        var alreadyAdded = notStartRow(rows, i, index, comparator) || notStartColumn(row, index, comparator);
+        return getColumnCells(rows, index, comparator);
+      });
+      var rowHeaders = map$1(grid, function (row) {
-        return alreadyAdded ? [] : [getCell(row, index)];
+        return isHeaderCells(row.cells);
       });
+      var shouldReplaceCell = columnReplacePredicate(targets, rowHeaders);
+      var scopeGenerator = columnScopeGenerator(applyScope, rowHeaders);
-      return replaceIn(grid, targets, comparator, substitution, replace);
+      return replaceIn(grid, targets, comparator, substitution, replace, scopeGenerator, shouldReplaceCell);
     };
-    var replaceRow = function (grid, index, section, comparator, substitution, tableSection) {
+    var replaceRows = function (grid, indexes, section, applyScope, comparator, substitution, tableSection) {
       var _a = extractGridDetails(grid), cols = _a.cols, rows = _a.rows;
-      var targetRow = rows[index];
+      var targetRow = rows[indexes[0]];
-      var targets = bind$2(targetRow.cells, function (item, i) {
+      var targets = bind$2(indexes, function (index) {
-        var alreadyAdded = notStartRow(rows, index, i, comparator) || notStartColumn(targetRow, i, comparator);
+        return getRowCells(rows, index, comparator);
+      });
+      var columnHeaders = map$1(targetRow.cells, function (_cell, index) {
-        return alreadyAdded ? [] : [item];
+        return isHeaderCells(getColumnCells(rows, index, comparator));
       });
-      var newRows = __spreadArray([], rows);
+      var newRows = __spreadArray([], rows, true);
+      each$2(indexes, function (index) {
-      newRows[index] = tableSection.transformRow(targetRow, section);
+        newRows[index] = tableSection.transformRow(rows[index], section);
+      });
+      var newGrid = cols.concat(newRows);
+      var shouldReplaceCell = rowReplacerPredicate(targetRow, columnHeaders);
+      var scopeGenerator = rowScopeGenerator(applyScope, columnHeaders);
-      return replaceIn(cols.concat(newRows), targets, comparator, substitution, tableSection.transformCell);
+      return replaceIn(newGrid, targets, comparator, substitution, tableSection.transformCell, scopeGenerator, shouldReplaceCell);
     };
-    var replaceCell = function (grid, rowIndex, columnIndex, comparator, substitution) {
+    var replaceCells = function (grid, details, comparator, substitution) {
       var rows = extractGridDetails(grid).rows;
-      var targetRow = rows[rowIndex];
+      var targetCells = map$1(details, function (detail) {
-      var targetCell = getCell(targetRow, columnIndex);
+        return getCell(rows[detail.row], detail.column);
+      });
-      return replaceIn(grid, [targetCell], comparator, substitution, replace);
+      return replaceIn(grid, targetCells, comparator, substitution, replace, Optional.none, always);
     };
     var uniqueColumns = function (details) {
       var uniqueCheck = function (rest, detail) {
         var columnExists = exists(rest, function (currentDetail) {
           return comparator(element, p.item) ? p.replacement : add(element);
         });
       };
       return { getOrInit: getOrInit };
     };
-    var transform = function (tag, scope) {
+    var transform = function (tag) {
       return function (generators) {
         var list = [];
         var find = function (element, comparator) {
           return find$1(list, function (x) {
             return comparator(x.item, element);
           });
         };
         var makeNew = function (element) {
-          var attrs = isUndefined(scope) ? {} : { scope: scope };
+          var attrs = tag === 'td' ? { scope: null } : {};
           var cell = generators.replace(element, tag, attrs);
           list.push({
             item: element,
             sub: cell
           });
         return insertColumnAt(newG, targetIndex, col.column, comparator, genWrappers.getOrInit);
       }, grid);
       return bundle(newGrid, details[0].row, targetIndex);
     };
     var opMakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) {
-      var replacer = function (currentGrid, column) {
-        return replaceColumn(currentGrid, column.column, comparator, genWrappers.replaceOrInit);
-      };
       var columns = uniqueColumns(details);
-      var newGrid = foldl(columns, replacer, initialGrid);
+      var columnIndexes = map$1(columns, function (detail) {
+        return detail.column;
+      });
+      var newGrid = replaceColumns(initialGrid, columnIndexes, true, comparator, genWrappers.replaceOrInit);
       return bundle(newGrid, details[0].row, details[0].column);
     };
     var opMakeCellsHeader = function (initialGrid, details, comparator, genWrappers) {
-      var replacer = function (currentGrid, detail) {
-        return replaceCell(currentGrid, detail.row, detail.column, comparator, genWrappers.replaceOrInit);
+      var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit);
-      };
-      var newGrid = foldl(details, replacer, initialGrid);
       return bundle(newGrid, details[0].row, details[0].column);
     };
     var opUnmakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) {
-      var replacer = function (currentGrid, column) {
-        return replaceColumn(currentGrid, column.column, comparator, genWrappers.replaceOrInit);
-      };
       var columns = uniqueColumns(details);
-      var newGrid = foldl(columns, replacer, initialGrid);
+      var columnIndexes = map$1(columns, function (detail) {
+        return detail.column;
+      });
+      var newGrid = replaceColumns(initialGrid, columnIndexes, false, comparator, genWrappers.replaceOrInit);
       return bundle(newGrid, details[0].row, details[0].column);
     };
     var opUnmakeCellsHeader = function (initialGrid, details, comparator, genWrappers) {
-      var replacer = function (currentGrid, detail) {
-        return replaceCell(currentGrid, detail.row, detail.column, comparator, genWrappers.replaceOrInit);
+      var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit);
-      };
-      var newGrid = foldl(details, replacer, initialGrid);
       return bundle(newGrid, details[0].row, details[0].column);
     };
-    var makeRowsSection = function (section) {
+    var makeRowsSection = function (section, applyScope) {
       return function (initialGrid, details, comparator, genWrappers, tableSection) {
-        var replacer = function (currentGrid, detail) {
-          return replaceRow(currentGrid, detail.row, section, comparator, genWrappers.replaceOrInit, tableSection);
-        };
         var rows = uniqueRows(details);
-        var newGrid = foldl(rows, replacer, initialGrid);
+        var rowIndexes = map$1(rows, function (detail) {
+          return detail.row;
+        });
+        var newGrid = replaceRows(initialGrid, rowIndexes, section, applyScope, comparator, genWrappers.replaceOrInit, tableSection);
         return bundle(newGrid, details[0].row, details[0].column);
       };
     };
-    var opMakeRowsHeader = makeRowsSection('thead');
+    var opMakeRowsHeader = makeRowsSection('thead', true);
-    var opMakeRowsBody = makeRowsSection('tbody');
+    var opMakeRowsBody = makeRowsSection('tbody', false);
-    var opMakeRowsFooter = makeRowsSection('tfoot');
+    var opMakeRowsFooter = makeRowsSection('tfoot', false);
     var opEraseColumns = function (grid, extractDetail, _comparator, _genWrappers) {
       var columns = uniqueColumns(extractDetail.details);
       var newGrid = deleteColumnsAt(grid, map$1(columns, function (column) {
         return column.column;
       }));
           var checkLocked = before ? firstColumnIsLocked : lastColumnIsLocked;
           return !checkLocked(warehouse, details.cells);
         });
       };
     };
+    var headerCellGenerator = Generators.transform('th');
+    var bodyCellGenerator = Generators.transform('td');
     var insertRowsBefore = run(opInsertRowsBefore, onCells, noop, noop, Generators.modification);
     var insertRowsAfter = run(opInsertRowsAfter, onCells, noop, noop, Generators.modification);
     var insertColumnsBefore = run(opInsertColumnsBefore, insertColumnsExtractor(true), adjustAndRedistributeWidths, noop, Generators.modification);
     var insertColumnsAfter = run(opInsertColumnsAfter, insertColumnsExtractor(false), adjustAndRedistributeWidths, noop, Generators.modification);
     var eraseColumns = run(opEraseColumns, eraseColumnsExtractor, adjustAndRedistributeWidths, prune, Generators.modification);
     var eraseRows = run(opEraseRows, onCells, noop, prune, Generators.modification);
-    var makeColumnsHeader = run(opMakeColumnsHeader, onUnlockedCells, noop, noop, Generators.transform('th', 'row'));
+    var makeColumnsHeader = run(opMakeColumnsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
-    var unmakeColumnsHeader = run(opUnmakeColumnsHeader, onUnlockedCells, noop, noop, Generators.transform('td', null));
+    var unmakeColumnsHeader = run(opUnmakeColumnsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
-    var makeRowsHeader = run(opMakeRowsHeader, onUnlockedCells, noop, noop, Generators.transform('th', 'col'));
+    var makeRowsHeader = run(opMakeRowsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
-    var makeRowsBody = run(opMakeRowsBody, onUnlockedCells, noop, noop, Generators.transform('td', null));
+    var makeRowsBody = run(opMakeRowsBody, onUnlockedCells, noop, noop, bodyCellGenerator);
-    var makeRowsFooter = run(opMakeRowsFooter, onUnlockedCells, noop, noop, Generators.transform('td', null));
+    var makeRowsFooter = run(opMakeRowsFooter, onUnlockedCells, noop, noop, bodyCellGenerator);
-    var makeCellsHeader = run(opMakeCellsHeader, onUnlockedCells, noop, noop, Generators.transform('th'));
+    var makeCellsHeader = run(opMakeCellsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
-    var unmakeCellsHeader = run(opUnmakeCellsHeader, onUnlockedCells, noop, noop, Generators.transform('td'));
+    var unmakeCellsHeader = run(opUnmakeCellsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
     var mergeCells = run(opMergeCells, onUnlockedMergable, resize, noop, Generators.merging);
     var unmergeCells = run(opUnmergeCells, onUnlockedUnmergable, resize, noop, Generators.merging);
     var pasteCells = run(opPasteCells, onPaste, resize, noop, Generators.modification);
     var pasteColsBefore = run(opPasteColsBefore, pasteColumnsExtractor(true), noop, noop, Generators.modification);
     var pasteColsAfter = run(opPasteColsAfter, pasteColumnsExtractor(false), noop, noop, Generators.modification);
         editor.insertContent(html);
         editor.addVisual();
       });
       return descendant(getBody(editor), 'table[data-mce-id="__mce"]').map(function (table) {
         if (isPixelsForced(editor)) {
-          enforcePixels(editor, table);
+          enforcePixels(table);
         } else if (isResponsiveForced(editor)) {
           enforceNone(table);
         } else if (isPercentagesForced(editor) || isPercentage(defaultStyles.width)) {
-          enforcePercentage(editor, table);
+          enforcePercentage(table);
+        }
         removeDataStyle(table);
         remove$7(table, 'data-mce-id');
         fireEvents(editor, table);
         selectFirstCellInTable(editor, table);
         var lastSelectedCell = selectedCells[selectedCells.length - 1];
         var minColRange = selectedCells[0].column;
         var maxColRange = lastSelectedCell.column + lastSelectedCell.colspan;
         var fakeColGroups = generateColGroup(house, minColRange, maxColRange);
         var fakeRows = generateRows(house, minColRange, maxColRange);
-        return __spreadArray(__spreadArray([], fakeColGroups), fakeRows);
+        return __spreadArray(__spreadArray([], fakeColGroups, true), fakeRows, true);
       });
     };
     var copyRows = function (table, target, generators) {
       var warehouse = Warehouse.fromTable(table);
         var a = rgba[3];
         return fromRgba(rgbaColour(r, g, b, a));
       });
     };
+    var Cell = function (initial) {
+      var value = initial;
+      var get = function () {
+        return value;
+      };
+      var set = function (v) {
+        value = v;
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
     var singleton = function (doRevoke) {
       var subject = Cell(Optional.none());
       var revoke = function () {
         return subject.get().each(doRevoke);
       };
         return getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) {
           var isForcedSizing = isResponsiveForced(editor) || isPixelsForced(editor) || isPercentagesForced(editor);
           if (!isForcedSizing) {
             table(cellOrCaption, isRoot).each(function (table) {
               if (sizing === 'relative' && !isPercentSizing(table)) {
-                enforcePercentage(editor, table);
+                enforcePercentage(table);
               } else if (sizing === 'fixed' && !isPixelSizing(table)) {
-                enforcePixels(editor, table);
+                enforcePixels(table);
               } else if (sizing === 'responsive' && !isNoneSizing(table)) {
                 enforceNone(table);
+              }
               removeDataStyle(table);
               fireTableModified(editor, table.dom, structureModified);
       var keydown = function (event, start, soffset, finish, foffset, direction) {
         var realEvent = event.raw;
         var keycode = realEvent.which;
         var shiftKey = realEvent.shiftKey === true;
         var handler = retrieve$1(container, annotations.selectedSelector).fold(function () {
+          if (isNavigation(keycode) && !shiftKey) {
+            annotations.clearBeforeUpdate(container);
+          }
           if (isDown(keycode) && shiftKey) {
             return curry(select, bridge, container, isRoot, down, finish, start, annotations.selectRange);
           } else if (isUp(keycode) && shiftKey) {
             return curry(select, bridge, container, isRoot, up, finish, start, annotations.selectRange);
           } else if (isDown(keycode)) {
           } else if (direction.isForward(keycode) && shiftKey) {
             return update$1([
               rc(0, +1),
               rc(+1, 0)
             ]);
-          } else if (isNavigation(keycode) && shiftKey === false) {
+          } else if (isNavigation(keycode) && !shiftKey) {
             return clearToNavigate;
           } else {
             return Optional.none;
+          }
         });
       var keyup = function (event, start, soffset, finish, foffset) {
         return retrieve$1(container, annotations.selectedSelector).fold(function () {
           var realEvent = event.raw;
           var keycode = realEvent.which;
           var shiftKey = realEvent.shiftKey === true;
-          if (shiftKey === false) {
+          if (!shiftKey) {
             return Optional.none();
+          }
           if (isNavigation(keycode)) {
             return sync(container, isRoot, start, soffset, finish, foffset, annotations.selectRange);
           } else {
       var clear = function (container) {
         clearBeforeUpdate(container);
         onClear();
       };
       var clearBeforeUpdate = function (container) {
-        var sels = descendants(container, ephemera.selectedSelector);
+        var sels = descendants(container, ephemera.selectedSelector + ',' + ephemera.firstSelectedSelector + ',' + ephemera.lastSelectedSelector);
         each$2(sels, removeSelectionAttributes);
       };
       var selectRange = function (container, cells, start, finish) {
         clear(container);
         each$2(cells, addSelectionAttribute);

Subversion Repositories oidplus

oidplus/trunk/vendor/tinymce/tinymce/plugins/table/plugin.js – Rev 637 → 679