handsontable 17.1.0 → 18.0.0-rc2

package/helpers/dom/element.js

@@ -12,6 +12,9 @@ _export(exports, {
     get HTML_CHARACTERS () {
         return HTML_CHARACTERS;
     },
+    get SANITIZER_WARN_KEY () {
+        return SANITIZER_WARN_KEY;
+    },
     get addClass () {
         return addClass;
     },
@@ -30,6 +33,9 @@ _export(exports, {
     get empty () {
         return empty;
     },
+    get eventTargetEl () {
+        return eventTargetEl;
+    },
     get fastInnerHTML () {
         return fastInnerHTML;
     },
@@ -42,6 +48,9 @@ _export(exports, {
     get getCaretPosition () {
         return getCaretPosition;
     },
+    get getChildEl () {
+        return getChildEl;
+    },
     get getCssTransform () {
         return getCssTransform;
     },
@@ -129,6 +138,12 @@ _export(exports, {
     get isHTMLElement () {
         return isHTMLElement;
     },
+    get isHTMLInputElement () {
+        return isHTMLInputElement;
+    },
+    get isHTMLTableCellElement () {
+        return isHTMLTableCellElement;
+    },
     get isInput () {
         return isInput;
     },
@@ -138,6 +153,9 @@ _export(exports, {
     get isOutsideInput () {
         return isOutsideInput;
     },
+    get isShadowRoot () {
+        return isShadowRoot;
+    },
     get isVisible () {
         return isVisible;
     },
@@ -196,21 +214,19 @@ _export(exports, {
         return setOverlayPosition;
     }
 });
-const _string = require("../string");
 const _a11y = require("../a11y");
 const _browser = require("../browser");
-const _console = require("../console");
-const _errors = require("../../helpers/errors");
+const _console = require("../../helpers/console");
 function getParent(element, level = 0) {
     let iteration = -1;
     let parent = null;
     let elementToCheck = element;
     while(elementToCheck !== null){
         if (iteration === level) {
-            parent = elementToCheck;
+            parent = isHTMLElement(elementToCheck) ? elementToCheck : null;
             break;
         }
-        if (elementToCheck.host && elementToCheck.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+        if (isShadowRoot(elementToCheck)) {
             elementToCheck = elementToCheck.host;
         } else {
             iteration += 1;
@@ -223,11 +239,17 @@ function isInternalElement(element, thisHotContainer) {
     const closestHandsontableContainer = element.closest('.handsontable');
     return !!closestHandsontableContainer && (closestHandsontableContainer.parentNode === thisHotContainer || closestHandsontableContainer === thisHotContainer);
 }
+function eventTargetEl(event) {
+    return event.target;
+}
 function getFrameElement(frame) {
-    return Object.getPrototypeOf(frame.parent) && frame.frameElement;
+    const { frameElement } = frame;
+    // `frame.parent` can be null when the iframe has been detached from the DOM. Guard before
+    // passing to Object.getPrototypeOf(), which throws on null/undefined.
+    return frame.parent && Object.getPrototypeOf(frame.parent) && frameElement instanceof HTMLIFrameElement ? frameElement : null;
 }
 function getParentWindow(frame) {
-    return getFrameElement(frame) && frame.parent;
+    return getFrameElement(frame) ? frame.parent : null;
 }
 function hasAccessToParentWindow(frame) {
     return !!Object.getPrototypeOf(frame.parent);
@@ -237,12 +259,11 @@ function closest(element, nodes = [], until) {
     let elementToCheck = element;
     while(elementToCheck !== null && elementToCheck !== undefined && elementToCheck !== until){
         const { nodeType, nodeName } = elementToCheck;
-        if (nodeType === ELEMENT_NODE && (nodes.includes(nodeName) || nodes.includes(elementToCheck))) {
+        if (nodeType === ELEMENT_NODE && isHTMLElement(elementToCheck) && (nodes.includes(nodeName) || nodes.includes(elementToCheck))) {
             return elementToCheck;
         }
-        const { host } = elementToCheck;
-        if (host && nodeType === DOCUMENT_FRAGMENT_NODE) {
-            elementToCheck = host;
+        if (isShadowRoot(elementToCheck)) {
+            elementToCheck = elementToCheck.host;
         } else {
             elementToCheck = elementToCheck.parentNode;
         }
@@ -251,17 +272,18 @@ function closest(element, nodes = [], until) {
 }
 function closestDown(element, nodes, until) {
     const matched = [];
-    let elementToCheck = element;
+    let elementToCheck = isHTMLElement(element) ? element : null;
     while(elementToCheck){
         elementToCheck = closest(elementToCheck, nodes, until);
         if (!elementToCheck || until && !until.contains(elementToCheck)) {
             break;
         }
         matched.push(elementToCheck);
-        if (elementToCheck.host && elementToCheck.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-            elementToCheck = elementToCheck.host;
+        if (isShadowRoot(elementToCheck)) {
+            const { host } = elementToCheck;
+            elementToCheck = isHTMLElement(host) ? host : null;
         } else {
-            elementToCheck = elementToCheck.parentNode;
+            elementToCheck = elementToCheck.parentElement;
         }
     }
     const length = matched.length;
@@ -292,10 +314,10 @@ function isChildOf(child, parent) {
     let node = child.parentNode;
     let queriedParents = [];
     if (typeof parent === 'string') {
-        if (child.defaultView) {
-            queriedParents = Array.prototype.slice.call(child.querySelectorAll(parent), 0);
+        if (child instanceof Document) {
+            queriedParents = Array.from(child.querySelectorAll(parent));
         } else {
-            queriedParents = Array.prototype.slice.call(child.ownerDocument.querySelectorAll(parent), 0);
+            queriedParents = Array.from(child.ownerDocument.querySelectorAll(parent));
         }
     } else {
         queriedParents.push(parent);
@@ -319,8 +341,8 @@ function index(element) {
     return i;
 }
 function overlayContainsElement(overlayType, element, root) {
-    const overlayElement = root.parentElement.querySelector(`.ht_clone_${overlayType}`);
-    return overlayElement ? overlayElement.contains(element) : null;
+    const overlayElement = root.parentElement?.querySelector(`.ht_clone_${overlayType}`);
+    return overlayElement ? overlayElement.contains(element) : false;
 }
 function isBottomMostColumnHeader(TH) {
     if (!TH || !TH.classList || !TH.parentNode || !TH.parentNode.parentNode) {
@@ -330,9 +352,9 @@ function isBottomMostColumnHeader(TH) {
         return false;
     }
     const headerRow = TH.parentNode;
-    const headerRows = Array.from(headerRow.parentNode.childNodes);
-    const headerLevel = headerRows.indexOf(headerRow);
-    const rowspan = Number.parseInt(TH.getAttribute('rowspan'), 10) || 1;
+    const headerRows = Array.from(headerRow?.parentNode?.childNodes ?? []);
+    const headerLevel = headerRow ? headerRows.indexOf(headerRow) : -1;
+    const rowspan = Number.parseInt(TH.getAttribute('rowspan') ?? '', 10) || 1;
     return headerLevel + rowspan >= headerRows.length;
 }
 /**
@@ -413,13 +435,13 @@ function setAttribute(domElement, attributes = [], attributeValue) {
         attributes = [
             [
                 attributes,
-                attributeValue
+                attributeValue ?? ''
             ]
         ];
     }
     attributes.forEach((attributeInfo)=>{
         if (Array.isArray(attributeInfo) && attributeInfo[0] !== '') {
-            domElement.setAttribute(...attributeInfo);
+            domElement.setAttribute(attributeInfo[0], String(attributeInfo[1]));
         }
     });
 }
@@ -447,7 +469,7 @@ function removeAttribute(domElement, attributesToRemove = []) {
 }
 function removeTextNodes(element) {
     if (element.nodeType === 3) {
-        element.parentNode.removeChild(element); // bye text nodes!
+        element.parentNode?.removeChild(element); // bye text nodes!
     } else if ([
         'TABLE',
         'THEAD',
@@ -467,15 +489,27 @@ function empty(element) {
         element.removeChild(child);
     }
 }
-const HTML_CHARACTERS = /(<(.*)>|&(.*);)/;
-let dompurifyDeprecatedMessageShown = false;
-function fastInnerHTML(element, content, sanitizer = _string.sanitize) {
+const HTML_CHARACTERS = /(<([^>]*)>|&([^;]*);)/;
+const SANITIZER_WARN_KEY = 'sanitizer';
+/**
+ * Default scope used when a caller writes raw HTML without supplying a per-instance
+ * scope. Keeps the warning to once per process for such callers.
+ */ const defaultSanitizerWarnScope = {};
+function fastInnerHTML(element, content, sanitizer = true, context = 'innerHTML', scope = defaultSanitizerWarnScope) {
     if (HTML_CHARACTERS.test(content)) {
-        if (!dompurifyDeprecatedMessageShown && sanitizer === _string.sanitize) {
-            dompurifyDeprecatedMessageShown = true;
-            (0, _console.deprecatedWarn)('The HTML sanitization using DOMPurify library is deprecated and will be removed in the next major release. ' + 'Use the `sanitizer` option instead.\n\n' + 'Migration guide: https://handsontable.com/docs/migration-from-16.2-to-17.0/\n' + '`sanitizer` documentation: https://handsontable.com/docs/api/options/#sanitizer');
+        let sanitized;
+        if (typeof sanitizer === 'function') {
+            sanitized = sanitizer(content, context);
+        } else {
+            // `false` means the caller renders raw HTML deliberately (for example, the `html` cell type).
+            // Any other non-function value (the default `true`) is an implicit raw write, so nudge once
+            // toward configuring a sanitizer to prevent XSS.
+            if (sanitizer !== false) {
+                (0, _console.warnOnce)(scope, SANITIZER_WARN_KEY, `HTML content is being written to the DOM ("${context}") without a sanitizer. ` + 'Configure the "sanitizer" option to prevent XSS vulnerabilities.');
+            }
+            sanitized = content;
         }
-        element.innerHTML = typeof sanitizer === 'function' ? sanitizer(content, 'innerHTML') : content;
+        element.innerHTML = sanitized;
     } else {
         fastInnerText(element, content);
     }
@@ -492,26 +526,33 @@ function fastInnerText(element, content) {
     }
 }
 function isVisible(element) {
+    // Fast path: use the native checkVisibility() API (Chrome 105+, Firefox 106+, Safari 17.4+).
+    // With no options it checks whether the element has an associated box — returning false for
+    // display:none and display:contents — and whether any ancestor sets content-visibility:hidden.
+    // This is stricter than the legacy walk below (which only catches display:none), but the
+    // extra cases are also semantically invisible, so the stricter result is correct.
+    // The benefit over the legacy walk: O(1) browser-native time instead of O(DOM depth) with
+    // per-node getComputedStyle() calls that force full-document layout recalculation.
+    if (typeof element.checkVisibility === 'function') {
+        return element.checkVisibility();
+    }
+    // Legacy fallback: manual ancestor walk for browsers that do not support checkVisibility().
     const documentElement = element.ownerDocument.documentElement;
     const windowElement = element.ownerDocument.defaultView;
     let next = element;
     while(next !== documentElement){
         if (next === null) {
             return false;
-        } else if (next.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-            if (next.host) {
-                // see: http://w3c.github.io/webcomponents/spec/shadow/#encapsulation
-                // according to spec, should be if (next.ownerDocument !== window.document), but that doesn't work yet
-                if (next.host.impl) {
-                    return isVisible(next.host.impl);
-                } else if (next.host) {
-                    return isVisible(next.host);
-                }
-                (0, _errors.throwWithCause)('Lost in Web Components world');
+        } else if (isShadowRoot(next)) {
+            const host = next.host;
+            if (host.impl) {
+                return isVisible(host.impl);
             } else {
-                return false; // this is a node detached from document in IE8
+                return isVisible(host);
             }
-        } else if (windowElement.getComputedStyle(next).display === 'none') {
+        } else if (next.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+            return false; // this is a node detached from document in IE8
+        } else if (next.nodeType === Node.ELEMENT_NODE && isHTMLElement(next) && windowElement?.getComputedStyle(next).display === 'none') {
             return false;
         }
         next = next.parentNode;
@@ -522,12 +563,12 @@ function hasZeroHeight(element) {
     const rootDocument = element.ownerDocument;
     const rootWindow = rootDocument.defaultView;
     let currentElement = element;
-    while(currentElement.parentNode){
+    while(currentElement.parentElement){
         if (currentElement.style.height === '0px' || currentElement.style.height === '0') {
-            const computedOverflow = rootWindow.getComputedStyle(currentElement).getPropertyValue('overflow');
+            const computedOverflow = rootWindow?.getComputedStyle(currentElement).getPropertyValue('overflow');
             return computedOverflow === 'hidden' || computedOverflow === 'clip';
         }
-        currentElement = currentElement.parentNode;
+        currentElement = currentElement.parentElement;
     }
     return false;
 }
@@ -542,7 +583,7 @@ function offset(element) {
     offsetLeft = elementToCheck.offsetLeft;
     offsetTop = elementToCheck.offsetTop;
     lastElem = elementToCheck;
-    /* eslint-disable no-cond-assign */ while(elementToCheck = elementToCheck.offsetParent){
+    /* eslint-disable no-cond-assign */ while(elementToCheck = isHTMLElement(elementToCheck.offsetParent) ? elementToCheck.offsetParent : null){
         // from my observation, document.body always has scrollLeft/scrollTop == 0
         if (elementToCheck === rootDocument.body) {
             break;
@@ -559,8 +600,8 @@ function offset(element) {
     // slow - http://jsperf.com/offset-vs-getboundingclientrect/6
     if (lastElem && lastElem.style.position === 'fixed') {
         // if(lastElem !== document.body) { //faster but does gives false positive in Firefox
-        offsetLeft += rootWindow.pageXOffset || documentElement.scrollLeft;
-        offsetTop += rootWindow.pageYOffset || documentElement.scrollTop;
+        offsetLeft += (rootWindow?.pageXOffset ?? 0) || documentElement.scrollLeft;
+        offsetTop += (rootWindow?.pageYOffset ?? 0) || documentElement.scrollTop;
     }
     return {
         left: offsetLeft,
@@ -574,29 +615,25 @@ function getWindowScrollLeft(rootWindow = window) {
     return rootWindow.scrollX;
 }
 function getScrollTop(element, rootWindow = window) {
-    if (element === rootWindow) {
+    if (element instanceof Window) {
         return getWindowScrollTop(rootWindow);
     }
     return element.scrollTop;
 }
 function getScrollLeft(element, rootWindow = window) {
-    if (element === rootWindow) {
+    if (element instanceof Window) {
         return getWindowScrollLeft(rootWindow);
     }
     return element.scrollLeft;
 }
 function getScrollableElement(element) {
-    let rootDocument = element.ownerDocument;
-    let rootWindow = rootDocument ? rootDocument.defaultView : undefined;
-    if (!rootDocument) {
-        rootDocument = element.document ? element.document : element;
-        rootWindow = rootDocument.defaultView;
-    }
+    const rootDocument = element.ownerDocument;
+    const rootWindow = rootDocument.defaultView;
     const props = [
         'auto',
         'scroll'
     ];
-    let el = element.parentNode;
+    let el = element.parentElement;
     while(el && el.style && rootDocument.body !== el){
         let { overflow, overflowX, overflowY } = el.style;
         if ([
@@ -606,7 +643,9 @@ function getScrollableElement(element) {
         ].includes('scroll')) {
             return el;
         } else {
-            ({ overflow, overflowX, overflowY } = rootWindow.getComputedStyle(el));
+            if (rootWindow) {
+                ({ overflow, overflowX, overflowY } = rootWindow.getComputedStyle(el));
+            }
             if (props.includes(overflow) || props.includes(overflowX) || props.includes(overflowY)) {
                 return el;
             }
@@ -618,9 +657,9 @@ function getScrollableElement(element) {
         if (el.clientWidth <= el.scrollWidth + 1 && (props.includes(overflowX) || props.includes(overflow))) {
             return el;
         }
-        el = el.parentNode;
+        el = el.parentElement;
     }
-    return rootWindow;
+    return rootWindow ?? rootDocument.documentElement;
 }
 function getMaximumScrollTop(element) {
     return element.scrollHeight - element.clientHeight;
@@ -631,56 +670,59 @@ function getMaximumScrollLeft(element) {
 function getTrimmingContainer(base) {
     const rootDocument = base.ownerDocument;
     const rootWindow = rootDocument.defaultView;
-    let el = base.parentNode;
+    let el = base.parentElement;
     while(el && el.style && rootDocument.body !== el){
         if (el.style.overflow !== 'visible' && el.style.overflow !== '') {
             return el;
         }
-        const computedStyle = rootWindow.getComputedStyle(el);
-        const allowedProperties = [
-            'scroll',
-            'hidden',
-            'auto',
-            'clip'
-        ];
-        const property = computedStyle.getPropertyValue('overflow');
-        const propertyY = computedStyle.getPropertyValue('overflow-y');
-        const propertyX = computedStyle.getPropertyValue('overflow-x');
-        if (allowedProperties.includes(property) || allowedProperties.includes(propertyY) || allowedProperties.includes(propertyX)) {
-            return el;
+        if (rootWindow) {
+            const computedStyle = rootWindow.getComputedStyle(el);
+            const allowedProperties = [
+                'scroll',
+                'hidden',
+                'auto',
+                'clip'
+            ];
+            const property = computedStyle.getPropertyValue('overflow');
+            const propertyY = computedStyle.getPropertyValue('overflow-y');
+            const propertyX = computedStyle.getPropertyValue('overflow-x');
+            if (allowedProperties.includes(property) || allowedProperties.includes(propertyY) || allowedProperties.includes(propertyX)) {
+                return el;
+            }
         }
-        el = el.parentNode;
+        el = el.parentElement;
     }
-    return rootWindow;
+    return rootWindow ?? rootDocument.documentElement;
 }
 function getStyle(element, prop, rootWindow = window) {
     if (!element) {
         return;
-    } else if (element === rootWindow) {
+    } else if (element instanceof Window) {
         if (prop === 'width') {
-            return `${rootWindow.innerWidth}px`;
+            return `${element.innerWidth}px`;
         } else if (prop === 'height') {
-            return `${rootWindow.innerHeight}px`;
+            return `${element.innerHeight}px`;
         }
         return;
     }
-    const styleProp = element.style[prop];
+    const styleProp = element.style.getPropertyValue(prop) || element.style[prop];
     if (styleProp !== '' && styleProp !== undefined) {
         return styleProp;
     }
     const computedStyle = rootWindow.getComputedStyle(element);
-    if (computedStyle[prop] !== '' && computedStyle[prop] !== undefined) {
-        return computedStyle[prop];
+    const computedProp = computedStyle.getPropertyValue(prop) || computedStyle[prop];
+    if (computedProp !== '' && computedProp !== undefined) {
+        return computedProp;
     }
 }
 function matchesCSSRules(element, rule) {
-    const { selectorText } = rule;
     let result = false;
-    if (rule.type === CSSRule.STYLE_RULE && selectorText) {
-        if (element.msMatchesSelector) {
-            result = element.msMatchesSelector(selectorText);
+    if (rule instanceof CSSStyleRule && rule.selectorText) {
+        const elementWithMs = element;
+        if ('msMatchesSelector' in element && typeof elementWithMs.msMatchesSelector === 'function') {
+            result = elementWithMs.msMatchesSelector(rule.selectorText);
         } else if (element.matches) {
-            result = element.matches(selectorText);
+            result = element.matches(rule.selectorText);
         }
     }
     return result;
@@ -692,10 +734,10 @@ function outerHeight(element) {
     return element.offsetHeight;
 }
 function innerHeight(element) {
-    return element.clientHeight || element.innerHeight;
+    return element instanceof Window ? element.innerHeight : element.clientHeight;
 }
 function innerWidth(element) {
-    return element.clientWidth || element.innerWidth;
+    return element instanceof Window ? element.innerWidth : element.clientWidth;
 }
 function addEvent(element, event, callback) {
     element.addEventListener(event, callback, false);
@@ -719,19 +761,25 @@ function getSelectionText(rootWindow = window) {
     const rootDocument = rootWindow.document;
     let text = '';
     if (rootWindow.getSelection) {
-        text = rootWindow.getSelection().toString();
-    } else if (rootDocument.selection && rootDocument.selection.type !== 'Control') {
-        text = rootDocument.selection.createRange().text;
+        text = rootWindow.getSelection()?.toString() ?? '';
+    } else {
+        if ('selection' in rootDocument) {
+            const docWithSel = rootDocument;
+            if (docWithSel.selection && docWithSel.selection.type !== 'Control') {
+                text = docWithSel.selection.createRange().text;
+            }
+        }
     }
     return text;
 }
 function clearTextSelection(rootWindow = window) {
     // http://stackoverflow.com/questions/3169786/clear-text-selection-with-javascript
     if (rootWindow.getSelection) {
-        if (rootWindow.getSelection().empty) {
-            rootWindow.getSelection().empty();
-        } else if (rootWindow.getSelection().removeAllRanges) {
-            rootWindow.getSelection().removeAllRanges();
+        const sel = rootWindow.getSelection();
+        if (sel?.empty) {
+            sel.empty();
+        } else if (sel?.removeAllRanges) {
+            sel.removeAllRanges();
         }
     }
 }
@@ -744,21 +792,24 @@ function setCaretPosition(element, pos, endPos) {
         try {
             element.setSelectionRange(pos, endPos);
         } catch (err) {
-            const elementParent = element.parentNode;
-            const parentDisplayValue = elementParent.style.display;
-            elementParent.style.display = 'block';
-            element.setSelectionRange(pos, endPos);
-            elementParent.style.display = parentDisplayValue;
+            const elementParent = element.parentElement;
+            if (elementParent) {
+                const parentDisplayValue = elementParent.style.display;
+                elementParent.style.display = 'block';
+                element.setSelectionRange(pos, endPos);
+                elementParent.style.display = parentDisplayValue;
+            }
         }
     }
 }
+let cachedScrollbarWidth;
 function getFractionalScalingCompensation(rootDocument = document) {
     if (!(0, _browser.isWindowsOS)()) {
         return 0;
     }
     // On Windows, fractional scaling makes the scrollbar wider to compensate for the anti-aliasing.
     // This is a workaround to calculate the correct scrollbar width.
-    return Number.isInteger(rootDocument.defaultView.devicePixelRatio || 1) ? 0 : 2;
+    return Number.isInteger(rootDocument.defaultView?.devicePixelRatio || 1) ? 0 : 2;
 }
 /**
  * Helper to calculate scrollbar width.
@@ -811,7 +862,6 @@ function walkontableCalculateScrollbarWidth(rootDocument = document) {
     }
     return defaultScrollbarWidth;
 }
-let cachedScrollbarWidth;
 function getScrollbarWidth(rootDocument = document) {
     if (cachedScrollbarWidth === undefined) {
         cachedScrollbarWidth = walkontableCalculateScrollbarWidth(rootDocument);
@@ -857,11 +907,11 @@ function isInput(element) {
     return element && (inputs.indexOf(element.nodeName) > -1 || element.contentEditable === 'true');
 }
 function isOutsideInput(element) {
-    return isInput(element) && element.hasAttribute('data-hot-input') === false;
+    return isInput(element) && 'hotInput' in element.dataset === false;
 }
 function selectElementIfAllowed(element) {
     const activeElement = element.ownerDocument.activeElement;
-    if (!isOutsideInput(activeElement)) {
+    if (isHTMLElement(activeElement) && !isOutsideInput(activeElement) && (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) {
         element.select();
     }
 }
@@ -882,24 +932,25 @@ function observeVisibilityChangeOnce(elementToBeObserved, callback) {
 function makeElementContentEditableAndSelectItsContent(element, invisibleSelection = true, ariaHidden = true) {
     const ownerDocument = element.ownerDocument;
     const range = ownerDocument.createRange();
-    const sel = ownerDocument.defaultView.getSelection();
+    const sel = ownerDocument.defaultView?.getSelection();
     setAttribute(element, 'contenteditable', true);
     if (ariaHidden) {
-        setAttribute(element, ...(0, _a11y.A11Y_HIDDEN)());
+        const hiddenAttr = (0, _a11y.A11Y_HIDDEN)();
+        setAttribute(element, hiddenAttr[0], hiddenAttr[1]);
     }
     if (invisibleSelection) {
         addClass(element, 'invisibleSelection');
     }
     range.selectNodeContents(element);
-    sel.removeAllRanges();
-    sel.addRange(range);
+    sel?.removeAllRanges();
+    sel?.addRange(range);
 }
 function removeContentEditableFromElementAndDeselect(selectedElement, removeInvisibleSelectionClass = true) {
-    const sel = selectedElement.ownerDocument.defaultView.getSelection();
+    const sel = selectedElement.ownerDocument.defaultView?.getSelection();
     if (selectedElement.hasAttribute('aria-hidden')) {
         selectedElement.removeAttribute('aria-hidden');
     }
-    sel.removeAllRanges();
+    sel?.removeAllRanges();
     if (removeInvisibleSelectionClass) {
         removeClass(selectedElement, 'invisibleSelection');
     }
@@ -911,6 +962,22 @@ function runWithSelectedContendEditableElement(element, callback, invisibleSelec
     removeContentEditableFromElementAndDeselect(element, invisibleSelection);
 }
 function isHTMLElement(element) {
-    const OwnElement = element?.ownerDocument?.defaultView.Element;
-    return !!(OwnElement && OwnElement !== null && element instanceof OwnElement);
+    if (typeof element !== 'object' || element === null) {
+        return false;
+    }
+    const OwnElement = element.ownerDocument?.defaultView?.Element;
+    return !!(OwnElement && element instanceof OwnElement);
+}
+function isHTMLTableCellElement(element) {
+    return isHTMLElement(element) && (element.tagName === 'TD' || element.tagName === 'TH');
+}
+function isHTMLInputElement(element) {
+    return element.tagName === 'INPUT';
+}
+function isShadowRoot(node) {
+    return node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && 'host' in node;
+}
+function getChildEl(parent, index) {
+    const node = parent.childNodes[index];
+    return node ? node : null;
 }