handsontable 18.0.0 → 18.1.0-rc1

package/editors/registry.js

@@ -43,15 +43,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -59,9 +56,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {

package/editors/registry.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {

package/editors/textEditor/textEditor.js

@@ -68,7 +68,7 @@ class TextEditor extends _baseEditor.BaseEditor {
    */ close() {
         this._opened = false;
         this.autoResize.unObserve();
-        if ((0, _element.isInternalElement)(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
+        if ((0, _element.isInternalElement)((0, _element.getDeepActiveElement)(this.hot.rootDocument), this.hot.rootElement)) {
             this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
         }
         this.hideEditableElement();

package/editors/textEditor/textEditor.mjs

@@ -1,7 +1,7 @@
 import { BaseEditor, EDITOR_STATE } from '../baseEditor/index.mjs';
 import EventManager from '../../eventManager.mjs';
 import { isEdge, isIOS } from '../../helpers/browser.mjs';
-import { addClass, isInternalElement, setCaretPosition, hasClass, removeClass, setAttribute } from '../../helpers/dom/element.mjs';
+import { addClass, getDeepActiveElement, isInternalElement, setCaretPosition, hasClass, removeClass, setAttribute } from '../../helpers/dom/element.mjs';
 import { rangeEach } from '../../helpers/number.mjs';
 import { createInputElementResizer } from '../../utils/autoResize.mjs';
 import { isDefined } from '../../helpers/mixed.mjs';
@@ -48,7 +48,7 @@ export const EDITOR_TYPE = 'text';
    */ close() {
         this._opened = false;
         this.autoResize.unObserve();
-        if (isInternalElement(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
+        if (isInternalElement(getDeepActiveElement(this.hot.rootDocument), this.hot.rootElement)) {
             this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
         }
         this.hideEditableElement();

package/eventManager.d.ts

@@ -1,5 +1,5 @@
 interface EventListenerEntry {
-    element: Element | Document | Window;
+    element: Element | Document | Window | ShadowRoot;
     event: string;
     callback: (event: Event) => void;
     callbackProxy: (event: Event) => void;
@@ -33,7 +33,7 @@ declare class EventManager {
      * @param {AddEventListenerOptions|boolean} [options] Listener options if object or useCapture if boolean.
      * @returns {Function} Returns function which you can easily call to remove that event.
      */
-    addEventListener<E extends Event = Event>(element: Element | Document | Window, eventName: string, callback: (event: E) => void, options?: boolean | AddEventListenerOptions): () => void;
+    addEventListener<E extends Event = Event>(element: Element | Document | Window | ShadowRoot, eventName: string, callback: (event: E) => void, options?: boolean | AddEventListenerOptions): () => void;
     /**
      * Remove the event listener previously registered.
      *
@@ -42,7 +42,7 @@ declare class EventManager {
      * @param {Function} callback Function to remove from the event target. It must be the same as during registration listener.
      * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager.
      */
-    removeEventListener(element: Element | Document | Window, eventName: string, callback: (event: Event) => void, onlyOwnEvents?: boolean): void;
+    removeEventListener(element: Element | Document | Window | ShadowRoot, eventName: string, callback: (event: Event) => void, onlyOwnEvents?: boolean): void;
     /**
      * Clear all previously registered events.
      *

package/focusManager/grid.d.ts

@@ -18,6 +18,34 @@ export declare class FocusGridManager {
      * Registers hooks to track selection changes and apply focus logic based on the configured focus mode.
      */
     init(): void;
+    /**
+     * Checks whether the browser focus currently sits inside the grid's root wrapper or portal.
+     * The state comes from focus events observed within the grid's own DOM tree, so it stays
+     * correct in environments where `document.activeElement` cannot be resolved through foreign
+     * shadow boundaries.
+     *
+     * @returns {boolean}
+     */
+    hasBrowserFocus(): boolean;
+    /**
+     * Checks whether the given focused element proves that the browser focus left the grid.
+     * Focus counts as foreign when the element is focusable, holds the browser focus, and is
+     * neither a part of the grid or its portal, nor one of the shadow hosts the grid is rendered
+     * within, nor the document body (a click on a non-focusable area keeps the focus where it
+     * was). Sandboxed hosts (e.g. Salesforce Lightning Web Security) hide the real focused
+     * element behind the host chain, so a focused ancestor host cannot prove the focus left the
+     * grid - only an unrelated element can.
+     *
+     * The check mirrors the scope-deactivation rule in the focus scope manager (`scopeManager`
+     * unlistens when a focus event lands outside every scope). Sandboxed hosts retarget the
+     * window-level focus events that rule depends on, so the mouseup path re-applies the same
+     * rule from the deepest reachable focused element. On a regular page both mechanisms agree -
+     * this adds no behavior that the scope manager does not already provide there.
+     *
+     * @param {HTMLElement | null} element The deepest reachable focused element.
+     * @returns {boolean}
+     */
+    isForeignFocusTarget(element: HTMLElement | null): boolean;
     /**
      * Get the current focus mode.
      *

package/focusManager/grid.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "FocusGridManager", {
         return FocusGridManager;
     }
 });
+const _eventManager = /*#__PURE__*/ _interop_require_default(require("../eventManager"));
 const _console = require("../helpers/console");
 const _element = require("../helpers/dom/element");
 const _function = require("../helpers/function");
@@ -17,15 +18,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -33,9 +31,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {
@@ -52,15 +48,18 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 /**
  * Possible focus modes.
  * - CELL - The browser's focus stays on the lastly selected cell element.
@@ -75,6 +74,17 @@ function _class_private_method_init(obj, privateSet) {
 var /**
    * The Handsontable instance.
    */ _hot = /*#__PURE__*/ new WeakMap(), /**
+   * Event manager used for the DOM listeners that track the browser focus within the grid.
+   *
+   * @type {EventManager}
+   */ _eventManager1 = /*#__PURE__*/ new WeakMap(), /**
+   * Tracks whether the browser focus currently sits inside the grid's root wrapper or portal.
+   * Maintained by `focusin`/`focusout` listeners bound within the grid's own DOM tree, where
+   * sandboxed hosts (e.g. Salesforce Lightning Web Security) still report true event targets -
+   * unlike `document.activeElement`, which such hosts collapse to the outermost shadow host.
+   *
+   * @type {boolean}
+   */ _hasBrowserFocus = /*#__PURE__*/ new WeakMap(), /**
    * The currently enabled focus mode.
    * Can be either:
    *
@@ -136,6 +146,54 @@ class FocusGridManager {
         _class_private_field_get(this, _hot).addHook('afterSelectionFocusSet', (...args)=>_class_private_method_get(this, _onAfterSelectionChange, onAfterSelectionChange).call(this));
         _class_private_field_get(this, _hot).addHook('afterSelectionEnd', (...args)=>_class_private_method_get(this, _focusEditorElement, focusEditorElement).call(this));
         _class_private_field_get(this, _hot).addHook('afterRender', (...args)=>_class_private_method_get(this, _onAfterRender, onAfterRender).call(this));
+        _class_private_field_set(this, _eventManager1, new _eventManager.default(_class_private_field_get(this, _hot)));
+        const focusRootElements = [
+            _class_private_field_get(this, _hot).rootWrapperElement ?? _class_private_field_get(this, _hot).rootElement,
+            _class_private_field_get(this, _hot).rootPortalElement
+        ].filter((element)=>(0, _element.isHTMLElement)(element));
+        focusRootElements.forEach((focusRootElement)=>{
+            _class_private_field_get(this, _eventManager1).addEventListener(focusRootElement, 'focusin', ()=>{
+                _class_private_field_set(this, _hasBrowserFocus, true);
+            });
+            _class_private_field_get(this, _eventManager1).addEventListener(focusRootElement, 'focusout', (event)=>{
+                const relatedTarget = event.relatedTarget;
+                _class_private_field_set(this, _hasBrowserFocus, (0, _element.isHTMLElement)(relatedTarget) && focusRootElements.some((focusRoot)=>focusRoot.contains(relatedTarget)));
+            });
+        });
+    }
+    /**
+   * Checks whether the browser focus currently sits inside the grid's root wrapper or portal.
+   * The state comes from focus events observed within the grid's own DOM tree, so it stays
+   * correct in environments where `document.activeElement` cannot be resolved through foreign
+   * shadow boundaries.
+   *
+   * @returns {boolean}
+   */ hasBrowserFocus() {
+        return _class_private_field_get(this, _hasBrowserFocus);
+    }
+    /**
+   * Checks whether the given focused element proves that the browser focus left the grid.
+   * Focus counts as foreign when the element is focusable, holds the browser focus, and is
+   * neither a part of the grid or its portal, nor one of the shadow hosts the grid is rendered
+   * within, nor the document body (a click on a non-focusable area keeps the focus where it
+   * was). Sandboxed hosts (e.g. Salesforce Lightning Web Security) hide the real focused
+   * element behind the host chain, so a focused ancestor host cannot prove the focus left the
+   * grid - only an unrelated element can.
+   *
+   * The check mirrors the scope-deactivation rule in the focus scope manager (`scopeManager`
+   * unlistens when a focus event lands outside every scope). Sandboxed hosts retarget the
+   * window-level focus events that rule depends on, so the mouseup path re-applies the same
+   * rule from the deepest reachable focused element. On a regular page both mechanisms agree -
+   * this adds no behavior that the scope manager does not already provide there.
+   *
+   * @param {HTMLElement | null} element The deepest reachable focused element.
+   * @returns {boolean}
+   */ isForeignFocusTarget(element) {
+        const { rootElement, rootPortalElement, rootDocument } = _class_private_field_get(this, _hot);
+        if (element === null || element === rootDocument.body || element === rootDocument.documentElement || (0, _element.isInternalElement)(element, rootElement) || rootPortalElement && rootPortalElement.contains(element)) {
+            return false;
+        }
+        return !(0, _element.getShadowHostChain)(rootElement).includes(element);
     }
     /**
    * Get the current focus mode.
@@ -279,6 +337,14 @@ class FocusGridManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _eventManager1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hasBrowserFocus, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_init(this, _focusMode, {
             writable: true,
             value: void 0
@@ -303,6 +369,8 @@ class FocusGridManager {
             writable: true,
             value: void 0
         });
+        _class_private_field_set(this, _eventManager1, null);
+        _class_private_field_set(this, _hasBrowserFocus, false);
         _class_private_field_set(this, _refocusDelay, 1);
         _class_private_field_set(this, _refocusElementGetter, null);
         _class_private_field_set(this, _debouncedSelect, new Map());
@@ -337,7 +405,8 @@ function focusCell() {
     // have run. Reading `this.#isSuspended` inside the callback would miss the suspend window.
     const suspended = _class_private_field_get(this, _isSuspended);
     _class_private_method_get(this, _getSelectedCell, getSelectedCell).call(this, (selectedCell)=>{
-        const activeElement = _class_private_field_get(this, _hot).rootDocument.activeElement;
+        const deepActiveElement = (0, _element.getDeepActiveElement)(_class_private_field_get(this, _hot).rootDocument);
+        const activeElement = (0, _element.isHTMLElement)(deepActiveElement) ? deepActiveElement : null;
         // When focus management is suspended and an external focusable element (outside Handsontable)
         // currently owns the browser focus, keep it - do not blur and do not move focus to the cell.
         // This preserves the focus of inputs that live next to the grid when a programmatic selection
@@ -362,7 +431,8 @@ function focusEditorElement() {
     // owns focus, fall through so the default `imeFastEdit` behavior still moves focus to the
     // editor textarea (existing per-editor IME support tests rely on this). See #10038.
     if (_class_private_field_get(this, _isSuspended)) {
-        const activeElement = _class_private_field_get(this, _hot).rootDocument.activeElement;
+        const deepActiveElement = (0, _element.getDeepActiveElement)(_class_private_field_get(this, _hot).rootDocument);
+        const activeElement = (0, _element.isHTMLElement)(deepActiveElement) ? deepActiveElement : null;
         if (activeElement && (0, _element.isOutsideInput)(activeElement)) {
             return;
         }

package/focusManager/grid.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {
@@ -39,17 +34,16 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
+import EventManager from '../eventManager.mjs';
 import { warn } from '../helpers/console.mjs';
-import { isHTMLElement, isOutsideInput } from '../helpers/dom/element.mjs';
+import { getDeepActiveElement, getShadowHostChain, isHTMLElement, isInternalElement, isOutsideInput } from '../helpers/dom/element.mjs';
 import { debounce } from '../helpers/function.mjs';
 /**
  * Possible focus modes.
@@ -65,6 +59,17 @@ import { debounce } from '../helpers/function.mjs';
 var /**
    * The Handsontable instance.
    */ _hot = /*#__PURE__*/ new WeakMap(), /**
+   * Event manager used for the DOM listeners that track the browser focus within the grid.
+   *
+   * @type {EventManager}
+   */ _eventManager = /*#__PURE__*/ new WeakMap(), /**
+   * Tracks whether the browser focus currently sits inside the grid's root wrapper or portal.
+   * Maintained by `focusin`/`focusout` listeners bound within the grid's own DOM tree, where
+   * sandboxed hosts (e.g. Salesforce Lightning Web Security) still report true event targets -
+   * unlike `document.activeElement`, which such hosts collapse to the outermost shadow host.
+   *
+   * @type {boolean}
+   */ _hasBrowserFocus = /*#__PURE__*/ new WeakMap(), /**
    * The currently enabled focus mode.
    * Can be either:
    *
@@ -129,6 +134,54 @@ var /**
         _class_private_field_get(this, _hot).addHook('afterSelectionFocusSet', (...args)=>_class_private_method_get(this, _onAfterSelectionChange, onAfterSelectionChange).call(this));
         _class_private_field_get(this, _hot).addHook('afterSelectionEnd', (...args)=>_class_private_method_get(this, _focusEditorElement, focusEditorElement).call(this));
         _class_private_field_get(this, _hot).addHook('afterRender', (...args)=>_class_private_method_get(this, _onAfterRender, onAfterRender).call(this));
+        _class_private_field_set(this, _eventManager, new EventManager(_class_private_field_get(this, _hot)));
+        const focusRootElements = [
+            _class_private_field_get(this, _hot).rootWrapperElement ?? _class_private_field_get(this, _hot).rootElement,
+            _class_private_field_get(this, _hot).rootPortalElement
+        ].filter((element)=>isHTMLElement(element));
+        focusRootElements.forEach((focusRootElement)=>{
+            _class_private_field_get(this, _eventManager).addEventListener(focusRootElement, 'focusin', ()=>{
+                _class_private_field_set(this, _hasBrowserFocus, true);
+            });
+            _class_private_field_get(this, _eventManager).addEventListener(focusRootElement, 'focusout', (event)=>{
+                const relatedTarget = event.relatedTarget;
+                _class_private_field_set(this, _hasBrowserFocus, isHTMLElement(relatedTarget) && focusRootElements.some((focusRoot)=>focusRoot.contains(relatedTarget)));
+            });
+        });
+    }
+    /**
+   * Checks whether the browser focus currently sits inside the grid's root wrapper or portal.
+   * The state comes from focus events observed within the grid's own DOM tree, so it stays
+   * correct in environments where `document.activeElement` cannot be resolved through foreign
+   * shadow boundaries.
+   *
+   * @returns {boolean}
+   */ hasBrowserFocus() {
+        return _class_private_field_get(this, _hasBrowserFocus);
+    }
+    /**
+   * Checks whether the given focused element proves that the browser focus left the grid.
+   * Focus counts as foreign when the element is focusable, holds the browser focus, and is
+   * neither a part of the grid or its portal, nor one of the shadow hosts the grid is rendered
+   * within, nor the document body (a click on a non-focusable area keeps the focus where it
+   * was). Sandboxed hosts (e.g. Salesforce Lightning Web Security) hide the real focused
+   * element behind the host chain, so a focused ancestor host cannot prove the focus left the
+   * grid - only an unrelated element can.
+   *
+   * The check mirrors the scope-deactivation rule in the focus scope manager (`scopeManager`
+   * unlistens when a focus event lands outside every scope). Sandboxed hosts retarget the
+   * window-level focus events that rule depends on, so the mouseup path re-applies the same
+   * rule from the deepest reachable focused element. On a regular page both mechanisms agree -
+   * this adds no behavior that the scope manager does not already provide there.
+   *
+   * @param {HTMLElement | null} element The deepest reachable focused element.
+   * @returns {boolean}
+   */ isForeignFocusTarget(element) {
+        const { rootElement, rootPortalElement, rootDocument } = _class_private_field_get(this, _hot);
+        if (element === null || element === rootDocument.body || element === rootDocument.documentElement || isInternalElement(element, rootElement) || rootPortalElement && rootPortalElement.contains(element)) {
+            return false;
+        }
+        return !getShadowHostChain(rootElement).includes(element);
     }
     /**
    * Get the current focus mode.
@@ -272,6 +325,14 @@ var /**
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _eventManager, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hasBrowserFocus, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_init(this, _focusMode, {
             writable: true,
             value: void 0
@@ -296,6 +357,8 @@ var /**
             writable: true,
             value: void 0
         });
+        _class_private_field_set(this, _eventManager, null);
+        _class_private_field_set(this, _hasBrowserFocus, false);
         _class_private_field_set(this, _refocusDelay, 1);
         _class_private_field_set(this, _refocusElementGetter, null);
         _class_private_field_set(this, _debouncedSelect, new Map());
@@ -330,7 +393,8 @@ function focusCell() {
     // have run. Reading `this.#isSuspended` inside the callback would miss the suspend window.
     const suspended = _class_private_field_get(this, _isSuspended);
     _class_private_method_get(this, _getSelectedCell, getSelectedCell).call(this, (selectedCell)=>{
-        const activeElement = _class_private_field_get(this, _hot).rootDocument.activeElement;
+        const deepActiveElement = getDeepActiveElement(_class_private_field_get(this, _hot).rootDocument);
+        const activeElement = isHTMLElement(deepActiveElement) ? deepActiveElement : null;
         // When focus management is suspended and an external focusable element (outside Handsontable)
         // currently owns the browser focus, keep it - do not blur and do not move focus to the cell.
         // This preserves the focus of inputs that live next to the grid when a programmatic selection
@@ -355,7 +419,8 @@ function focusEditorElement() {
     // owns focus, fall through so the default `imeFastEdit` behavior still moves focus to the
     // editor textarea (existing per-editor IME support tests rely on this). See #10038.
     if (_class_private_field_get(this, _isSuspended)) {
-        const activeElement = _class_private_field_get(this, _hot).rootDocument.activeElement;
+        const deepActiveElement = getDeepActiveElement(_class_private_field_get(this, _hot).rootDocument);
+        const activeElement = isHTMLElement(deepActiveElement) ? deepActiveElement : null;
         if (activeElement && isOutsideInput(activeElement)) {
             return;
         }

package/focusManager/scopeManager.js

@@ -166,7 +166,7 @@ function createFocusScopeManager(hotInstance) {
                 scope.disable();
             }
             if (scope === activeScope) {
-                if (scope.contains(hotInstance.rootDocument.activeElement)) {
+                if (scope.contains((0, _element.getDeepActiveElement)(hotInstance.rootDocument))) {
                     scope.deactivateFocusCatchers();
                 } else {
                     scope.activateFocusCatchers();

package/focusManager/scopeManager.mjs

@@ -3,7 +3,7 @@ import { throwWithCause } from '../helpers/errors.mjs';
 import { createFocusScope } from './scope.mjs';
 import { useEventListener } from './eventListener.mjs';
 import { FOCUS_SOURCES } from './constants.mjs';
-import { eventTargetEl, isVisible } from '../helpers/dom/element.mjs';
+import { eventTargetEl, getDeepActiveElement, isVisible } from '../helpers/dom/element.mjs';
 /**
  * @typedef {object} FocusScopeManager
  * @property {function(): string | null} getActiveScopeId Returns the ID of the active scope.
@@ -178,7 +178,7 @@ import { eventTargetEl, isVisible } from '../helpers/dom/element.mjs';
                 scope.disable();
             }
             if (scope === activeScope) {
-                if (scope.contains(hotInstance.rootDocument.activeElement)) {
+                if (scope.contains(getDeepActiveElement(hotInstance.rootDocument))) {
                     scope.deactivateFocusCatchers();
                 } else {
                     scope.activateFocusCatchers();

package/helpers/array.d.ts

@@ -93,6 +93,31 @@ export declare function arrayAvg(array: number[]): number;
  * @returns {Array}
  */
 export declare function arrayFlatten(array: unknown[]): unknown[];
+/**
+ * Removes the elements at the given indexes from the array. The array is compacted in one
+ * pass and mutated in place, so external references to it stay valid. Cost is O(array length)
+ * regardless of how many indexes are removed - unlike one `splice` call per removed index,
+ * which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {Set<number>} indexes The indexes of the elements to remove.
+ * @returns {Array} Returns the same, mutated array.
+ */
+export declare function removeIndexesInPlace<T>(array: T[], indexes: Set<number>): T[];
+/**
+ * Inserts `amount` copies of `value` into the array at the given index. The tail is shifted
+ * right once by `amount` and the array is mutated in place, so external references to it stay
+ * valid. An index greater than the array length is clamped to it (the values are appended),
+ * matching `Array.prototype.splice` semantics. Cost is O(array length + amount) regardless of
+ * `amount` - unlike one `splice` call per inserted value, which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {number} index The index at which to insert the values.
+ * @param {number} amount The number of copies to insert.
+ * @param {*} value The value to insert.
+ * @returns {Array} Returns the same, mutated array.
+ */
+export declare function insertValuesInPlace<T>(array: T[], index: number, amount: number, value: T): T[];
 /**
  * Unique values in the array.
  *

package/helpers/array.js

@@ -56,9 +56,15 @@ _export(exports, {
     get getUnionOfArrays () {
         return getUnionOfArrays;
     },
+    get insertValuesInPlace () {
+        return insertValuesInPlace;
+    },
     get pivot () {
         return pivot;
     },
+    get removeIndexesInPlace () {
+        return removeIndexesInPlace;
+    },
     get stringToArray () {
         return stringToArray;
     },
@@ -182,10 +188,36 @@ function arrayAvg(array) {
 function arrayFlatten(array) {
     return arrayReduce(array, (initial, value)=>initial.concat(Array.isArray(value) ? arrayFlatten(value) : value), []);
 }
+function removeIndexesInPlace(array, indexes) {
+    let writeIndex = 0;
+    for(let readIndex = 0; readIndex < array.length; readIndex++){
+        if (!indexes.has(readIndex)) {
+            array[writeIndex] = array[readIndex];
+            writeIndex += 1;
+        }
+    }
+    array.length = writeIndex;
+    return array;
+}
+function insertValuesInPlace(array, index, amount, value) {
+    if (amount <= 0) {
+        return array;
+    }
+    const oldLength = array.length;
+    const insertAt = Math.min(index, oldLength);
+    array.length = oldLength + amount;
+    for(let i = oldLength - 1; i >= insertAt; i--){
+        array[i + amount] = array[i];
+    }
+    array.fill(value, insertAt, insertAt + amount);
+    return array;
+}
 function arrayUnique(array) {
     const unique = [];
+    const seen = new Set();
     arrayEach(array, (value)=>{
-        if (unique.indexOf(value) === -1) {
+        if (!seen.has(value)) {
+            seen.add(value);
             unique.push(value);
         }
     });
@@ -197,7 +229,8 @@ function getDifferenceOfArrays(...arrays) {
     ];
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>!array.includes(value));
+        const lookup = new Set(array);
+        filteredFirstArray = filteredFirstArray.filter((value)=>!lookup.has(value));
     });
     return filteredFirstArray;
 }
@@ -213,11 +246,15 @@ function getIntersectionOfArrays(...args) {
             arrays.push(arg);
         }
     });
-    const isMatch = comparator ? (value, array)=>array.some((item)=>comparator(value, item)) : (value, array)=>array.includes(value);
     const [first, ...rest] = arrays;
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>isMatch(value, array));
+        if (comparator) {
+            filteredFirstArray = filteredFirstArray.filter((value)=>array.some((item)=>comparator(value, item)));
+        } else {
+            const lookup = new Set(array);
+            filteredFirstArray = filteredFirstArray.filter((value)=>lookup.has(value));
+        }
     });
     return filteredFirstArray;
 }