@tabler/core 1.0.0-beta20 → 1.0.0-beta21

package/dist/libs/tinymce/models/dom/model.js

@@ -1,5 +1,5 @@
 /**
- * TinyMCE version 6.4.2 (2023-04-26)
+ * TinyMCE version 7.3.0 (2024-08-07)
  */
 
 (function () {
@@ -749,16 +749,14 @@
     });
 
     const isShadowRoot = dos => isDocumentFragment(dos) && isNonNullable(dos.dom.host);
-    const supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
-    const isSupported$1 = constant(supported);
-    const getRootNode = supported ? e => SugarElement.fromDom(e.dom.getRootNode()) : documentOrOwner;
+    const getRootNode = e => SugarElement.fromDom(e.dom.getRootNode());
     const getShadowRoot = e => {
       const r = getRootNode(e);
       return isShadowRoot(r) ? Optional.some(r) : Optional.none();
     };
     const getShadowHost = e => SugarElement.fromDom(e.dom.host);
     const getOriginalEventTarget = event => {
-      if (isSupported$1() && isNonNullable(event.target)) {
+      if (isNonNullable(event.target)) {
         const el = SugarElement.fromDom(event.target);
         if (isElement(el) && isOpenShadowHost(el)) {
           if (event.composed && event.composedPath) {
@@ -879,7 +877,14 @@
     const bindFrom = (a, f) => a !== undefined && a !== null ? f(a) : Optional.none();
     const someIf = (b, a) => b ? Optional.some(a) : Optional.none();
 
+    const removeFromStart = (str, numChars) => {
+      return str.substring(numChars);
+    };
+
     const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
+    const removeLeading = (str, prefix) => {
+      return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
+    };
     const contains = (str, substr, start = 0, end) => {
       const idx = str.indexOf(substr, start);
       if (idx !== -1) {
@@ -1364,7 +1369,7 @@
     const PlatformDetection = { detect: detect$3 };
 
     const mediaMatch = query => window.matchMedia(query).matches;
-    let platform = cached(() => PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch));
+    let platform = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from(window.navigator.userAgentData), mediaMatch));
     const detect$2 = () => platform();
 
     const Dimension = (name, getOffset) => {
@@ -1835,6 +1840,7 @@
     const rPercentageBasedSizeRegex = /(\d+(\.\d+)?)%/;
     const rPixelBasedSizeRegex = /(\d+(\.\d+)?)px|em/;
     const isCol$2 = isTag('col');
+    const isRow$2 = isTag('tr');
     const getPercentSize = (elm, outerGetter, innerGetter) => {
       const relativeParent = parentElement(elm).getOrThunk(() => getBody$1(owner(elm)));
       return outerGetter(elm) / innerGetter(relativeParent) * 100;
@@ -1848,6 +1854,9 @@
     const setHeight = (cell, amount) => {
       set$1(cell, 'height', amount + 'px');
     };
+    const removeHeight = cell => {
+      remove$5(cell, 'height');
+    };
     const getHeightValue = cell => getRuntime(cell) + 'px';
     const convert = (cell, number, getter, setter) => {
       const newSize = table(cell).map(table => {
@@ -1879,11 +1888,11 @@
       });
     };
     const getRawWidth$1 = element => getRaw$1(element, 'width');
-    const getRawHeight = element => getRaw$1(element, 'height');
+    const getRawHeight$1 = element => getRaw$1(element, 'height');
     const getPercentageWidth = cell => getPercentSize(cell, get$9, getInner);
     const getPixelWidth$1 = cell => isCol$2(cell) ? get$9(cell) : getRuntime$1(cell);
     const getHeight = cell => {
-      return get$7(cell, 'rowspan', getTotalHeight);
+      return isRow$2(cell) ? get$8(cell) : get$7(cell, 'rowspan', getTotalHeight);
     };
     const getGenericWidth = cell => {
       const width = getRawWidth$1(cell);
@@ -1897,6 +1906,7 @@
       set$1(cell, 'width', amount + unit);
     };
     const getPixelTableWidth = table => get$9(table) + 'px';
+    const getPixelTableHeight = table => get$8(table) + 'px';
     const getPercentTableWidth = table => getPercentSize(table, get$9, getInner) + '%';
     const isPercentSizing$1 = table => getRawWidth$1(table).exists(size => rPercentageBasedSizeRegex.test(size));
     const isPixelSizing$1 = table => getRawWidth$1(table).exists(size => rPixelBasedSizeRegex.test(size));
@@ -1908,7 +1918,7 @@
       return getRawWidth$1(cell).getOrThunk(() => getPixelWidth$1(cell) + 'px');
     };
     const getRawH = cell => {
-      return getRawHeight(cell).getOrThunk(() => getHeight(cell) + 'px');
+      return getRawHeight$1(cell).getOrThunk(() => getHeight(cell) + 'px');
     };
     const justCols = warehouse => map$1(Warehouse.justColumns(warehouse), column => Optional.from(column.element));
     const isValidColumn = cell => {
@@ -1955,20 +1965,19 @@
         return deduced.getOrThunk(tableSize.minCellWidth);
       });
     };
-    const getHeightFrom = (warehouse, table, direction, getHeight, fallback) => {
-      const rows$1 = rows(warehouse);
-      const backups = [Optional.some(direction.edge(table))].concat(map$1(direction.positions(rows$1, table), pos => pos.map(p => p.y)));
-      return map$1(rows$1, (cellOption, c) => {
-        return getDimension(cellOption, c, backups, not(hasRowspan), getHeight, fallback);
-      });
+    const getHeightFrom = (warehouse, table, getHeight, fallback) => {
+      const rowCells = rows(warehouse);
+      const rows$1 = map$1(warehouse.all, r => Optional.some(r.element));
+      const backups = [Optional.some(height.edge(table))].concat(map$1(height.positions(rowCells, table), pos => pos.map(p => p.y)));
+      return map$1(rows$1, (row, i) => getDimension(row, i, backups, always, getHeight, fallback));
     };
-    const getPixelHeights = (warehouse, table, direction) => {
-      return getHeightFrom(warehouse, table, direction, getHeight, deduced => {
+    const getPixelHeights = (warehouse, table) => {
+      return getHeightFrom(warehouse, table, getHeight, deduced => {
         return deduced.getOrThunk(minHeight);
       });
     };
-    const getRawHeights = (warehouse, table, direction) => {
-      return getHeightFrom(warehouse, table, direction, getRawH, getDeduced);
+    const getRawHeights = (warehouse, table) => {
+      return getHeightFrom(warehouse, table, getRawH, getDeduced);
     };
 
     const widthLookup = (table, getter) => () => {
@@ -2356,6 +2365,140 @@
     };
     const fromDom = nodes => map$1(nodes, SugarElement.fromDom);
 
+    const option = name => editor => editor.options.get(name);
+    const defaultWidth = '100%';
+    const getPixelForcedWidth = editor => {
+      var _a;
+      const dom = editor.dom;
+      const parentBlock = (_a = dom.getParent(editor.selection.getStart(), dom.isBlock)) !== null && _a !== void 0 ? _a : editor.getBody();
+      return getInner(SugarElement.fromDom(parentBlock)) + 'px';
+    };
+    const determineDefaultTableStyles = (editor, defaultStyles) => {
+      if (isTableResponsiveForced(editor) || !shouldStyleWithCss(editor)) {
+        return defaultStyles;
+      } else if (isTablePixelsForced(editor)) {
+        return {
+          ...defaultStyles,
+          width: getPixelForcedWidth(editor)
+        };
+      } else {
+        return {
+          ...defaultStyles,
+          width: defaultWidth
+        };
+      }
+    };
+    const determineDefaultTableAttributes = (editor, defaultAttributes) => {
+      if (isTableResponsiveForced(editor) || shouldStyleWithCss(editor)) {
+        return defaultAttributes;
+      } else if (isTablePixelsForced(editor)) {
+        return {
+          ...defaultAttributes,
+          width: getPixelForcedWidth(editor)
+        };
+      } else {
+        return {
+          ...defaultAttributes,
+          width: defaultWidth
+        };
+      }
+    };
+    const register = editor => {
+      const registerOption = editor.options.register;
+      registerOption('table_clone_elements', { processor: 'string[]' });
+      registerOption('table_use_colgroups', {
+        processor: 'boolean',
+        default: true
+      });
+      registerOption('table_header_type', {
+        processor: value => {
+          const valid = contains$2([
+            'section',
+            'cells',
+            'sectionCells',
+            'auto'
+          ], value);
+          return valid ? {
+            value,
+            valid
+          } : {
+            valid: false,
+            message: 'Must be one of: section, cells, sectionCells or auto.'
+          };
+        },
+        default: 'section'
+      });
+      registerOption('table_sizing_mode', {
+        processor: 'string',
+        default: 'auto'
+      });
+      registerOption('table_default_attributes', {
+        processor: 'object',
+        default: { border: '1' }
+      });
+      registerOption('table_default_styles', {
+        processor: 'object',
+        default: { 'border-collapse': 'collapse' }
+      });
+      registerOption('table_column_resizing', {
+        processor: value => {
+          const valid = contains$2([
+            'preservetable',
+            'resizetable'
+          ], value);
+          return valid ? {
+            value,
+            valid
+          } : {
+            valid: false,
+            message: 'Must be preservetable, or resizetable.'
+          };
+        },
+        default: 'preservetable'
+      });
+      registerOption('table_resize_bars', {
+        processor: 'boolean',
+        default: true
+      });
+      registerOption('table_style_by_css', {
+        processor: 'boolean',
+        default: true
+      });
+      registerOption('table_merge_content_on_paste', {
+        processor: 'boolean',
+        default: true
+      });
+    };
+    const getTableCloneElements = editor => {
+      return Optional.from(editor.options.get('table_clone_elements'));
+    };
+    const hasTableObjectResizing = editor => {
+      const objectResizing = editor.options.get('object_resizing');
+      return contains$2(objectResizing.split(','), 'table');
+    };
+    const getTableHeaderType = option('table_header_type');
+    const getTableColumnResizingBehaviour = option('table_column_resizing');
+    const isPreserveTableColumnResizing = editor => getTableColumnResizingBehaviour(editor) === 'preservetable';
+    const isResizeTableColumnResizing = editor => getTableColumnResizingBehaviour(editor) === 'resizetable';
+    const getTableSizingMode = option('table_sizing_mode');
+    const isTablePercentagesForced = editor => getTableSizingMode(editor) === 'relative';
+    const isTablePixelsForced = editor => getTableSizingMode(editor) === 'fixed';
+    const isTableResponsiveForced = editor => getTableSizingMode(editor) === 'responsive';
+    const hasTableResizeBars = option('table_resize_bars');
+    const shouldStyleWithCss = option('table_style_by_css');
+    const shouldMergeContentOnPaste = option('table_merge_content_on_paste');
+    const getTableDefaultAttributes = editor => {
+      const options = editor.options;
+      const defaultAttributes = options.get('table_default_attributes');
+      return options.isSet('table_default_attributes') ? defaultAttributes : determineDefaultTableAttributes(editor, defaultAttributes);
+    };
+    const getTableDefaultStyles = editor => {
+      const options = editor.options;
+      const defaultStyles = options.get('table_default_styles');
+      return options.isSet('table_default_styles') ? defaultStyles : determineDefaultTableStyles(editor, defaultStyles);
+    };
+    const tableUseColumnGroup = option('table_use_colgroups');
+
     const closest = target => closest$1(target, '[contenteditable]');
     const isEditable$1 = (element, assumeEditable = false) => {
       if (inBody(element)) {
@@ -2378,10 +2521,12 @@
     const getSelectionStart = editor => SugarElement.fromDom(editor.selection.getStart());
     const getPixelWidth = elm => elm.getBoundingClientRect().width;
     const getPixelHeight = elm => elm.getBoundingClientRect().height;
-    const getRawWidth = (editor, elm) => {
-      const raw = editor.dom.getStyle(elm, 'width') || editor.dom.getAttrib(elm, 'width');
+    const getRawValue = prop => (editor, elm) => {
+      const raw = editor.dom.getStyle(elm, prop) || editor.dom.getAttrib(elm, prop);
       return Optional.from(raw).filter(isNotEmpty);
     };
+    const getRawWidth = getRawValue('width');
+    const getRawHeight = getRawValue('height');
     const isPercentage$1 = value => /^(\d+(\.\d+)?)%$/.test(value);
     const isPixel = value => /^(\d+(\.\d+)?)px$/.test(value);
     const isInEditableContext$1 = cell => closest$2(cell, isTag('table')).exists(isEditable$1);
@@ -2904,7 +3049,7 @@
                 return name(content) !== 'meta';
               });
               const isTable = isTag('table');
-              if (elements.length === 1 && isTable(elements[0])) {
+              if (shouldMergeContentOnPaste(editor) && elements.length === 1 && isTable(elements[0])) {
                 e.preventDefault();
                 const doc = SugarElement.fromDom(editor.getDoc());
                 const generators = paste$1(doc);
@@ -4023,17 +4168,6 @@
         colspan: column.colspan
       }));
     };
-    const recalculateHeightForCells = (warehouse, heights) => {
-      const all = Warehouse.justCells(warehouse);
-      return map$1(all, cell => {
-        const height = total(cell.row, cell.row + cell.rowspan, heights);
-        return {
-          element: cell.element,
-          height,
-          rowspan: cell.rowspan
-        };
-      });
-    };
     const matchRowHeight = (warehouse, heights) => {
       return map$1(warehouse.all, (row, i) => {
         return {
@@ -4068,17 +4202,16 @@
       recalculateAndApply(warehouse, newWidths, tableSize);
       resizing.resizeTable(tableSize.adjustTableWidth, clampedStep, isLastColumn);
     };
-    const adjustHeight = (table, delta, index, direction) => {
+    const adjustHeight = (table, delta, index) => {
       const warehouse = Warehouse.fromTable(table);
-      const heights = getPixelHeights(warehouse, table, direction);
+      const heights = getPixelHeights(warehouse, table);
       const newHeights = map$1(heights, (dy, i) => index === i ? Math.max(delta + dy, minHeight()) : dy);
-      const newCellSizes = recalculateHeightForCells(warehouse, newHeights);
       const newRowSizes = matchRowHeight(warehouse, newHeights);
       each$2(newRowSizes, row => {
         setHeight(row.element, row.height);
       });
-      each$2(newCellSizes, cell => {
-        setHeight(cell.element, cell.height);
+      each$2(Warehouse.justCells(warehouse), cell => {
+        removeHeight(cell.element);
       });
       const total = sumUp(newHeights);
       setHeight(table, total);
@@ -4447,7 +4580,7 @@
     const opEraseRows = (grid, details, _comparator, _genWrappers) => {
       const rows = uniqueRows(details);
       const newGrid = deleteRowsAt(grid, rows[0].row, rows[rows.length - 1].row);
-      const maxRowIndex = newGrid.length > 0 ? newGrid.length - 1 : 0;
+      const maxRowIndex = Math.max(extractGridDetails(newGrid).rows.length - 1, 0);
       return bundle(newGrid, Math.min(details[0].row, maxRowIndex), details[0].column);
     };
     const opMergeCells = (grid, mergable, comparator, genWrappers) => {
@@ -4492,7 +4625,7 @@
       const context = rows[pasteDetails.cells[0].row];
       const gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
       const mergedGrid = insertCols(index, grid, gridB, pasteDetails.generators, comparator);
-      return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
+      return bundle(mergedGrid, pasteDetails.cells[0].row, index);
     };
     const opPasteRowsBefore = (grid, pasteDetails, comparator, _genWrappers) => {
       const rows = extractGridDetails(grid).rows;
@@ -4508,7 +4641,7 @@
       const context = rows[pasteDetails.cells[0].row];
       const gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
       const mergedGrid = insertRows(index, grid, gridB, pasteDetails.generators, comparator);
-      return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
+      return bundle(mergedGrid, index, pasteDetails.cells[0].column);
     };
     const opGetColumnsType = (table, target) => {
       const house = Warehouse.fromTable(table);
@@ -4639,135 +4772,6 @@
       style: true
     };
 
-    const option = name => editor => editor.options.get(name);
-    const defaultWidth = '100%';
-    const getPixelForcedWidth = editor => {
-      var _a;
-      const dom = editor.dom;
-      const parentBlock = (_a = dom.getParent(editor.selection.getStart(), dom.isBlock)) !== null && _a !== void 0 ? _a : editor.getBody();
-      return getInner(SugarElement.fromDom(parentBlock)) + 'px';
-    };
-    const determineDefaultTableStyles = (editor, defaultStyles) => {
-      if (isTableResponsiveForced(editor) || !shouldStyleWithCss(editor)) {
-        return defaultStyles;
-      } else if (isTablePixelsForced(editor)) {
-        return {
-          ...defaultStyles,
-          width: getPixelForcedWidth(editor)
-        };
-      } else {
-        return {
-          ...defaultStyles,
-          width: defaultWidth
-        };
-      }
-    };
-    const determineDefaultTableAttributes = (editor, defaultAttributes) => {
-      if (isTableResponsiveForced(editor) || shouldStyleWithCss(editor)) {
-        return defaultAttributes;
-      } else if (isTablePixelsForced(editor)) {
-        return {
-          ...defaultAttributes,
-          width: getPixelForcedWidth(editor)
-        };
-      } else {
-        return {
-          ...defaultAttributes,
-          width: defaultWidth
-        };
-      }
-    };
-    const register = editor => {
-      const registerOption = editor.options.register;
-      registerOption('table_clone_elements', { processor: 'string[]' });
-      registerOption('table_use_colgroups', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('table_header_type', {
-        processor: value => {
-          const valid = contains$2([
-            'section',
-            'cells',
-            'sectionCells',
-            'auto'
-          ], value);
-          return valid ? {
-            value,
-            valid
-          } : {
-            valid: false,
-            message: 'Must be one of: section, cells, sectionCells or auto.'
-          };
-        },
-        default: 'section'
-      });
-      registerOption('table_sizing_mode', {
-        processor: 'string',
-        default: 'auto'
-      });
-      registerOption('table_default_attributes', {
-        processor: 'object',
-        default: { border: '1' }
-      });
-      registerOption('table_default_styles', {
-        processor: 'object',
-        default: { 'border-collapse': 'collapse' }
-      });
-      registerOption('table_column_resizing', {
-        processor: value => {
-          const valid = contains$2([
-            'preservetable',
-            'resizetable'
-          ], value);
-          return valid ? {
-            value,
-            valid
-          } : {
-            valid: false,
-            message: 'Must be preservetable, or resizetable.'
-          };
-        },
-        default: 'preservetable'
-      });
-      registerOption('table_resize_bars', {
-        processor: 'boolean',
-        default: true
-      });
-      registerOption('table_style_by_css', {
-        processor: 'boolean',
-        default: true
-      });
-    };
-    const getTableCloneElements = editor => {
-      return Optional.from(editor.options.get('table_clone_elements'));
-    };
-    const hasTableObjectResizing = editor => {
-      const objectResizing = editor.options.get('object_resizing');
-      return contains$2(objectResizing.split(','), 'table');
-    };
-    const getTableHeaderType = option('table_header_type');
-    const getTableColumnResizingBehaviour = option('table_column_resizing');
-    const isPreserveTableColumnResizing = editor => getTableColumnResizingBehaviour(editor) === 'preservetable';
-    const isResizeTableColumnResizing = editor => getTableColumnResizingBehaviour(editor) === 'resizetable';
-    const getTableSizingMode = option('table_sizing_mode');
-    const isTablePercentagesForced = editor => getTableSizingMode(editor) === 'relative';
-    const isTablePixelsForced = editor => getTableSizingMode(editor) === 'fixed';
-    const isTableResponsiveForced = editor => getTableSizingMode(editor) === 'responsive';
-    const hasTableResizeBars = option('table_resize_bars');
-    const shouldStyleWithCss = option('table_style_by_css');
-    const getTableDefaultAttributes = editor => {
-      const options = editor.options;
-      const defaultAttributes = options.get('table_default_attributes');
-      return options.isSet('table_default_attributes') ? defaultAttributes : determineDefaultTableAttributes(editor, defaultAttributes);
-    };
-    const getTableDefaultStyles = editor => {
-      const options = editor.options;
-      const defaultStyles = options.get('table_default_styles');
-      return options.isSet('table_default_styles') ? defaultStyles : determineDefaultTableStyles(editor, defaultStyles);
-    };
-    const tableUseColumnGroup = option('table_use_colgroups');
-
     const get$5 = (editor, table) => {
       if (isTablePercentagesForced(editor)) {
         return TableSize.percentageSize(table);
@@ -5105,11 +5109,9 @@
         set$1(column.element, 'width', width + unit);
       });
     };
-    const redistributeToH = (newHeights, rows, cells, unit) => {
+    const redistributeToH = (newHeights, rows, cells) => {
       each$2(cells, cell => {
-        const heights = newHeights.slice(cell.row, cell.rowspan + cell.row);
-        const h = sum(heights, minHeight());
-        set$1(cell.element, 'height', h + unit);
+        remove$5(cell.element, 'height');
       });
       each$2(rows, (row, i) => {
         set$1(row.element, 'height', newHeights[i]);
@@ -5136,11 +5138,10 @@
         set$1(table, 'width', newWidth);
       });
       optHeight.each(newHeight => {
-        const hUnit = getUnit(newHeight);
         const totalHeight = get$8(table);
-        const oldHeights = getRawHeights(warehouse, table, height);
+        const oldHeights = getRawHeights(warehouse, table);
         const nuHeights = redistribute$1(oldHeights, totalHeight, newHeight);
-        redistributeToH(nuHeights, rows, cells, hUnit);
+        redistributeToH(nuHeights, rows, cells);
         set$1(table, 'height', newHeight);
       });
     };
@@ -5150,18 +5151,24 @@
 
     const cleanupLegacyAttributes = element => {
       remove$7(element, 'width');
+      remove$7(element, 'height');
     };
-    const convertToPercentSize = table => {
+    const convertToPercentSizeWidth = table => {
       const newWidth = getPercentTableWidth(table);
       redistribute(table, Optional.some(newWidth), Optional.none());
       cleanupLegacyAttributes(table);
     };
-    const convertToPixelSize = table => {
+    const convertToPixelSizeWidth = table => {
       const newWidth = getPixelTableWidth(table);
       redistribute(table, Optional.some(newWidth), Optional.none());
       cleanupLegacyAttributes(table);
     };
-    const convertToNoneSize = table => {
+    const convertToPixelSizeHeight = table => {
+      const newHeight = getPixelTableHeight(table);
+      redistribute(table, Optional.none(), Optional.some(newHeight));
+      cleanupLegacyAttributes(table);
+    };
+    const convertToNoneSizeWidth = table => {
       remove$5(table, 'width');
       const columns = columns$1(table);
       const rowElements = columns.length > 0 ? columns : cells$1(table);
@@ -5269,11 +5276,11 @@
       });
       return descendant(getBody(editor), 'table[data-mce-id="__mce"]').map(table => {
         if (isTablePixelsForced(editor)) {
-          convertToPixelSize(table);
+          convertToPixelSizeWidth(table);
         } else if (isTableResponsiveForced(editor)) {
-          convertToNoneSize(table);
+          convertToNoneSizeWidth(table);
         } else if (isTablePercentagesForced(editor) || isPercentage(defaultStyles.width)) {
-          convertToPercentSize(table);
+          convertToPercentSizeWidth(table);
         }
         removeDataStyle(table);
         remove$7(table, 'data-mce-id');
@@ -5350,11 +5357,11 @@
         if (!isForcedSizing) {
           table(cellOrCaption, isRoot).each(table => {
             if (sizing === 'relative' && !isPercentSizing(table)) {
-              convertToPercentSize(table);
+              convertToPercentSizeWidth(table);
             } else if (sizing === 'fixed' && !isPixelSizing(table)) {
-              convertToPixelSize(table);
+              convertToPixelSizeWidth(table);
             } else if (sizing === 'responsive' && !isNoneSizing(table)) {
-              convertToNoneSize(table);
+              convertToNoneSizeWidth(table);
             }
             removeDataStyle(table);
             fireTableModified(editor, table.dom, structureModified);
@@ -6309,7 +6316,6 @@
                 const isCellClosestContentEditable = is(closest(event.target), singleCell, eq$1);
                 if (isNonEditableCell && isCellClosestContentEditable) {
                   annotations.selectRange(container, boxes, singleCell, singleCell);
-                  bridge.selectContents(singleCell);
                 }
               } else if (boxes.length > 1) {
                 annotations.selectRange(container, boxes, cellSel.start, cellSel.finish);
@@ -6427,32 +6433,32 @@
     };
 
     const caretPositionFromPoint = (doc, x, y) => {
-      var _a, _b;
-      return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(pos => {
+      var _a;
+      return Optional.from((_a = doc.caretPositionFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y)).bind(pos => {
         if (pos.offsetNode === null) {
           return Optional.none();
         }
-        const r = doc.dom.createRange();
+        const r = doc.createRange();
         r.setStart(pos.offsetNode, pos.offset);
         r.collapse();
         return Optional.some(r);
       });
     };
     const caretRangeFromPoint = (doc, x, y) => {
-      var _a, _b;
-      return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y));
+      var _a;
+      return Optional.from((_a = doc.caretRangeFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y));
     };
-    const availableSearch = (() => {
-      if (document.caretPositionFromPoint) {
-        return caretPositionFromPoint;
-      } else if (document.caretRangeFromPoint) {
-        return caretRangeFromPoint;
+    const availableSearch = (doc, x, y) => {
+      if (doc.caretPositionFromPoint) {
+        return caretPositionFromPoint(doc, x, y);
+      } else if (doc.caretRangeFromPoint) {
+        return caretRangeFromPoint(doc, x, y);
       } else {
-        return Optional.none;
+        return Optional.none();
       }
-    })();
+    };
     const fromPoint = (win, x, y) => {
-      const doc = SugarElement.fromDom(win.document);
+      const doc = win.document;
       return availableSearch(doc, x, y).map(rng => SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));
     };
 
@@ -6990,11 +6996,12 @@
       const onSelection = (cells, start, finish) => {
         const tableOpt = table(start);
         tableOpt.each(table => {
+          const cellsDom = map$1(cells, cell => cell.dom);
           const cloneFormats = getTableCloneElements(editor);
           const generators = cellOperations(noop, SugarElement.fromDom(editor.getDoc()), cloneFormats);
           const selectedCells = getCellsFromSelection(editor);
-          const otherCells = getOtherCells(table, { selection: selectedCells }, generators);
-          fireTableSelectionChange(editor, cells, start, finish, otherCells);
+          const otherCellsDom = getOtherCells(table, { selection: selectedCells }, generators).map(otherCells => map(otherCells, cellArr => map$1(cellArr, cell => cell.dom))).getOrUndefined();
+          fireTableSelectionChange(editor, cellsDom, start.dom, finish.dom, otherCellsDom);
         });
       };
       const onClear = () => fireTableSelectionClear(editor);
@@ -7780,7 +7787,7 @@
         const table = event.table;
         events.trigger.beforeResize(table, 'row');
         const delta = hdirection.delta(event.delta, table);
-        adjustHeight(table, delta, event.row, hdirection);
+        adjustHeight(table, delta, event.row);
         events.trigger.afterResize(table, 'row');
       });
       manager.events.startAdjust.bind(_event => {
@@ -7863,7 +7870,7 @@
     const isTable = node => isNonNullable(node) && node.nodeName === 'TABLE';
     const barResizerPrefix = 'bar-';
     const isResizable = elm => get$b(elm, 'data-mce-resize') !== 'false';
-    const syncPixels = table => {
+    const syncTableCellPixels = table => {
       const warehouse = Warehouse.fromTable(table);
       if (!Warehouse.hasColumns(warehouse)) {
         each$2(cells$1(table), cell => {
@@ -7873,19 +7880,29 @@
         });
       }
     };
+    const isCornerResize = origin => startsWith(origin, 'corner-');
+    const getCornerLocation = origin => removeLeading(origin, 'corner-');
     const TableResizeHandler = editor => {
       const selectionRng = value();
       const tableResize = value();
       const resizeWire = value();
       let startW;
       let startRawW;
+      let startH;
+      let startRawH;
       const lazySizing = table => get$5(editor, table);
       const lazyResizingBehaviour = () => isPreserveTableColumnResizing(editor) ? preserveTable() : resizeTable();
       const getNumColumns = table => getGridSize(table).columns;
-      const afterCornerResize = (table, origin, width) => {
-        const isRightEdgeResize = endsWith(origin, 'e');
+      const getNumRows = table => getGridSize(table).rows;
+      const afterCornerResize = (table, origin, width, height) => {
+        const location = getCornerLocation(origin);
+        const isRightEdgeResize = endsWith(location, 'e');
+        const isNorthEdgeResize = startsWith(location, 'n');
         if (startRawW === '') {
-          convertToPercentSize(table);
+          convertToPercentSizeWidth(table);
+        }
+        if (startRawH === '') {
+          convertToPixelSizeHeight(table);
         }
         if (width !== startW && startRawW !== '') {
           set$1(table, 'width', startRawW);
@@ -7899,7 +7916,12 @@
           set$1(table, 'width', targetPercentW + '%');
         }
         if (isPixel(startRawW)) {
-          syncPixels(table);
+          syncTableCellPixels(table);
+        }
+        if (height !== startH && startRawH !== '') {
+          set$1(table, 'height', startRawH);
+          const idx = isNorthEdgeResize ? 0 : getNumRows(table) - 1;
+          adjustHeight(table, height - startH, idx);
         }
       };
       const destroy = () => {
@@ -7946,15 +7968,17 @@
             editor.dom.addClass(clone, 'mce-' + getTableColumnResizingBehaviour(editor) + '-columns');
           });
           if (!isPixelSizing(table) && isTablePixelsForced(editor)) {
-            convertToPixelSize(table);
+            convertToPixelSizeWidth(table);
           } else if (!isPercentSizing(table) && isTablePercentagesForced(editor)) {
-            convertToPercentSize(table);
+            convertToPercentSizeWidth(table);
           }
           if (isNoneSizing(table) && startsWith(e.origin, barResizerPrefix)) {
-            convertToPercentSize(table);
+            convertToPercentSizeWidth(table);
           }
           startW = e.width;
           startRawW = isTableResponsiveForced(editor) ? '' : getRawWidth(editor, targetElm).getOr('');
+          startH = e.height;
+          startRawH = getRawHeight(editor, targetElm).getOr('');
         }
       });
       editor.on('ObjectResized', e => {
@@ -7962,8 +7986,8 @@
         if (isTable(targetElm)) {
           const table = SugarElement.fromDom(targetElm);
           const origin = e.origin;
-          if (startsWith(origin, 'corner-')) {
-            afterCornerResize(table, origin, e.width);
+          if (isCornerResize(origin)) {
+            afterCornerResize(table, origin, e.width, e.height);
           }
           removeDataStyle(table);
           fireTableModified(editor, table.dom, styleModified);