WebSVN – Moodle – Diff – /lib/editor/tiny/js/tinymce/models/dom/model.js

 /**
- * TinyMCE version 6.8.3 (2024-02-08)
+ * TinyMCE version 7.7.1 (2025-03-05)
  */
 (function () {
       element,
       columns
     });
     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 = e => SugarElement.fromDom(e.dom.getRootNode());
-    const getRootNode = supported ? e => SugarElement.fromDom(e.dom.getRootNode()) : documentOrOwner;
+    const getContentContainer = dos => isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
     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) {
             const composedPath = event.composedPath();
       return r;
     };
     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 checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
+    };
     const contains = (str, substr, start = 0, end) => {
       const idx = str.indexOf(substr, start);
       if (idx !== -1) {
         return isUndefined(end) ? true : idx + substr.length <= end;
       };
     };
     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) => {
         });
         index += colspan;
       });
       return columnsGroup;
     };
-    const generate$1 = list => {
+    const generate$2 = list => {
       const access = {};
       const cells = [];
       const tableOpt = head(list).map(rowData => rowData.element).bind(table);
       const lockedColumns = tableOpt.bind(getLockedColumnsFromTable).getOr({});
       let maxRows = 0;
         colgroups
       };
     };
     const fromTable = table => {
       const list = fromTable$1(table);
-      return generate$1(list);
+      return generate$2(list);
     };
     const justCells = warehouse => bind$2(warehouse.all, w => w.cells);
     const justColumns = warehouse => values(warehouse.columns);
     const hasColumns = warehouse => keys(warehouse.columns).length > 0;
     const getColumnAt = (warehouse, columnIndex) => Optional.from(warehouse.columns[columnIndex]);
     const Warehouse = {
       fromTable,
-      generate: generate$1,
+      generate: generate$2,
       getAt,
       findItem,
       filterItems,
       justCells,
       justColumns,
     };
     const rPercentageBasedSizeRegex = /(\d+(\.\d+)?)%/;
     const rPixelBasedSizeRegex = /(\d+(\.\d+)?)px|em/;
+    const isCol$2 = isTag('col');
-    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;
     };
       set$1(cell, 'width', amount + '%');
     };
     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 => {
         const total = getter(table);
         return Math.floor(number / 100 * total);
       return getRaw$2(element, prop).orThunk(() => {
         return getOpt(element, prop).map(val => val + 'px');
       });
     };
     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);
       return width.bind(w => parse(w, [
         'fixed',
     };
     const setGenericWidth = (cell, amount, unit) => {
       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));
     const isNoneSizing$1 = table => getRawWidth$1(table).isNone();
     const percentageBasedSizeRegex = constant(rPercentageBasedSizeRegex);
     const isCol$1 = isTag('col');
     const getRawW = cell => {
       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 => {
       const browser = detect$2().browser;
       const supportsColWidths = browser.isChromium() || browser.isFirefox();
     const getPixelWidths = (warehouse, table, tableSize) => {
       return getWidthFrom(warehouse, table, getPixelWidth$1, deduced => {
         return deduced.getOrThunk(tableSize.minCellWidth);
       });
     };
-    const getHeightFrom = (warehouse, table, direction, getHeight, fallback) => {
+    const getHeightFrom = (warehouse, table, getHeight, fallback) => {
-      const rows$1 = rows(warehouse);
+      const rowCells = rows(warehouse);
+      const rows$1 = map$1(warehouse.all, r => Optional.some(r.element));
-      const backups = [Optional.some(direction.edge(table))].concat(map$1(direction.positions(rows$1, table), pos => pos.map(p => p.y)));
+      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, (cellOption, c) => {
-        return getDimension(cellOption, c, backups, not(hasRowspan), getHeight, fallback);
+      return map$1(rows$1, (row, i) => getDimension(row, i, backups, always, getHeight, fallback));
-      });
     };
-    const getPixelHeights = (warehouse, table, direction) => {
+    const getPixelHeights = (warehouse, table) => {
-      return getHeightFrom(warehouse, table, direction, getHeight, deduced => {
+      return getHeightFrom(warehouse, table, getHeight, deduced => {
         return deduced.getOrThunk(minHeight);
       });
     };
-    const getRawHeights = (warehouse, table, direction) => {
+    const getRawHeights = (warehouse, table) => {
-      return getHeightFrom(warehouse, table, direction, getRawH, getDeduced);
+      return getHeightFrom(warehouse, table, getRawH, getDeduced);
     };
     const widthLookup = (table, getter) => () => {
       if (inBody(table)) {
       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 fixedContainerSelector = option('fixed_toolbar_container');
+    const fixedToolbarContainerTarget = option('fixed_toolbar_container_target');
+    const fixedContainerTarget = editor => {
+      var _a;
+      if (!editor.inline) {
+        return Optional.none();
+      }
+      const selector = (_a = fixedContainerSelector(editor)) !== null && _a !== void 0 ? _a : '';
+      if (selector.length > 0) {
+        return descendant(body$1(), selector);
+      }
+      const element = fixedToolbarContainerTarget(editor);
+      if (isNonNullable(element)) {
+        return Optional.some(SugarElement.fromDom(element));
+      }
+      return Optional.none();
+    };
+    const useFixedContainer = editor => editor.inline && fixedContainerTarget(editor).isSome();
+    const getUiMode = option('ui_mode');
+    const isSplitUiMode = editor => !useFixedContainer(editor) && getUiMode(editor) === 'split';
     const closest = target => closest$1(target, '[contenteditable]');
     const isEditable$1 = (element, assumeEditable = false) => {
       if (inBody(element)) {
       each$2(rows$1(table), removeStyleAttribute);
     };
     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 getRawValue = prop => (editor, elm) => {
-      const raw = editor.dom.getStyle(elm, 'width') || editor.dom.getAttrib(elm, 'width');
+      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);
         removeDataStyle(replica);
         return [replica];
       });
     };
     const serializeElements = (editor, elements) => map$1(elements, elm => editor.selection.serializer.serialize(elm.dom, {})).join('');
-    const getTextContent = elements => map$1(elements, element => element.dom.innerText).join('');
+    const getTextContent = (editor, replicaElements) => {
+      const doc = editor.getDoc();
+      const dos = getRootNode(SugarElement.fromDom(editor.getBody()));
+      const offscreenDiv = SugarElement.fromTag('div', doc);
+      set$2(offscreenDiv, 'data-mce-bogus', 'all');
+      setAll(offscreenDiv, {
+        position: 'fixed',
+        left: '-9999999px',
+        top: '0',
+        overflow: 'hidden',
+        opacity: '0'
+      });
+      const root = getContentContainer(dos);
+      append(offscreenDiv, replicaElements);
+      append$1(root, offscreenDiv);
+      const textContent = offscreenDiv.dom.innerText;
+      remove$6(offscreenDiv);
+      return textContent;
+    };
     const registerEvents = (editor, actions) => {
       editor.on('BeforeGetContent', e => {
         const multiCellContext = cells => {
           e.preventDefault();
-          extractSelected(cells).each(elements => {
+          extractSelected(cells).each(replicaElements => {
-            e.content = e.format === 'text' ? getTextContent(elements) : serializeElements(editor, elements);
+            const content = e.format === 'text' ? getTextContent(editor, replicaElements) : serializeElements(editor, replicaElements);
+            e.content = content;
           });
         };
         if (e.selection === true) {
           const cells = getCellsFromFakeSelection(editor);
           if (cells.length >= 1) {
       const rows = extractGridDetails(grid).rows;
       const targetCells = map$1(details, detail => getCell(rows[detail.row], detail.column));
       return replaceIn(grid, targetCells, comparator, substitution, replace, Optional.none, always);
     };
-    const generate = cases => {
+    const generate$1 = cases => {
       if (!isArray(cases)) {
         throw new Error('cases must be an array');
+      }
       if (cases.length === 0) {
           };
         };
       });
       return adt;
     };
-    const Adt = { generate };
+    const Adt = { generate: generate$1 };
     const adt$6 = Adt.generate([
       { none: [] },
       { only: ['index'] },
         element: column.element,
         width: widths[index],
         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 {
           element: row.element,
           height: heights[i]
       const deltas = determine(widths, index, clampedStep, tableSize, resizing);
       const newWidths = map$1(deltas, (dx, i) => dx + widths[i]);
       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 => {
+      each$2(Warehouse.justCells(warehouse), cell => {
-        setHeight(cell.element, cell.height);
+        removeHeight(cell.element);
       });
       const total = sumUp(newHeights);
       setHeight(table, total);
     };
     const adjustAndRedistributeWidths$1 = (_table, list, details, tableSize, resizeBehaviour) => {
       return bundle(newGrid, columns[0].row, Math.min(columns[0].column, maxColIndex));
     };
     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) => {
       const cells = mergable.cells;
       merge(cells);
       const rows = extractGridDetails(grid).rows;
       const index = pasteDetails.cells[pasteDetails.cells.length - 1].column + pasteDetails.cells[pasteDetails.cells.length - 1].colspan;
       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;
       const index = pasteDetails.cells[0].row;
       const context = rows[index];
       const rows = extractGridDetails(grid).rows;
       const index = pasteDetails.cells[pasteDetails.cells.length - 1].row + pasteDetails.cells[pasteDetails.cells.length - 1].rowspan;
       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);
       const details = onCells(house, target);
       return details.bind(selectedCells => {
     const insertColumnsAfter = run(opInsertColumnsAfter, insertColumnsExtractor(false), adjustAndRedistributeWidths, noop, Generators.modification);
     const eraseColumns = run(opEraseColumns, eraseColumnsExtractor, adjustAndRedistributeWidths, prune, Generators.modification);
     const eraseRows = run(opEraseRows, onCells, noop, prune, Generators.modification);
     const makeColumnsHeader = run(opMakeColumnsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
     const unmakeColumnsHeader = run(opUnmakeColumnsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
-    const makeRowsHeader = run(opMakeRowsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
+    const makeRowsHeader = run(opMakeRowsHeader, onCells, noop, noop, headerCellGenerator);
-    const makeRowsBody = run(opMakeRowsBody, onUnlockedCells, noop, noop, bodyCellGenerator);
+    const makeRowsBody = run(opMakeRowsBody, onCells, noop, noop, bodyCellGenerator);
-    const makeRowsFooter = run(opMakeRowsFooter, onUnlockedCells, noop, noop, bodyCellGenerator);
+    const makeRowsFooter = run(opMakeRowsFooter, onCells, noop, noop, bodyCellGenerator);
     const makeCellsHeader = run(opMakeCellsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
     const unmakeCellsHeader = run(opUnmakeCellsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
     const mergeCells = run(opMergeCells, onUnlockedMergable, resize, noop, Generators.merging);
     const unmergeCells = run(opUnmergeCells, onUnlockedUnmergable, resize, noop, Generators.merging);
     const pasteCells = run(opPasteCells, onPaste, resize, noop, Generators.modification);
       each$2(columns, (column, index) => {
         const width = sum([newWidths[index]], minWidth());
         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]);
       });
     };
           redistributeToW(nuWidths, cells, widthUnit);
+        }
         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);
       });
     };
     const isPercentSizing = isPercentSizing$1;
     const isPixelSizing = isPixelSizing$1;
     const isNoneSizing = isNoneSizing$1;
     const cleanupLegacyAttributes = element => {
+      remove$7(element, 'width');
-      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 convertToPixelSizeHeight = table => {
+      const newHeight = getPixelTableHeight(table);
+      redistribute(table, Optional.none(), Optional.some(newHeight));
+      cleanupLegacyAttributes(table);
     };
-    const convertToNoneSize = table => {
+    const convertToNoneSizeWidth = table => {
       remove$5(table, 'width');
       const columns = columns$1(table);
       const rowElements = columns.length > 0 ? columns : cells$1(table);
       each$2(rowElements, cell => {
         editor.insertContent(html);
         editor.addVisual();
       });
       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');
         fireEvents(editor, table);
         selectFirstCellInTable(editor, table);
       const setSizingMode = sizing => getSelectionStartCellOrCaption(editor).each(cellOrCaption => {
         const isForcedSizing = isTableResponsiveForced(editor) || isTablePixelsForced(editor) || isTablePercentagesForced(editor);
         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);
           });
+        }
                 const singleCell = boxes[0];
                 const isNonEditableCell = getRaw(singleCell) === 'false';
                 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);
                 bridge.selectContents(finish);
+              }
       getWin,
       range
     };
     const caretPositionFromPoint = (doc, x, y) => {
-      var _a, _b;
+      var _a;
-      return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(pos => {
+      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;
+      var _a;
-      return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y));
+      return Optional.from((_a = doc.caretRangeFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y));
     };
-    const availableSearch = (() => {
+    const availableSearch = (doc, x, y) => {
-      if (document.caretPositionFromPoint) {
+      if (doc.caretPositionFromPoint) {
-        return caretPositionFromPoint;
+        return caretPositionFromPoint(doc, x, y);
-      } else if (document.caretRangeFromPoint) {
+      } else if (doc.caretRangeFromPoint) {
-        return 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));
     };
           if (selection.setBaseAndExtent) {
             selection.setBaseAndExtent(start.dom, soffset, finish.dom, foffset);
           } else if (selection.extend) {
             try {
               setLegacyRtlRange(win, selection, start, soffset, finish, foffset);
-            } catch (e) {
+            } catch (_a) {
               doSetRange(win, finish, foffset, start, soffset);
+            }
           } else {
             doSetRange(win, finish, foffset, start, soffset);
+          }
     const TableCellSelectionHandler = (editor, resizeHandler) => {
       const cellSelection = Selections(() => SugarElement.fromDom(editor.getBody()), () => getSelectionCell(getSelectionStart(editor), getIsRoot(editor)), ephemera.selectedSelector);
       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);
+          const otherCellsDom = getOtherCells(table, { selection: selectedCells }, generators).map(otherCells => map(otherCells, cellArr => map$1(cellArr, cell => cell.dom))).getOrUndefined();
-          fireTableSelectionChange(editor, cells, start, finish, otherCells);
+          fireTableSelectionChange(editor, cellsDom, start.dom, finish.dom, otherCellsDom);
         });
       };
       const onClear = () => fireTableSelectionClear(editor);
       const annotations = SelectionAnnotation.byAttr(ephemera, onSelection, onClear);
       editor.on('init', _e => {
         events.trigger.startAdjust();
         mutation.assign(target);
         set$2(target, 'data-initial-' + dir, getCssValue(target, dir));
         add(target, resizeBarDragging);
         set$1(target, 'opacity', '0.2');
-        resizing.go(wire.parent());
+        resizing.go(wire.dragContainer());
       };
       const mousedown = bind(wire.parent(), 'mousedown', event => {
         if (isRowBar(event.target)) {
           handler(event.target, 'top');
+        }
       });
       manager.events.adjustHeight.bind(event => {
         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 => {
         events.trigger.startDrag();
       });
         events: events.registry
       };
     };
     const TableResize = { create };
+    const random = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
+    let unique = 0;
+    const generate = prefix => {
+      const date = new Date();
+      const time = date.getTime();
+      const random$1 = Math.floor(random() * 1000000000);
+      unique++;
+      return prefix + '_' + random$1 + unique + String(time);
+    };
     const only = (element, isResizable) => {
       const parent = isDocument(element) ? documentElement(element) : element;
       return {
         parent: constant(parent),
+        view: constant(element),
-        view: constant(element),
+        dragContainer: constant(parent),
         origin: constant(SugarPosition(0, 0)),
         isResizable
       };
     };
     const detached = (editable, chrome, isResizable) => {
       const origin = () => absolute(chrome);
       return {
         parent: constant(chrome),
+        view: constant(editable),
-        view: constant(editable),
+        dragContainer: constant(chrome),
         origin,
         isResizable
       };
     };
     const body = (editable, chrome, isResizable) => {
       return {
         parent: constant(chrome),
+        view: constant(editable),
-        view: constant(editable),
+        dragContainer: constant(chrome),
         origin: constant(SugarPosition(0, 0)),
         isResizable
       };
+    };
+    const scrollable = (editable, chrome, dragContainer, isResizable) => {
+      return {
+        parent: constant(chrome),
+        view: constant(editable),
+        dragContainer: constant(dragContainer),
+        origin: () => absolute(chrome),
+        isResizable
+      };
     };
     const ResizeWire = {
       only,
       detached,
+      body,
-      body
+      scrollable
     };
     const createContainer = position => {
+      const id = generate('resizer-container');
-    const createContainer = () => {
+      const container = SugarElement.fromTag('div');
-      const container = SugarElement.fromTag('div');
+      set$2(container, 'id', id);
       setAll(container, {
-        position: 'static',
+        position,
         height: '0',
         width: '0',
         padding: '0',
         margin: '0',
-        border: '0'
-      });
+        border: '0'
-      append$1(body$1(), container);
+      });
+      return container;
+    };
+    const getInlineResizeWire = (editor, isResizable) => {
+      const isSplitUiMode$1 = isSplitUiMode(editor);
+      const editorBody = SugarElement.fromDom(editor.getBody());
+      const container = createContainer(isSplitUiMode$1 ? 'relative' : 'static');
+      const body = body$1();
+      if (isSplitUiMode$1) {
+        after$5(editorBody, container);
+        return ResizeWire.scrollable(editorBody, container, body, isResizable);
+      }
+      append$1(body, container);
-      return container;
+      return ResizeWire.body(editorBody, container, isResizable);
+    };
+    const get = (editor, isResizable) => {
+      if (editor.inline) {
-    };
+        return getInlineResizeWire(editor, isResizable);
     const get = (editor, isResizable) => {
-      return editor.inline ? ResizeWire.body(SugarElement.fromDom(editor.getBody()), createContainer(), isResizable) : ResizeWire.only(SugarElement.fromDom(editor.getDoc()), isResizable);
+      return ResizeWire.only(SugarElement.fromDom(editor.getDoc()), isResizable);
     };
     const remove = (editor, wire) => {
       if (editor.inline) {
         remove$6(wire.parent());
+      }
     };
     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 => {
           const computedWidth = get$a(cell, 'width');
           set$1(cell, 'width', computedWidth);
           remove$7(cell, 'width');
+        });
+      }
-        });
+    };
     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;
-      const resizeWire = value();
+      let startRawW;
-      let startW;
+      let startH;
-      let startRawW;
+      let startRawH;
+      const lazySizing = table => get$5(editor, table);
-      const lazySizing = table => get$5(editor, table);
+      const lazyResizingBehaviour = () => isPreserveTableColumnResizing(editor) ? preserveTable() : resizeTable();
+      const getNumColumns = table => getGridSize(table).columns;
-      const lazyResizingBehaviour = () => isPreserveTableColumnResizing(editor) ? preserveTable() : resizeTable();
+      const getNumRows = table => getGridSize(table).rows;
+      const afterCornerResize = (table, origin, width, height) => {
-      const getNumColumns = table => getGridSize(table).columns;
+        const location = getCornerLocation(origin);
-      const afterCornerResize = (table, origin, width) => {
+        const isRightEdgeResize = endsWith(location, 'e');
+        const isNorthEdgeResize = startsWith(location, 'n');
+        if (startRawW === '') {
+          convertToPercentSizeWidth(table);
         const isRightEdgeResize = endsWith(origin, 'e');
-        if (startRawW === '') {
+        if (startRawH === '') {
-          convertToPercentSize(table);
+          convertToPixelSizeHeight(table);
+        }
         if (width !== startW && startRawW !== '') {
           const percentW = parseFloat(startRawW.replace('%', ''));
           const targetPercentW = width * percentW / startW;
           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 = () => {
         tableResize.on(sz => {
           sz.destroy();
         const rawWire = get(editor, isResizable);
         resizeWire.set(rawWire);
         if (hasTableObjectResizing(editor) && hasTableResizeBars(editor)) {
           const resizing = lazyResizingBehaviour();
           const sz = TableResize.create(rawWire, resizing, lazySizing);
+          if (!editor.mode.isReadOnly()) {
-          sz.on();
+            sz.on();
+          }
           sz.events.startDrag.bind(_event => {
             selectionRng.set(editor.selection.getRng());
           });
           sz.events.beforeResize.bind(event => {
             const rawTable = event.table.dom;
           tableResize.set(sz);
+        }
       });
       editor.on('ObjectResizeStart', e => {
         const targetElm = e.target;
-        if (isTable(targetElm)) {
+        if (isTable(targetElm) && !editor.mode.isReadOnly()) {
           const table = SugarElement.fromDom(targetElm);
           each$2(editor.dom.select('.mce-clonedresizable'), clone => {
             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 => {
         const targetElm = e.target;
         if (isTable(targetElm)) {
           const table = SugarElement.fromDom(targetElm);
           const origin = e.origin;
-          if (startsWith(origin, 'corner-')) {
+          if (isCornerResize(origin)) {
-            afterCornerResize(table, origin, e.width);
+            afterCornerResize(table, origin, e.width, e.height);
+          }
           removeDataStyle(table);
           fireTableModified(editor, table.dom, styleModified);
+        }
       });
-      editor.on('SwitchMode', () => {
+      const showResizeBars = () => {
         tableResize.on(resize => {
-          if (editor.mode.isReadOnly()) {
-            resize.hideBars();
+          resize.on();
-          } else {
-            resize.showBars();
+          resize.showBars();
-          }
         });
-      });
+      };
-      editor.on('dragstart dragend', e => {
+      const hideResizeBars = () => {
         tableResize.on(resize => {
-          if (e.type === 'dragstart') {
-            resize.hideBars();
-            resize.off();
+          resize.off();
-          } else {
-            resize.on();
-            resize.showBars();
+          resize.hideBars();
-          }
         });
+      };
+      editor.on('DisabledStateChange', e => {
+        e.state ? hideResizeBars() : showResizeBars();
+      });
+      editor.on('SwitchMode', () => {
+        editor.mode.isReadOnly() ? hideResizeBars() : showResizeBars();
+      });
+      editor.on('dragstart dragend', e => {
+        e.type === 'dragstart' ? hideResizeBars() : showResizeBars();
       });
       editor.on('remove', () => {
         destroy();
       });
       const refresh = table => {

Proyectos de Subversion Moodle

(root)/lib/editor/tiny/js/tinymce/models/dom/model.js – Rev 1 → 1441