@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/a11y/focus-monitor/focus-monitor.js

@@ -28,343 +28,339 @@ const captureEventListenerOptions = normalizePassiveListenerOptions({
     capture: true
 });
 /** Monitors mouse and keyboard events to determine the cause of focus events. */
-let FocusMonitor = /** @class */ (() => {
-    class FocusMonitor {
-        constructor(_ngZone, _platform, 
-        /** @breaking-change 11.0.0 make document required */
-        document, options) {
-            this._ngZone = _ngZone;
-            this._platform = _platform;
-            /** The focus origin that the next focus event is a result of. */
-            this._origin = null;
-            /** Whether the window has just been focused. */
-            this._windowFocused = false;
-            /** Map of elements being monitored to their info. */
-            this._elementInfo = new Map();
-            /** The number of elements currently being monitored. */
-            this._monitoredElementCount = 0;
-            /**
-             * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
-             * as well as the number of monitored elements that they contain. We have to treat focus/blur
-             * handlers differently from the rest of the events, because the browser won't emit events
-             * to the document when focus moves inside of a shadow root.
-             */
-            this._rootNodeFocusListenerCount = new Map();
-            /**
-             * Event listener for `keydown` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentKeydownListener = () => {
-                // On keydown record the origin and clear any touch event that may be in progress.
-                this._lastTouchTarget = null;
-                this._setOriginForCurrentEventQueue('keyboard');
-            };
-            /**
-             * Event listener for `mousedown` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentMousedownListener = (event) => {
-                // On mousedown record the origin only if there is not touch
-                // target, since a mousedown can happen as a result of a touch event.
-                if (!this._lastTouchTarget) {
-                    // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
-                    // Resolve the focus source to `keyboard` if we detect one of them.
-                    const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
-                    this._setOriginForCurrentEventQueue(source);
-                }
-            };
-            /**
-             * Event listener for `touchstart` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentTouchstartListener = (event) => {
-                // When the touchstart event fires the focus event is not yet in the event queue. This means
-                // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to
-                // see if a focus happens.
-                if (this._touchTimeoutId != null) {
-                    clearTimeout(this._touchTimeoutId);
-                }
-                this._lastTouchTarget = getTarget(event);
-                this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);
-            };
-            /**
-             * Event listener for `focus` events on the window.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._windowFocusListener = () => {
-                // Make a note of when the window regains focus, so we can
-                // restore the origin info for the focused element.
-                this._windowFocused = true;
-                this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);
-            };
-            /**
-             * Event listener for `focus` and 'blur' events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._rootNodeFocusAndBlurListener = (event) => {
-                const target = getTarget(event);
-                const handler = event.type === 'focus' ? this._onFocus : this._onBlur;
-                // We need to walk up the ancestor chain in order to support `checkChildren`.
-                for (let element = target; element; element = element.parentElement) {
-                    handler.call(this, event, element);
-                }
-            };
-            this._document = document;
-            this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
-        }
-        monitor(element, checkChildren = false) {
-            // Do nothing if we're not on the browser platform.
-            if (!this._platform.isBrowser) {
-                return observableOf(null);
+export class FocusMonitor {
+    constructor(_ngZone, _platform, 
+    /** @breaking-change 11.0.0 make document required */
+    document, options) {
+        this._ngZone = _ngZone;
+        this._platform = _platform;
+        /** The focus origin that the next focus event is a result of. */
+        this._origin = null;
+        /** Whether the window has just been focused. */
+        this._windowFocused = false;
+        /** Map of elements being monitored to their info. */
+        this._elementInfo = new Map();
+        /** The number of elements currently being monitored. */
+        this._monitoredElementCount = 0;
+        /**
+         * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
+         * as well as the number of monitored elements that they contain. We have to treat focus/blur
+         * handlers differently from the rest of the events, because the browser won't emit events
+         * to the document when focus moves inside of a shadow root.
+         */
+        this._rootNodeFocusListenerCount = new Map();
+        /**
+         * Event listener for `keydown` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._documentKeydownListener = () => {
+            // On keydown record the origin and clear any touch event that may be in progress.
+            this._lastTouchTarget = null;
+            this._setOriginForCurrentEventQueue('keyboard');
+        };
+        /**
+         * Event listener for `mousedown` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._documentMousedownListener = (event) => {
+            // On mousedown record the origin only if there is not touch
+            // target, since a mousedown can happen as a result of a touch event.
+            if (!this._lastTouchTarget) {
+                // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
+                // Resolve the focus source to `keyboard` if we detect one of them.
+                const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
+                this._setOriginForCurrentEventQueue(source);
             }
-            const nativeElement = coerceElement(element);
-            // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
-            // the shadow root, rather than the `document`, because the browser won't emit focus events
-            // to the `document`, if focus is moving within the same shadow root.
-            const rootNode = _getShadowRoot(nativeElement) || this._getDocument();
-            const cachedInfo = this._elementInfo.get(nativeElement);
-            // Check if we're already monitoring this element.
-            if (cachedInfo) {
-                if (checkChildren) {
-                    // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
-                    // observers into ones that behave as if `checkChildren` was turned on. We need a more
-                    // robust solution.
-                    cachedInfo.checkChildren = true;
-                }
-                return cachedInfo.subject.asObservable();
+        };
+        /**
+         * Event listener for `touchstart` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._documentTouchstartListener = (event) => {
+            // When the touchstart event fires the focus event is not yet in the event queue. This means
+            // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to
+            // see if a focus happens.
+            if (this._touchTimeoutId != null) {
+                clearTimeout(this._touchTimeoutId);
             }
-            // Create monitored element info.
-            const info = {
-                checkChildren: checkChildren,
-                subject: new Subject(),
-                rootNode
-            };
-            this._elementInfo.set(nativeElement, info);
-            this._registerGlobalListeners(info);
-            return info.subject.asObservable();
-        }
-        stopMonitoring(element) {
-            const nativeElement = coerceElement(element);
-            const elementInfo = this._elementInfo.get(nativeElement);
-            if (elementInfo) {
-                elementInfo.subject.complete();
-                this._setClasses(nativeElement);
-                this._elementInfo.delete(nativeElement);
-                this._removeGlobalListeners(elementInfo);
+            this._lastTouchTarget = getTarget(event);
+            this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);
+        };
+        /**
+         * Event listener for `focus` events on the window.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._windowFocusListener = () => {
+            // Make a note of when the window regains focus, so we can
+            // restore the origin info for the focused element.
+            this._windowFocused = true;
+            this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);
+        };
+        /**
+         * Event listener for `focus` and 'blur' events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._rootNodeFocusAndBlurListener = (event) => {
+            const target = getTarget(event);
+            const handler = event.type === 'focus' ? this._onFocus : this._onBlur;
+            // We need to walk up the ancestor chain in order to support `checkChildren`.
+            for (let element = target; element; element = element.parentElement) {
+                handler.call(this, event, element);
             }
+        };
+        this._document = document;
+        this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
+    }
+    monitor(element, checkChildren = false) {
+        // Do nothing if we're not on the browser platform.
+        if (!this._platform.isBrowser) {
+            return observableOf(null);
         }
-        focusVia(element, origin, options) {
-            const nativeElement = coerceElement(element);
-            this._setOriginForCurrentEventQueue(origin);
-            // `focus` isn't available on the server
-            if (typeof nativeElement.focus === 'function') {
-                // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.
-                nativeElement.focus(options);
+        const nativeElement = coerceElement(element);
+        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
+        // the shadow root, rather than the `document`, because the browser won't emit focus events
+        // to the `document`, if focus is moving within the same shadow root.
+        const rootNode = _getShadowRoot(nativeElement) || this._getDocument();
+        const cachedInfo = this._elementInfo.get(nativeElement);
+        // Check if we're already monitoring this element.
+        if (cachedInfo) {
+            if (checkChildren) {
+                // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
+                // observers into ones that behave as if `checkChildren` was turned on. We need a more
+                // robust solution.
+                cachedInfo.checkChildren = true;
             }
+            return cachedInfo.subject.asObservable();
         }
-        ngOnDestroy() {
-            this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
+        // Create monitored element info.
+        const info = {
+            checkChildren: checkChildren,
+            subject: new Subject(),
+            rootNode
+        };
+        this._elementInfo.set(nativeElement, info);
+        this._registerGlobalListeners(info);
+        return info.subject.asObservable();
+    }
+    stopMonitoring(element) {
+        const nativeElement = coerceElement(element);
+        const elementInfo = this._elementInfo.get(nativeElement);
+        if (elementInfo) {
+            elementInfo.subject.complete();
+            this._setClasses(nativeElement);
+            this._elementInfo.delete(nativeElement);
+            this._removeGlobalListeners(elementInfo);
         }
-        /** Access injected document if available or fallback to global document reference */
-        _getDocument() {
-            return this._document || document;
+    }
+    focusVia(element, origin, options) {
+        const nativeElement = coerceElement(element);
+        this._setOriginForCurrentEventQueue(origin);
+        // `focus` isn't available on the server
+        if (typeof nativeElement.focus === 'function') {
+            // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.
+            nativeElement.focus(options);
         }
-        /** Use defaultView of injected document if available or fallback to global window reference */
-        _getWindow() {
-            const doc = this._getDocument();
-            return doc.defaultView || window;
+    }
+    ngOnDestroy() {
+        this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
+    }
+    /** Access injected document if available or fallback to global document reference */
+    _getDocument() {
+        return this._document || document;
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        const doc = this._getDocument();
+        return doc.defaultView || window;
+    }
+    _toggleClass(element, className, shouldSet) {
+        if (shouldSet) {
+            element.classList.add(className);
         }
-        _toggleClass(element, className, shouldSet) {
-            if (shouldSet) {
-                element.classList.add(className);
-            }
-            else {
-                element.classList.remove(className);
-            }
+        else {
+            element.classList.remove(className);
         }
-        _getFocusOrigin(event) {
-            // If we couldn't detect a cause for the focus event, it's due to one of three reasons:
-            // 1) The window has just regained focus, in which case we want to restore the focused state of
-            //    the element from before the window blurred.
-            // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.
-            // 3) The element was programmatically focused, in which case we should mark the origin as
-            //    'program'.
-            if (this._origin) {
-                return this._origin;
-            }
-            if (this._windowFocused && this._lastFocusOrigin) {
-                return this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                return 'touch';
-            }
-            else {
-                return 'program';
-            }
+    }
+    _getFocusOrigin(event) {
+        // If we couldn't detect a cause for the focus event, it's due to one of three reasons:
+        // 1) The window has just regained focus, in which case we want to restore the focused state of
+        //    the element from before the window blurred.
+        // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.
+        // 3) The element was programmatically focused, in which case we should mark the origin as
+        //    'program'.
+        if (this._origin) {
+            return this._origin;
         }
-        /**
-         * Sets the focus classes on the element based on the given focus origin.
-         * @param element The element to update the classes on.
-         * @param origin The focus origin.
-         */
-        _setClasses(element, origin) {
-            this._toggleClass(element, 'cdk-focused', !!origin);
-            this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');
-            this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');
-            this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');
-            this._toggleClass(element, 'cdk-program-focused', origin === 'program');
+        if (this._windowFocused && this._lastFocusOrigin) {
+            return this._lastFocusOrigin;
         }
-        /**
-         * Sets the origin and schedules an async function to clear it at the end of the event queue.
-         * If the detection mode is 'eventual', the origin is never cleared.
-         * @param origin The origin to set.
-         */
-        _setOriginForCurrentEventQueue(origin) {
-            this._ngZone.runOutsideAngular(() => {
-                this._origin = origin;
-                if (this._detectionMode === 0 /* IMMEDIATE */) {
-                    // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
-                    // tick after the interaction event fired. To ensure the focus origin is always correct,
-                    // the focus origin will be determined at the beginning of the next tick.
-                    this._originTimeoutId = setTimeout(() => this._origin = null, 1);
-                }
-            });
+        else if (this._wasCausedByTouch(event)) {
+            return 'touch';
         }
-        /**
-         * Checks whether the given focus event was caused by a touchstart event.
-         * @param event The focus event to check.
-         * @returns Whether the event was caused by a touch.
-         */
-        _wasCausedByTouch(event) {
-            // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
-            // Consider the following dom structure:
-            //
-            // <div #parent tabindex="0" cdkFocusClasses>
-            //   <div #child (click)="#parent.focus()"></div>
-            // </div>
-            //
-            // If the user touches the #child element and the #parent is programmatically focused as a
-            // result, this code will still consider it to have been caused by the touch event and will
-            // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
-            // relatively small edge-case that can be worked around by using
-            // focusVia(parentEl, 'program') to focus the parent element.
-            //
-            // If we decide that we absolutely must handle this case correctly, we can do so by listening
-            // for the first focus event after the touchstart, and then the first blur event after that
-            // focus event. When that blur event fires we know that whatever follows is not a result of the
-            // touchstart.
-            const focusTarget = getTarget(event);
-            return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
-                (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
+        else {
+            return 'program';
         }
-        /**
-         * Handles focus events on a registered element.
-         * @param event The focus event.
-         * @param element The monitored element.
-         */
-        _onFocus(event, element) {
-            // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
-            // focus event affecting the monitored element. If we want to use the origin of the first event
-            // instead we should check for the cdk-focused class here and return if the element already has
-            // it. (This only matters for elements that have includesChildren = true).
-            // If we are not counting child-element-focus as focused, make sure that the event target is the
-            // monitored element itself.
-            const elementInfo = this._elementInfo.get(element);
-            if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
-                return;
+    }
+    /**
+     * Sets the focus classes on the element based on the given focus origin.
+     * @param element The element to update the classes on.
+     * @param origin The focus origin.
+     */
+    _setClasses(element, origin) {
+        this._toggleClass(element, 'cdk-focused', !!origin);
+        this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');
+        this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');
+        this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');
+        this._toggleClass(element, 'cdk-program-focused', origin === 'program');
+    }
+    /**
+     * Sets the origin and schedules an async function to clear it at the end of the event queue.
+     * If the detection mode is 'eventual', the origin is never cleared.
+     * @param origin The origin to set.
+     */
+    _setOriginForCurrentEventQueue(origin) {
+        this._ngZone.runOutsideAngular(() => {
+            this._origin = origin;
+            if (this._detectionMode === 0 /* IMMEDIATE */) {
+                // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
+                // tick after the interaction event fired. To ensure the focus origin is always correct,
+                // the focus origin will be determined at the beginning of the next tick.
+                this._originTimeoutId = setTimeout(() => this._origin = null, 1);
             }
-            const origin = this._getFocusOrigin(event);
-            this._setClasses(element, origin);
-            this._emitOrigin(elementInfo.subject, origin);
-            this._lastFocusOrigin = origin;
+        });
+    }
+    /**
+     * Checks whether the given focus event was caused by a touchstart event.
+     * @param event The focus event to check.
+     * @returns Whether the event was caused by a touch.
+     */
+    _wasCausedByTouch(event) {
+        // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
+        // Consider the following dom structure:
+        //
+        // <div #parent tabindex="0" cdkFocusClasses>
+        //   <div #child (click)="#parent.focus()"></div>
+        // </div>
+        //
+        // If the user touches the #child element and the #parent is programmatically focused as a
+        // result, this code will still consider it to have been caused by the touch event and will
+        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
+        // relatively small edge-case that can be worked around by using
+        // focusVia(parentEl, 'program') to focus the parent element.
+        //
+        // If we decide that we absolutely must handle this case correctly, we can do so by listening
+        // for the first focus event after the touchstart, and then the first blur event after that
+        // focus event. When that blur event fires we know that whatever follows is not a result of the
+        // touchstart.
+        const focusTarget = getTarget(event);
+        return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
+            (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
+    }
+    /**
+     * Handles focus events on a registered element.
+     * @param event The focus event.
+     * @param element The monitored element.
+     */
+    _onFocus(event, element) {
+        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
+        // focus event affecting the monitored element. If we want to use the origin of the first event
+        // instead we should check for the cdk-focused class here and return if the element already has
+        // it. (This only matters for elements that have includesChildren = true).
+        // If we are not counting child-element-focus as focused, make sure that the event target is the
+        // monitored element itself.
+        const elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
+            return;
         }
-        /**
-         * Handles blur events on a registered element.
-         * @param event The blur event.
-         * @param element The monitored element.
-         */
-        _onBlur(event, element) {
-            // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
-            // order to focus another child of the monitored element.
-            const elementInfo = this._elementInfo.get(element);
-            if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
-                element.contains(event.relatedTarget))) {
-                return;
-            }
-            this._setClasses(element);
-            this._emitOrigin(elementInfo.subject, null);
+        const origin = this._getFocusOrigin(event);
+        this._setClasses(element, origin);
+        this._emitOrigin(elementInfo.subject, origin);
+        this._lastFocusOrigin = origin;
+    }
+    /**
+     * Handles blur events on a registered element.
+     * @param event The blur event.
+     * @param element The monitored element.
+     */
+    _onBlur(event, element) {
+        // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
+        // order to focus another child of the monitored element.
+        const elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
+            element.contains(event.relatedTarget))) {
+            return;
         }
-        _emitOrigin(subject, origin) {
-            this._ngZone.run(() => subject.next(origin));
+        this._setClasses(element);
+        this._emitOrigin(elementInfo.subject, null);
+    }
+    _emitOrigin(subject, origin) {
+        this._ngZone.run(() => subject.next(origin));
+    }
+    _registerGlobalListeners(elementInfo) {
+        if (!this._platform.isBrowser) {
+            return;
         }
-        _registerGlobalListeners(elementInfo) {
-            if (!this._platform.isBrowser) {
-                return;
-            }
-            const rootNode = elementInfo.rootNode;
-            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
-            if (!rootNodeFocusListeners) {
-                this._ngZone.runOutsideAngular(() => {
-                    rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                });
-            }
-            this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
-            // Register global listeners when first element is monitored.
-            if (++this._monitoredElementCount === 1) {
-                // Note: we listen to events in the capture phase so we
-                // can detect them even if the user stops propagation.
-                this._ngZone.runOutsideAngular(() => {
-                    const document = this._getDocument();
-                    const window = this._getWindow();
-                    document.addEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
-                    document.addEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
-                    document.addEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
-                    window.addEventListener('focus', this._windowFocusListener);
-                });
-            }
+        const rootNode = elementInfo.rootNode;
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
+            this._ngZone.runOutsideAngular(() => {
+                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+            });
         }
-        _removeGlobalListeners(elementInfo) {
-            const rootNode = elementInfo.rootNode;
-            if (this._rootNodeFocusListenerCount.has(rootNode)) {
-                const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
-                if (rootNodeFocusListeners > 1) {
-                    this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
-                }
-                else {
-                    rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    this._rootNodeFocusListenerCount.delete(rootNode);
-                }
-            }
-            // Unregister global listeners when last element is unmonitored.
-            if (!--this._monitoredElementCount) {
+        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
+        // Register global listeners when first element is monitored.
+        if (++this._monitoredElementCount === 1) {
+            // Note: we listen to events in the capture phase so we
+            // can detect them even if the user stops propagation.
+            this._ngZone.runOutsideAngular(() => {
                 const document = this._getDocument();
                 const window = this._getWindow();
-                document.removeEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
-                document.removeEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
-                document.removeEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
-                window.removeEventListener('focus', this._windowFocusListener);
-                // Clear timeouts for all potentially pending timeouts to prevent the leaks.
-                clearTimeout(this._windowFocusTimeoutId);
-                clearTimeout(this._touchTimeoutId);
-                clearTimeout(this._originTimeoutId);
+                document.addEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
+                document.addEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
+                document.addEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
+                window.addEventListener('focus', this._windowFocusListener);
+            });
+        }
+    }
+    _removeGlobalListeners(elementInfo) {
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
+            if (rootNodeFocusListeners > 1) {
+                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
+            }
+            else {
+                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                this._rootNodeFocusListenerCount.delete(rootNode);
             }
         }
+        // Unregister global listeners when last element is unmonitored.
+        if (!--this._monitoredElementCount) {
+            const document = this._getDocument();
+            const window = this._getWindow();
+            document.removeEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
+            document.removeEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
+            document.removeEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
+            window.removeEventListener('focus', this._windowFocusListener);
+            // Clear timeouts for all potentially pending timeouts to prevent the leaks.
+            clearTimeout(this._windowFocusTimeoutId);
+            clearTimeout(this._touchTimeoutId);
+            clearTimeout(this._originTimeoutId);
+        }
     }
-    FocusMonitor.ɵprov = i0.ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i2.DOCUMENT, 8), i0.ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
-    FocusMonitor.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    FocusMonitor.ctorParameters = () => [
-        { type: NgZone },
-        { type: Platform },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }
-    ];
-    return FocusMonitor;
-})();
-export { FocusMonitor };
+}
+FocusMonitor.ɵprov = i0.ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i2.DOCUMENT, 8), i0.ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
+FocusMonitor.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+FocusMonitor.ctorParameters = () => [
+    { type: NgZone },
+    { type: Platform },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }
+];
 /** Gets the target of an event, accounting for Shadow DOM. */
 function getTarget(event) {
     // If an event is bound outside the Shadow DOM, the `event.target` will
@@ -380,37 +376,33 @@ function getTarget(event) {
  *    focused.
  * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
  */
-let CdkMonitorFocus = /** @class */ (() => {
-    class CdkMonitorFocus {
-        constructor(_elementRef, _focusMonitor) {
-            this._elementRef = _elementRef;
-            this._focusMonitor = _focusMonitor;
-            this.cdkFocusChange = new EventEmitter();
-        }
-        ngAfterViewInit() {
-            this._monitorSubscription = this._focusMonitor.monitor(this._elementRef, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
-                .subscribe(origin => this.cdkFocusChange.emit(origin));
-        }
-        ngOnDestroy() {
-            this._focusMonitor.stopMonitoring(this._elementRef);
-            if (this._monitorSubscription) {
-                this._monitorSubscription.unsubscribe();
-            }
+export class CdkMonitorFocus {
+    constructor(_elementRef, _focusMonitor) {
+        this._elementRef = _elementRef;
+        this._focusMonitor = _focusMonitor;
+        this.cdkFocusChange = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        this._monitorSubscription = this._focusMonitor.monitor(this._elementRef, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
+            .subscribe(origin => this.cdkFocusChange.emit(origin));
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        if (this._monitorSubscription) {
+            this._monitorSubscription.unsubscribe();
         }
     }
-    CdkMonitorFocus.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
-                },] }
-    ];
-    CdkMonitorFocus.ctorParameters = () => [
-        { type: ElementRef },
-        { type: FocusMonitor }
-    ];
-    CdkMonitorFocus.propDecorators = {
-        cdkFocusChange: [{ type: Output }]
-    };
-    return CdkMonitorFocus;
-})();
-export { CdkMonitorFocus };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-monitor.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/focus-monitor/focus-monitor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,QAAQ,EAAE,+BAA+B,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAChG,OAAO,EACL,SAAS,EACT,UAAU,EACV,YAAY,EACZ,MAAM,EACN,UAAU,EACV,cAAc,EACd,MAAM,EAEN,QAAQ,EACR,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAa,EAAE,IAAI,YAAY,EAAE,OAAO,EAAe,MAAM,MAAM,CAAC;AAC3E,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,+BAA+B,EAAC,MAAM,mBAAmB,CAAC;;;;AAGlE,kGAAkG;AAClG,kDAAkD;AAClD,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC;AAkCnC,8CAA8C;AAC9C,MAAM,CAAC,MAAM,6BAA6B,GACtC,IAAI,cAAc,CAAsB,mCAAmC,CAAC,CAAC;AAQjF;;;GAGG;AACH,MAAM,2BAA2B,GAAG,+BAA+B,CAAC;IAClE,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,IAAI;CACd,CAAC,CAAC;AAGH,iFAAiF;AACjF;IAAA,MACa,YAAY;QAiGvB,YACY,OAAe,EACf,SAAmB;QAC3B,qDAAqD;QACvB,QAAkB,EACG,OACvB;YALpB,YAAO,GAAP,OAAO,CAAQ;YACf,cAAS,GAAT,SAAS,CAAU;YAlG/B,iEAAiE;YACzD,YAAO,GAAgB,IAAI,CAAC;YAKpC,gDAAgD;YACxC,mBAAc,GAAG,KAAK,CAAC;YAc/B,qDAAqD;YAC7C,iBAAY,GAAG,IAAI,GAAG,EAAqC,CAAC;YAEpE,wDAAwD;YAChD,2BAAsB,GAAG,CAAC,CAAC;YAEnC;;;;;eAKG;YACK,gCAA2B,GAAG,IAAI,GAAG,EAAgC,CAAC;YAQ9E;;;eAGG;YACK,6BAAwB,GAAG,GAAG,EAAE;gBACtC,kFAAkF;gBAClF,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAC7B,IAAI,CAAC,8BAA8B,CAAC,UAAU,CAAC,CAAC;YAClD,CAAC,CAAA;YAED;;;eAGG;YACK,+BAA0B,GAAG,CAAC,KAAiB,EAAE,EAAE;gBACzD,4DAA4D;gBAC5D,qEAAqE;gBACrE,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;oBAC1B,kFAAkF;oBAClF,mEAAmE;oBACnE,MAAM,MAAM,GAAG,+BAA+B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC;oBAC7E,IAAI,CAAC,8BAA8B,CAAC,MAAM,CAAC,CAAC;iBAC7C;YACH,CAAC,CAAA;YAED;;;eAGG;YACK,gCAA2B,GAAG,CAAC,KAAiB,EAAE,EAAE;gBAC1D,4FAA4F;gBAC5F,2FAA2F;gBAC3F,0BAA0B;gBAC1B,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,EAAE;oBAChC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;iBACpC;gBAED,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;gBACzC,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,GAAG,IAAI,EAAE,eAAe,CAAC,CAAC;YACzF,CAAC,CAAA;YAED;;;eAGG;YACK,yBAAoB,GAAG,GAAG,EAAE;gBAClC,0DAA0D;gBAC1D,mDAAmD;gBACnD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;gBAC3B,IAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC;YAC7E,CAAC,CAAA;YAeD;;;eAGG;YACK,kCAA6B,GAAG,CAAC,KAAY,EAAE,EAAE;gBACvD,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;gBAChC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;gBAEtE,6EAA6E;gBAC7E,KAAK,IAAI,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE;oBACnE,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAmB,EAAE,OAAO,CAAC,CAAC;iBAClD;YACH,CAAC,CAAA;YAfC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC1B,IAAI,CAAC,cAAc,GAAG,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,sBAAuC,CAAC;QACtF,CAAC;QAiCD,OAAO,CAAC,OAA8C,EAC9C,gBAAyB,KAAK;YACpC,mDAAmD;YACnD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;gBAC7B,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;aAC3B;YAED,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAE7C,uFAAuF;YACvF,2FAA2F;YAC3F,qEAAqE;YACrE,MAAM,QAAQ,GAAI,cAAc,CAAC,aAAa,CAAsB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5F,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;YAExD,kDAAkD;YAClD,IAAI,UAAU,EAAE;gBACd,IAAI,aAAa,EAAE;oBACjB,oFAAoF;oBACpF,sFAAsF;oBACtF,mBAAmB;oBACnB,UAAU,CAAC,aAAa,GAAG,IAAI,CAAC;iBACjC;gBAED,OAAO,UAAU,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;aAC1C;YAED,iCAAiC;YACjC,MAAM,IAAI,GAAyB;gBACjC,aAAa,EAAE,aAAa;gBAC5B,OAAO,EAAE,IAAI,OAAO,EAAe;gBACnC,QAAQ;aACT,CAAC;YACF,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;YAEpC,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QACrC,CAAC;QAcD,cAAc,CAAC,OAA8C;YAC3D,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAC7C,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;YAEzD,IAAI,WAAW,EAAE;gBACf,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;gBAE/B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;gBAChC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBACxC,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;aAC1C;QACH,CAAC;QAkBD,QAAQ,CAAC,OAA8C,EAC/C,MAAmB,EACnB,OAAsB;YAE5B,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAE7C,IAAI,CAAC,8BAA8B,CAAC,MAAM,CAAC,CAAC;YAE5C,wCAAwC;YACxC,IAAI,OAAO,aAAa,CAAC,KAAK,KAAK,UAAU,EAAE;gBAC7C,4FAA4F;gBAC3F,aAAqB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;aACvC;QACH,CAAC;QAED,WAAW;YACT,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9E,CAAC;QAED,qFAAqF;QAC7E,YAAY;YAClB,OAAO,IAAI,CAAC,SAAS,IAAI,QAAQ,CAAC;QACpC,CAAC;QAED,+FAA+F;QACvF,UAAU;YAChB,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAChC,OAAO,GAAG,CAAC,WAAW,IAAI,MAAM,CAAC;QACnC,CAAC;QAEO,YAAY,CAAC,OAAgB,EAAE,SAAiB,EAAE,SAAkB;YAC1E,IAAI,SAAS,EAAE;gBACb,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;aAClC;iBAAM;gBACL,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;aACrC;QACH,CAAC;QAEO,eAAe,CAAC,KAAiB;YACvC,uFAAuF;YACvF,+FAA+F;YAC/F,iDAAiD;YACjD,kFAAkF;YAClF,0FAA0F;YAC1F,gBAAgB;YAChB,IAAI,IAAI,CAAC,OAAO,EAAE;gBAChB,OAAO,IAAI,CAAC,OAAO,CAAC;aACrB;YAED,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,gBAAgB,EAAE;gBAChD,OAAO,IAAI,CAAC,gBAAgB,CAAC;aAC9B;iBAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE;gBACxC,OAAO,OAAO,CAAC;aAChB;iBAAM;gBACL,OAAO,SAAS,CAAC;aAClB;QACH,CAAC;QAED;;;;WAIG;QACK,WAAW,CAAC,OAAoB,EAAE,MAAoB;YAC5D,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;YACpD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YACpE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,sBAAsB,EAAE,MAAM,KAAK,UAAU,CAAC,CAAC;YAC1E,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YACpE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,qBAAqB,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC;QAC1E,CAAC;QAED;;;;WAIG;QACK,8BAA8B,CAAC,MAAmB;YACxD,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;gBAClC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;gBAEtB,IAAI,IAAI,CAAC,cAAc,sBAAwC,EAAE;oBAC/D,4FAA4F;oBAC5F,wFAAwF;oBACxF,yEAAyE;oBACzE,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;iBAClE;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED;;;;WAIG;QACK,iBAAiB,CAAC,KAAiB;YACzC,wFAAwF;YACxF,wCAAwC;YACxC,EAAE;YACF,6CAA6C;YAC7C,iDAAiD;YACjD,SAAS;YACT,EAAE;YACF,0FAA0F;YAC1F,2FAA2F;YAC3F,yFAAyF;YACzF,gEAAgE;YAChE,6DAA6D;YAC7D,EAAE;YACF,6FAA6F;YAC7F,2FAA2F;YAC3F,+FAA+F;YAC/F,cAAc;YACd,MAAM,WAAW,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YACrC,OAAO,IAAI,CAAC,gBAAgB,YAAY,IAAI,IAAI,WAAW,YAAY,IAAI;gBACvE,CAAC,WAAW,KAAK,IAAI,CAAC,gBAAgB,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAC7F,CAAC;QAED;;;;WAIG;QACK,QAAQ,CAAC,KAAiB,EAAE,OAAoB;YACtD,4FAA4F;YAC5F,+FAA+F;YAC/F,+FAA+F;YAC/F,0EAA0E;YAE1E,gGAAgG;YAChG,4BAA4B;YAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACnD,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,WAAW,CAAC,aAAa,IAAI,OAAO,KAAK,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE;gBAChF,OAAO;aACR;YAED,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YAC3C,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAClC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC9C,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;QACjC,CAAC;QAED;;;;WAIG;QACH,OAAO,CAAC,KAAiB,EAAE,OAAoB;YAC7C,+FAA+F;YAC/F,yDAAyD;YACzD,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAEnD,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,CAAC,aAAa,IAAI,KAAK,CAAC,aAAa,YAAY,IAAI;gBACjF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE;gBAC1C,OAAO;aACR;YAED,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC9C,CAAC;QAEO,WAAW,CAAC,OAA6B,EAAE,MAAmB;YACpE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/C,CAAC;QAEO,wBAAwB,CAAC,WAAiC;YAChE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;gBAC7B,OAAO;aACR;YAED,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;YACtC,MAAM,sBAAsB,GAAG,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAEnF,IAAI,CAAC,sBAAsB,EAAE;gBAC3B,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;oBAClC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,6BAA6B,EACnE,2BAA2B,CAAC,CAAC;oBAC/B,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,EAClE,2BAA2B,CAAC,CAAC;gBACjC,CAAC,CAAC,CAAC;aACJ;YAED,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,QAAQ,EAAE,sBAAsB,GAAG,CAAC,CAAC,CAAC;YAE3E,6DAA6D;YAC7D,IAAI,EAAE,IAAI,CAAC,sBAAsB,KAAK,CAAC,EAAE;gBACvC,uDAAuD;gBACvD,sDAAsD;gBACtD,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;oBAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;oBACrC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;oBAEjC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,wBAAwB,EAChE,2BAA2B,CAAC,CAAC;oBAC/B,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,0BAA0B,EACpE,2BAA2B,CAAC,CAAC;oBAC/B,QAAQ,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,2BAA2B,EACtE,2BAA2B,CAAC,CAAC;oBAC/B,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAC9D,CAAC,CAAC,CAAC;aACJ;QACH,CAAC;QAEO,sBAAsB,CAAC,WAAiC;YAC9D,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;YAEtC,IAAI,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBAClD,MAAM,sBAAsB,GAAG,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC;gBAE/E,IAAI,sBAAsB,GAAG,CAAC,EAAE;oBAC9B,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,QAAQ,EAAE,sBAAsB,GAAG,CAAC,CAAC,CAAC;iBAC5E;qBAAM;oBACL,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,6BAA6B,EACtE,2BAA2B,CAAC,CAAC;oBAC/B,QAAQ,CAAC,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,EACrE,2BAA2B,CAAC,CAAC;oBAC/B,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;iBACnD;aACF;YAED,gEAAgE;YAChE,IAAI,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE;gBAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBACrC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;gBAEjC,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,wBAAwB,EACnE,2BAA2B,CAAC,CAAC;gBAC/B,QAAQ,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,0BAA0B,EACvE,2BAA2B,CAAC,CAAC;gBAC/B,QAAQ,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,2BAA2B,EACzE,2BAA2B,CAAC,CAAC;gBAC/B,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAE/D,4EAA4E;gBAC5E,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;gBACzC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBACnC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;aACrC;QACH,CAAC;;;;gBAzcF,UAAU,SAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;;gBArE9B,MAAM;gBARA,QAAQ;gDAmLT,QAAQ,YAAI,MAAM,SAAC,QAAQ;gDAC3B,QAAQ,YAAI,MAAM,SAAC,6BAA6B;;uBA5LvD;KA+hBC;SAzcY,YAAY;AA2czB,8DAA8D;AAC9D,SAAS,SAAS,CAAC,KAAY;IAC7B,uEAAuE;IACvE,qEAAqE;IACrE,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAuB,CAAC;AAC7F,CAAC;AAGD;;;;;;;;GAQG;AACH;IAAA,MAGa,eAAe;QAI1B,YAAoB,WAAoC,EAAU,aAA2B;YAAzE,gBAAW,GAAX,WAAW,CAAyB;YAAU,kBAAa,GAAb,aAAa,CAAc;YAFnF,mBAAc,GAAG,IAAI,YAAY,EAAe,CAAC;QAEqC,CAAC;QAEjG,eAAe;YACb,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CACpD,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,wBAAwB,CAAC,CAAC;iBACrE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3D,CAAC;QAED,WAAW;YACT,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAEpD,IAAI,IAAI,CAAC,oBAAoB,EAAE;gBAC7B,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,CAAC;aACzC;QACH,CAAC;;;gBAtBF,SAAS,SAAC;oBACT,QAAQ,EAAE,oDAAoD;iBAC/D;;;gBAziBC,UAAU;gBA8iBuE,YAAY;;;iCAF5F,MAAM;;IAkBT,sBAAC;KAAA;SApBY,eAAe","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Platform, normalizePassiveListenerOptions, _getShadowRoot} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Injectable,\n  InjectionToken,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  AfterViewInit,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject, Subscription} from 'rxjs';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {DOCUMENT} from '@angular/common';\nimport {isFakeMousedownFromScreenReader} from '../fake-mousedown';\n\n\n// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n// that a value of around 650ms seems appropriate.\nexport const TOUCH_BUFFER_MS = 650;\n\n\nexport type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/**\n * Corresponds to the options that can be passed to the native `focus` event.\n * via https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus\n */\nexport interface FocusOptions {\n  /** Whether the browser should scroll to the element when it is focused. */\n  preventScroll?: boolean;\n}\n\n/** Detection mode used for attributing the origin of a focus event. */\nexport const enum FocusMonitorDetectionMode {\n  /**\n   * Any mousedown, keydown, or touchstart event that happened in the previous\n   * tick or the current tick will be used to assign a focus event's origin (to\n   * either mouse, keyboard, or touch). This is the default option.\n   */\n  IMMEDIATE,\n  /**\n   * A focus event's origin is always attributed to the last corresponding\n   * mousedown, keydown, or touchstart event, no matter how long ago it occured.\n   */\n  EVENTUAL\n}\n\n/** Injectable service-level options for FocusMonitor. */\nexport interface FocusMonitorOptions {\n  detectionMode?: FocusMonitorDetectionMode;\n}\n\n/** InjectionToken for FocusMonitorOptions. */\nexport const FOCUS_MONITOR_DEFAULT_OPTIONS =\n    new InjectionToken<FocusMonitorOptions>('cdk-focus-monitor-default-options');\n\ntype MonitoredElementInfo = {\n  checkChildren: boolean,\n  subject: Subject<FocusOrigin>,\n  rootNode: HTMLElement|Document\n};\n\n/**\n * Event listener options that enable capturing and also\n * mark the listener as passive if the browser supports it.\n */\nconst captureEventListenerOptions = normalizePassiveListenerOptions({\n  passive: true,\n  capture: true\n});\n\n\n/** Monitors mouse and keyboard events to determine the cause of focus events. */\n@Injectable({providedIn: 'root'})\nexport class FocusMonitor implements OnDestroy {\n  /** The focus origin that the next focus event is a result of. */\n  private _origin: FocusOrigin = null;\n\n  /** The FocusOrigin of the last focus event tracked by the FocusMonitor. */\n  private _lastFocusOrigin: FocusOrigin;\n\n  /** Whether the window has just been focused. */\n  private _windowFocused = false;\n\n  /** The target of the last touch event. */\n  private _lastTouchTarget: EventTarget | null;\n\n  /** The timeout id of the touch timeout, used to cancel timeout later. */\n  private _touchTimeoutId: number;\n\n  /** The timeout id of the window focus timeout. */\n  private _windowFocusTimeoutId: number;\n\n  /** The timeout id of the origin clearing timeout. */\n  private _originTimeoutId: number;\n\n  /** Map of elements being monitored to their info. */\n  private _elementInfo = new Map<HTMLElement, MonitoredElementInfo>();\n\n  /** The number of elements currently being monitored. */\n  private _monitoredElementCount = 0;\n\n  /**\n   * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n   * as well as the number of monitored elements that they contain. We have to treat focus/blur\n   * handlers differently from the rest of the events, because the browser won't emit events\n   * to the document when focus moves inside of a shadow root.\n   */\n  private _rootNodeFocusListenerCount = new Map<HTMLElement|Document, number>();\n\n  /**\n   * The specified detection mode, used for attributing the origin of a focus\n   * event.\n   */\n  private readonly _detectionMode: FocusMonitorDetectionMode;\n\n  /**\n   * Event listener for `keydown` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentKeydownListener = () => {\n    // On keydown record the origin and clear any touch event that may be in progress.\n    this._lastTouchTarget = null;\n    this._setOriginForCurrentEventQueue('keyboard');\n  }\n\n  /**\n   * Event listener for `mousedown` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentMousedownListener = (event: MouseEvent) => {\n    // On mousedown record the origin only if there is not touch\n    // target, since a mousedown can happen as a result of a touch event.\n    if (!this._lastTouchTarget) {\n      // In some cases screen readers fire fake `mousedown` events instead of `keydown`.\n      // Resolve the focus source to `keyboard` if we detect one of them.\n      const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';\n      this._setOriginForCurrentEventQueue(source);\n    }\n  }\n\n  /**\n   * Event listener for `touchstart` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentTouchstartListener = (event: TouchEvent) => {\n    // When the touchstart event fires the focus event is not yet in the event queue. This means\n    // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to\n    // see if a focus happens.\n    if (this._touchTimeoutId != null) {\n      clearTimeout(this._touchTimeoutId);\n    }\n\n    this._lastTouchTarget = getTarget(event);\n    this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);\n  }\n\n  /**\n   * Event listener for `focus` events on the window.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _windowFocusListener = () => {\n    // Make a note of when the window regains focus, so we can\n    // restore the origin info for the focused element.\n    this._windowFocused = true;\n    this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);\n  }\n\n  /** Used to reference correct document/window */\n  protected _document?: Document;\n\n  constructor(\n      private _ngZone: NgZone,\n      private _platform: Platform,\n      /** @breaking-change 11.0.0 make document required */\n      @Optional() @Inject(DOCUMENT) document: any|null,\n      @Optional() @Inject(FOCUS_MONITOR_DEFAULT_OPTIONS) options:\n          FocusMonitorOptions|null) {\n    this._document = document;\n    this._detectionMode = options?.detectionMode || FocusMonitorDetectionMode.IMMEDIATE;\n  }\n  /**\n   * Event listener for `focus` and 'blur' events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _rootNodeFocusAndBlurListener = (event: Event) => {\n    const target = getTarget(event);\n    const handler = event.type === 'focus' ? this._onFocus : this._onBlur;\n\n    // We need to walk up the ancestor chain in order to support `checkChildren`.\n    for (let element = target; element; element = element.parentElement) {\n      handler.call(this, event as FocusEvent, element);\n    }\n  }\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: HTMLElement, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: ElementRef<HTMLElement>, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  monitor(element: HTMLElement | ElementRef<HTMLElement>,\n          checkChildren: boolean = false): Observable<FocusOrigin> {\n    // Do nothing if we're not on the browser platform.\n    if (!this._platform.isBrowser) {\n      return observableOf(null);\n    }\n\n    const nativeElement = coerceElement(element);\n\n    // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to\n    // the shadow root, rather than the `document`, because the browser won't emit focus events\n    // to the `document`, if focus is moving within the same shadow root.\n    const rootNode = (_getShadowRoot(nativeElement) as HTMLElement|null) || this._getDocument();\n    const cachedInfo = this._elementInfo.get(nativeElement);\n\n    // Check if we're already monitoring this element.\n    if (cachedInfo) {\n      if (checkChildren) {\n        // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren\n        // observers into ones that behave as if `checkChildren` was turned on. We need a more\n        // robust solution.\n        cachedInfo.checkChildren = true;\n      }\n\n      return cachedInfo.subject.asObservable();\n    }\n\n    // Create monitored element info.\n    const info: MonitoredElementInfo = {\n      checkChildren: checkChildren,\n      subject: new Subject<FocusOrigin>(),\n      rootNode\n    };\n    this._elementInfo.set(nativeElement, info);\n    this._registerGlobalListeners(info);\n\n    return info.subject.asObservable();\n  }\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: HTMLElement): void;\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: ElementRef<HTMLElement>): void;\n\n  stopMonitoring(element: HTMLElement | ElementRef<HTMLElement>): void {\n    const nativeElement = coerceElement(element);\n    const elementInfo = this._elementInfo.get(nativeElement);\n\n    if (elementInfo) {\n      elementInfo.subject.complete();\n\n      this._setClasses(nativeElement);\n      this._elementInfo.delete(nativeElement);\n      this._removeGlobalListeners(elementInfo);\n    }\n  }\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: HTMLElement, origin: FocusOrigin, options?: FocusOptions): void;\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: ElementRef<HTMLElement>, origin: FocusOrigin, options?: FocusOptions): void;\n\n  focusVia(element: HTMLElement | ElementRef<HTMLElement>,\n          origin: FocusOrigin,\n          options?: FocusOptions): void {\n\n    const nativeElement = coerceElement(element);\n\n    this._setOriginForCurrentEventQueue(origin);\n\n    // `focus` isn't available on the server\n    if (typeof nativeElement.focus === 'function') {\n      // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.\n      (nativeElement as any).focus(options);\n    }\n  }\n\n  ngOnDestroy() {\n    this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));\n  }\n\n  /** Access injected document if available or fallback to global document reference */\n  private _getDocument(): Document {\n    return this._document || document;\n  }\n\n  /** Use defaultView of injected document if available or fallback to global window reference */\n  private _getWindow(): Window {\n    const doc = this._getDocument();\n    return doc.defaultView || window;\n  }\n\n  private _toggleClass(element: Element, className: string, shouldSet: boolean) {\n    if (shouldSet) {\n      element.classList.add(className);\n    } else {\n      element.classList.remove(className);\n    }\n  }\n\n  private _getFocusOrigin(event: FocusEvent): FocusOrigin {\n    // If we couldn't detect a cause for the focus event, it's due to one of three reasons:\n    // 1) The window has just regained focus, in which case we want to restore the focused state of\n    //    the element from before the window blurred.\n    // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.\n    // 3) The element was programmatically focused, in which case we should mark the origin as\n    //    'program'.\n    if (this._origin) {\n      return this._origin;\n    }\n\n    if (this._windowFocused && this._lastFocusOrigin) {\n      return this._lastFocusOrigin;\n    } else if (this._wasCausedByTouch(event)) {\n      return 'touch';\n    } else {\n      return 'program';\n    }\n  }\n\n  /**\n   * Sets the focus classes on the element based on the given focus origin.\n   * @param element The element to update the classes on.\n   * @param origin The focus origin.\n   */\n  private _setClasses(element: HTMLElement, origin?: FocusOrigin): void {\n    this._toggleClass(element, 'cdk-focused', !!origin);\n    this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');\n    this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');\n    this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');\n    this._toggleClass(element, 'cdk-program-focused', origin === 'program');\n  }\n\n  /**\n   * Sets the origin and schedules an async function to clear it at the end of the event queue.\n   * If the detection mode is 'eventual', the origin is never cleared.\n   * @param origin The origin to set.\n   */\n  private _setOriginForCurrentEventQueue(origin: FocusOrigin): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._origin = origin;\n\n      if (this._detectionMode === FocusMonitorDetectionMode.IMMEDIATE) {\n        // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*\n        // tick after the interaction event fired. To ensure the focus origin is always correct,\n        // the focus origin will be determined at the beginning of the next tick.\n        this._originTimeoutId = setTimeout(() => this._origin = null, 1);\n      }\n    });\n  }\n\n  /**\n   * Checks whether the given focus event was caused by a touchstart event.\n   * @param event The focus event to check.\n   * @returns Whether the event was caused by a touch.\n   */\n  private _wasCausedByTouch(event: FocusEvent): boolean {\n    // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.\n    // Consider the following dom structure:\n    //\n    // <div #parent tabindex=\"0\" cdkFocusClasses>\n    //   <div #child (click)=\"#parent.focus()\"></div>\n    // </div>\n    //\n    // If the user touches the #child element and the #parent is programmatically focused as a\n    // result, this code will still consider it to have been caused by the touch event and will\n    // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a\n    // relatively small edge-case that can be worked around by using\n    // focusVia(parentEl, 'program') to focus the parent element.\n    //\n    // If we decide that we absolutely must handle this case correctly, we can do so by listening\n    // for the first focus event after the touchstart, and then the first blur event after that\n    // focus event. When that blur event fires we know that whatever follows is not a result of the\n    // touchstart.\n    const focusTarget = getTarget(event);\n    return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&\n        (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));\n  }\n\n  /**\n   * Handles focus events on a registered element.\n   * @param event The focus event.\n   * @param element The monitored element.\n   */\n  private _onFocus(event: FocusEvent, element: HTMLElement) {\n    // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n    // focus event affecting the monitored element. If we want to use the origin of the first event\n    // instead we should check for the cdk-focused class here and return if the element already has\n    // it. (This only matters for elements that have includesChildren = true).\n\n    // If we are not counting child-element-focus as focused, make sure that the event target is the\n    // monitored element itself.\n    const elementInfo = this._elementInfo.get(element);\n    if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {\n      return;\n    }\n\n    const origin = this._getFocusOrigin(event);\n    this._setClasses(element, origin);\n    this._emitOrigin(elementInfo.subject, origin);\n    this._lastFocusOrigin = origin;\n  }\n\n  /**\n   * Handles blur events on a registered element.\n   * @param event The blur event.\n   * @param element The monitored element.\n   */\n  _onBlur(event: FocusEvent, element: HTMLElement) {\n    // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n    // order to focus another child of the monitored element.\n    const elementInfo = this._elementInfo.get(element);\n\n    if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&\n        element.contains(event.relatedTarget))) {\n      return;\n    }\n\n    this._setClasses(element);\n    this._emitOrigin(elementInfo.subject, null);\n  }\n\n  private _emitOrigin(subject: Subject<FocusOrigin>, origin: FocusOrigin) {\n    this._ngZone.run(() => subject.next(origin));\n  }\n\n  private _registerGlobalListeners(elementInfo: MonitoredElementInfo) {\n    if (!this._platform.isBrowser) {\n      return;\n    }\n\n    const rootNode = elementInfo.rootNode;\n    const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;\n\n    if (!rootNodeFocusListeners) {\n      this._ngZone.runOutsideAngular(() => {\n        rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n      });\n    }\n\n    this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);\n\n    // Register global listeners when first element is monitored.\n    if (++this._monitoredElementCount === 1) {\n      // Note: we listen to events in the capture phase so we\n      // can detect them even if the user stops propagation.\n      this._ngZone.runOutsideAngular(() => {\n        const document = this._getDocument();\n        const window = this._getWindow();\n\n        document.addEventListener('keydown', this._documentKeydownListener,\n          captureEventListenerOptions);\n        document.addEventListener('mousedown', this._documentMousedownListener,\n          captureEventListenerOptions);\n        document.addEventListener('touchstart', this._documentTouchstartListener,\n          captureEventListenerOptions);\n        window.addEventListener('focus', this._windowFocusListener);\n      });\n    }\n  }\n\n  private _removeGlobalListeners(elementInfo: MonitoredElementInfo) {\n    const rootNode = elementInfo.rootNode;\n\n    if (this._rootNodeFocusListenerCount.has(rootNode)) {\n      const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode)!;\n\n      if (rootNodeFocusListeners > 1) {\n        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);\n      } else {\n        rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        this._rootNodeFocusListenerCount.delete(rootNode);\n      }\n    }\n\n    // Unregister global listeners when last element is unmonitored.\n    if (!--this._monitoredElementCount) {\n      const document = this._getDocument();\n      const window = this._getWindow();\n\n      document.removeEventListener('keydown', this._documentKeydownListener,\n        captureEventListenerOptions);\n      document.removeEventListener('mousedown', this._documentMousedownListener,\n        captureEventListenerOptions);\n      document.removeEventListener('touchstart', this._documentTouchstartListener,\n        captureEventListenerOptions);\n      window.removeEventListener('focus', this._windowFocusListener);\n\n      // Clear timeouts for all potentially pending timeouts to prevent the leaks.\n      clearTimeout(this._windowFocusTimeoutId);\n      clearTimeout(this._touchTimeoutId);\n      clearTimeout(this._originTimeoutId);\n    }\n  }\n}\n\n/** Gets the target of an event, accounting for Shadow DOM. */\nfunction getTarget(event: Event): HTMLElement|null {\n  // If an event is bound outside the Shadow DOM, the `event.target` will\n  // point to the shadow root so we have to use `composedPath` instead.\n  return (event.composedPath ? event.composedPath()[0] : event.target) as HTMLElement | null;\n}\n\n\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\n@Directive({\n  selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n})\nexport class CdkMonitorFocus implements AfterViewInit, OnDestroy {\n  private _monitorSubscription: Subscription;\n  @Output() cdkFocusChange = new EventEmitter<FocusOrigin>();\n\n  constructor(private _elementRef: ElementRef<HTMLElement>, private _focusMonitor: FocusMonitor) {}\n\n  ngAfterViewInit() {\n    this._monitorSubscription = this._focusMonitor.monitor(\n      this._elementRef,\n      this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))\n      .subscribe(origin => this.cdkFocusChange.emit(origin));\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n\n    if (this._monitorSubscription) {\n      this._monitorSubscription.unsubscribe();\n    }\n  }\n}\n"]}
+}
+CdkMonitorFocus.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
+            },] }
+];
+CdkMonitorFocus.ctorParameters = () => [
+    { type: ElementRef },
+    { type: FocusMonitor }
+];
+CdkMonitorFocus.propDecorators = {
+    cdkFocusChange: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-monitor.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/focus-monitor/focus-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Platform, normalizePassiveListenerOptions, _getShadowRoot} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Injectable,\n  InjectionToken,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  AfterViewInit,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject, Subscription} from 'rxjs';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {DOCUMENT} from '@angular/common';\nimport {isFakeMousedownFromScreenReader} from '../fake-mousedown';\n\n\n// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n// that a value of around 650ms seems appropriate.\nexport const TOUCH_BUFFER_MS = 650;\n\n\nexport type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/**\n * Corresponds to the options that can be passed to the native `focus` event.\n * via https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus\n */\nexport interface FocusOptions {\n  /** Whether the browser should scroll to the element when it is focused. */\n  preventScroll?: boolean;\n}\n\n/** Detection mode used for attributing the origin of a focus event. */\nexport const enum FocusMonitorDetectionMode {\n  /**\n   * Any mousedown, keydown, or touchstart event that happened in the previous\n   * tick or the current tick will be used to assign a focus event's origin (to\n   * either mouse, keyboard, or touch). This is the default option.\n   */\n  IMMEDIATE,\n  /**\n   * A focus event's origin is always attributed to the last corresponding\n   * mousedown, keydown, or touchstart event, no matter how long ago it occured.\n   */\n  EVENTUAL\n}\n\n/** Injectable service-level options for FocusMonitor. */\nexport interface FocusMonitorOptions {\n  detectionMode?: FocusMonitorDetectionMode;\n}\n\n/** InjectionToken for FocusMonitorOptions. */\nexport const FOCUS_MONITOR_DEFAULT_OPTIONS =\n    new InjectionToken<FocusMonitorOptions>('cdk-focus-monitor-default-options');\n\ntype MonitoredElementInfo = {\n  checkChildren: boolean,\n  subject: Subject<FocusOrigin>,\n  rootNode: HTMLElement|Document\n};\n\n/**\n * Event listener options that enable capturing and also\n * mark the listener as passive if the browser supports it.\n */\nconst captureEventListenerOptions = normalizePassiveListenerOptions({\n  passive: true,\n  capture: true\n});\n\n\n/** Monitors mouse and keyboard events to determine the cause of focus events. */\n@Injectable({providedIn: 'root'})\nexport class FocusMonitor implements OnDestroy {\n  /** The focus origin that the next focus event is a result of. */\n  private _origin: FocusOrigin = null;\n\n  /** The FocusOrigin of the last focus event tracked by the FocusMonitor. */\n  private _lastFocusOrigin: FocusOrigin;\n\n  /** Whether the window has just been focused. */\n  private _windowFocused = false;\n\n  /** The target of the last touch event. */\n  private _lastTouchTarget: EventTarget | null;\n\n  /** The timeout id of the touch timeout, used to cancel timeout later. */\n  private _touchTimeoutId: number;\n\n  /** The timeout id of the window focus timeout. */\n  private _windowFocusTimeoutId: number;\n\n  /** The timeout id of the origin clearing timeout. */\n  private _originTimeoutId: number;\n\n  /** Map of elements being monitored to their info. */\n  private _elementInfo = new Map<HTMLElement, MonitoredElementInfo>();\n\n  /** The number of elements currently being monitored. */\n  private _monitoredElementCount = 0;\n\n  /**\n   * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n   * as well as the number of monitored elements that they contain. We have to treat focus/blur\n   * handlers differently from the rest of the events, because the browser won't emit events\n   * to the document when focus moves inside of a shadow root.\n   */\n  private _rootNodeFocusListenerCount = new Map<HTMLElement|Document, number>();\n\n  /**\n   * The specified detection mode, used for attributing the origin of a focus\n   * event.\n   */\n  private readonly _detectionMode: FocusMonitorDetectionMode;\n\n  /**\n   * Event listener for `keydown` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentKeydownListener = () => {\n    // On keydown record the origin and clear any touch event that may be in progress.\n    this._lastTouchTarget = null;\n    this._setOriginForCurrentEventQueue('keyboard');\n  }\n\n  /**\n   * Event listener for `mousedown` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentMousedownListener = (event: MouseEvent) => {\n    // On mousedown record the origin only if there is not touch\n    // target, since a mousedown can happen as a result of a touch event.\n    if (!this._lastTouchTarget) {\n      // In some cases screen readers fire fake `mousedown` events instead of `keydown`.\n      // Resolve the focus source to `keyboard` if we detect one of them.\n      const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';\n      this._setOriginForCurrentEventQueue(source);\n    }\n  }\n\n  /**\n   * Event listener for `touchstart` events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _documentTouchstartListener = (event: TouchEvent) => {\n    // When the touchstart event fires the focus event is not yet in the event queue. This means\n    // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to\n    // see if a focus happens.\n    if (this._touchTimeoutId != null) {\n      clearTimeout(this._touchTimeoutId);\n    }\n\n    this._lastTouchTarget = getTarget(event);\n    this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);\n  }\n\n  /**\n   * Event listener for `focus` events on the window.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _windowFocusListener = () => {\n    // Make a note of when the window regains focus, so we can\n    // restore the origin info for the focused element.\n    this._windowFocused = true;\n    this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);\n  }\n\n  /** Used to reference correct document/window */\n  protected _document?: Document;\n\n  constructor(\n      private _ngZone: NgZone,\n      private _platform: Platform,\n      /** @breaking-change 11.0.0 make document required */\n      @Optional() @Inject(DOCUMENT) document: any|null,\n      @Optional() @Inject(FOCUS_MONITOR_DEFAULT_OPTIONS) options:\n          FocusMonitorOptions|null) {\n    this._document = document;\n    this._detectionMode = options?.detectionMode || FocusMonitorDetectionMode.IMMEDIATE;\n  }\n  /**\n   * Event listener for `focus` and 'blur' events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _rootNodeFocusAndBlurListener = (event: Event) => {\n    const target = getTarget(event);\n    const handler = event.type === 'focus' ? this._onFocus : this._onBlur;\n\n    // We need to walk up the ancestor chain in order to support `checkChildren`.\n    for (let element = target; element; element = element.parentElement) {\n      handler.call(this, event as FocusEvent, element);\n    }\n  }\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: HTMLElement, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: ElementRef<HTMLElement>, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  monitor(element: HTMLElement | ElementRef<HTMLElement>,\n          checkChildren: boolean = false): Observable<FocusOrigin> {\n    // Do nothing if we're not on the browser platform.\n    if (!this._platform.isBrowser) {\n      return observableOf(null);\n    }\n\n    const nativeElement = coerceElement(element);\n\n    // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to\n    // the shadow root, rather than the `document`, because the browser won't emit focus events\n    // to the `document`, if focus is moving within the same shadow root.\n    const rootNode = (_getShadowRoot(nativeElement) as HTMLElement|null) || this._getDocument();\n    const cachedInfo = this._elementInfo.get(nativeElement);\n\n    // Check if we're already monitoring this element.\n    if (cachedInfo) {\n      if (checkChildren) {\n        // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren\n        // observers into ones that behave as if `checkChildren` was turned on. We need a more\n        // robust solution.\n        cachedInfo.checkChildren = true;\n      }\n\n      return cachedInfo.subject.asObservable();\n    }\n\n    // Create monitored element info.\n    const info: MonitoredElementInfo = {\n      checkChildren: checkChildren,\n      subject: new Subject<FocusOrigin>(),\n      rootNode\n    };\n    this._elementInfo.set(nativeElement, info);\n    this._registerGlobalListeners(info);\n\n    return info.subject.asObservable();\n  }\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: HTMLElement): void;\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: ElementRef<HTMLElement>): void;\n\n  stopMonitoring(element: HTMLElement | ElementRef<HTMLElement>): void {\n    const nativeElement = coerceElement(element);\n    const elementInfo = this._elementInfo.get(nativeElement);\n\n    if (elementInfo) {\n      elementInfo.subject.complete();\n\n      this._setClasses(nativeElement);\n      this._elementInfo.delete(nativeElement);\n      this._removeGlobalListeners(elementInfo);\n    }\n  }\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: HTMLElement, origin: FocusOrigin, options?: FocusOptions): void;\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: ElementRef<HTMLElement>, origin: FocusOrigin, options?: FocusOptions): void;\n\n  focusVia(element: HTMLElement | ElementRef<HTMLElement>,\n          origin: FocusOrigin,\n          options?: FocusOptions): void {\n\n    const nativeElement = coerceElement(element);\n\n    this._setOriginForCurrentEventQueue(origin);\n\n    // `focus` isn't available on the server\n    if (typeof nativeElement.focus === 'function') {\n      // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.\n      (nativeElement as any).focus(options);\n    }\n  }\n\n  ngOnDestroy() {\n    this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));\n  }\n\n  /** Access injected document if available or fallback to global document reference */\n  private _getDocument(): Document {\n    return this._document || document;\n  }\n\n  /** Use defaultView of injected document if available or fallback to global window reference */\n  private _getWindow(): Window {\n    const doc = this._getDocument();\n    return doc.defaultView || window;\n  }\n\n  private _toggleClass(element: Element, className: string, shouldSet: boolean) {\n    if (shouldSet) {\n      element.classList.add(className);\n    } else {\n      element.classList.remove(className);\n    }\n  }\n\n  private _getFocusOrigin(event: FocusEvent): FocusOrigin {\n    // If we couldn't detect a cause for the focus event, it's due to one of three reasons:\n    // 1) The window has just regained focus, in which case we want to restore the focused state of\n    //    the element from before the window blurred.\n    // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.\n    // 3) The element was programmatically focused, in which case we should mark the origin as\n    //    'program'.\n    if (this._origin) {\n      return this._origin;\n    }\n\n    if (this._windowFocused && this._lastFocusOrigin) {\n      return this._lastFocusOrigin;\n    } else if (this._wasCausedByTouch(event)) {\n      return 'touch';\n    } else {\n      return 'program';\n    }\n  }\n\n  /**\n   * Sets the focus classes on the element based on the given focus origin.\n   * @param element The element to update the classes on.\n   * @param origin The focus origin.\n   */\n  private _setClasses(element: HTMLElement, origin?: FocusOrigin): void {\n    this._toggleClass(element, 'cdk-focused', !!origin);\n    this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');\n    this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');\n    this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');\n    this._toggleClass(element, 'cdk-program-focused', origin === 'program');\n  }\n\n  /**\n   * Sets the origin and schedules an async function to clear it at the end of the event queue.\n   * If the detection mode is 'eventual', the origin is never cleared.\n   * @param origin The origin to set.\n   */\n  private _setOriginForCurrentEventQueue(origin: FocusOrigin): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._origin = origin;\n\n      if (this._detectionMode === FocusMonitorDetectionMode.IMMEDIATE) {\n        // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*\n        // tick after the interaction event fired. To ensure the focus origin is always correct,\n        // the focus origin will be determined at the beginning of the next tick.\n        this._originTimeoutId = setTimeout(() => this._origin = null, 1);\n      }\n    });\n  }\n\n  /**\n   * Checks whether the given focus event was caused by a touchstart event.\n   * @param event The focus event to check.\n   * @returns Whether the event was caused by a touch.\n   */\n  private _wasCausedByTouch(event: FocusEvent): boolean {\n    // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.\n    // Consider the following dom structure:\n    //\n    // <div #parent tabindex=\"0\" cdkFocusClasses>\n    //   <div #child (click)=\"#parent.focus()\"></div>\n    // </div>\n    //\n    // If the user touches the #child element and the #parent is programmatically focused as a\n    // result, this code will still consider it to have been caused by the touch event and will\n    // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a\n    // relatively small edge-case that can be worked around by using\n    // focusVia(parentEl, 'program') to focus the parent element.\n    //\n    // If we decide that we absolutely must handle this case correctly, we can do so by listening\n    // for the first focus event after the touchstart, and then the first blur event after that\n    // focus event. When that blur event fires we know that whatever follows is not a result of the\n    // touchstart.\n    const focusTarget = getTarget(event);\n    return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&\n        (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));\n  }\n\n  /**\n   * Handles focus events on a registered element.\n   * @param event The focus event.\n   * @param element The monitored element.\n   */\n  private _onFocus(event: FocusEvent, element: HTMLElement) {\n    // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n    // focus event affecting the monitored element. If we want to use the origin of the first event\n    // instead we should check for the cdk-focused class here and return if the element already has\n    // it. (This only matters for elements that have includesChildren = true).\n\n    // If we are not counting child-element-focus as focused, make sure that the event target is the\n    // monitored element itself.\n    const elementInfo = this._elementInfo.get(element);\n    if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {\n      return;\n    }\n\n    const origin = this._getFocusOrigin(event);\n    this._setClasses(element, origin);\n    this._emitOrigin(elementInfo.subject, origin);\n    this._lastFocusOrigin = origin;\n  }\n\n  /**\n   * Handles blur events on a registered element.\n   * @param event The blur event.\n   * @param element The monitored element.\n   */\n  _onBlur(event: FocusEvent, element: HTMLElement) {\n    // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n    // order to focus another child of the monitored element.\n    const elementInfo = this._elementInfo.get(element);\n\n    if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&\n        element.contains(event.relatedTarget))) {\n      return;\n    }\n\n    this._setClasses(element);\n    this._emitOrigin(elementInfo.subject, null);\n  }\n\n  private _emitOrigin(subject: Subject<FocusOrigin>, origin: FocusOrigin) {\n    this._ngZone.run(() => subject.next(origin));\n  }\n\n  private _registerGlobalListeners(elementInfo: MonitoredElementInfo) {\n    if (!this._platform.isBrowser) {\n      return;\n    }\n\n    const rootNode = elementInfo.rootNode;\n    const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;\n\n    if (!rootNodeFocusListeners) {\n      this._ngZone.runOutsideAngular(() => {\n        rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n      });\n    }\n\n    this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);\n\n    // Register global listeners when first element is monitored.\n    if (++this._monitoredElementCount === 1) {\n      // Note: we listen to events in the capture phase so we\n      // can detect them even if the user stops propagation.\n      this._ngZone.runOutsideAngular(() => {\n        const document = this._getDocument();\n        const window = this._getWindow();\n\n        document.addEventListener('keydown', this._documentKeydownListener,\n          captureEventListenerOptions);\n        document.addEventListener('mousedown', this._documentMousedownListener,\n          captureEventListenerOptions);\n        document.addEventListener('touchstart', this._documentTouchstartListener,\n          captureEventListenerOptions);\n        window.addEventListener('focus', this._windowFocusListener);\n      });\n    }\n  }\n\n  private _removeGlobalListeners(elementInfo: MonitoredElementInfo) {\n    const rootNode = elementInfo.rootNode;\n\n    if (this._rootNodeFocusListenerCount.has(rootNode)) {\n      const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode)!;\n\n      if (rootNodeFocusListeners > 1) {\n        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);\n      } else {\n        rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions);\n        this._rootNodeFocusListenerCount.delete(rootNode);\n      }\n    }\n\n    // Unregister global listeners when last element is unmonitored.\n    if (!--this._monitoredElementCount) {\n      const document = this._getDocument();\n      const window = this._getWindow();\n\n      document.removeEventListener('keydown', this._documentKeydownListener,\n        captureEventListenerOptions);\n      document.removeEventListener('mousedown', this._documentMousedownListener,\n        captureEventListenerOptions);\n      document.removeEventListener('touchstart', this._documentTouchstartListener,\n        captureEventListenerOptions);\n      window.removeEventListener('focus', this._windowFocusListener);\n\n      // Clear timeouts for all potentially pending timeouts to prevent the leaks.\n      clearTimeout(this._windowFocusTimeoutId);\n      clearTimeout(this._touchTimeoutId);\n      clearTimeout(this._originTimeoutId);\n    }\n  }\n}\n\n/** Gets the target of an event, accounting for Shadow DOM. */\nfunction getTarget(event: Event): HTMLElement|null {\n  // If an event is bound outside the Shadow DOM, the `event.target` will\n  // point to the shadow root so we have to use `composedPath` instead.\n  return (event.composedPath ? event.composedPath()[0] : event.target) as HTMLElement | null;\n}\n\n\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\n@Directive({\n  selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n})\nexport class CdkMonitorFocus implements AfterViewInit, OnDestroy {\n  private _monitorSubscription: Subscription;\n  @Output() cdkFocusChange = new EventEmitter<FocusOrigin>();\n\n  constructor(private _elementRef: ElementRef<HTMLElement>, private _focusMonitor: FocusMonitor) {}\n\n  ngAfterViewInit() {\n    this._monitorSubscription = this._focusMonitor.monitor(\n      this._elementRef,\n      this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))\n      .subscribe(origin => this.cdkFocusChange.emit(origin));\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n\n    if (this._monitorSubscription) {\n      this._monitorSubscription.unsubscribe();\n    }\n  }\n}\n"]}