@angular/cdk 9.1.3 → 9.2.2

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

@@ -10,11 +10,12 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Platform, normalizePassiveListenerOptions } from '@angular/cdk/platform';
-import { Directive, ElementRef, EventEmitter, Injectable, NgZone, Output, Optional, Inject, } from '@angular/core';
+import { Platform, normalizePassiveListenerOptions, _getShadowRoot } from '@angular/cdk/platform';
+import { Directive, ElementRef, EventEmitter, Inject, Injectable, InjectionToken, NgZone, Optional, Output, } from '@angular/core';
 import { of as observableOf, Subject } from 'rxjs';
 import { coerceElement } from '@angular/cdk/coercion';
 import { DOCUMENT } from '@angular/common';
+import { isFakeMousedownFromScreenReader } from '../fake-mousedown';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/platform";
 import * as i2 from "@angular/common";
@@ -35,6 +36,35 @@ if (false) {
      */
     FocusOptions.prototype.preventScroll;
 }
+/** @enum {number} */
+const FocusMonitorDetectionMode = {
+    /**
+     * Any mousedown, keydown, or touchstart event that happened in the previous
+     * tick or the current tick will be used to assign a focus event's origin (to
+     * either mouse, keyboard, or touch). This is the default option.
+     */
+    IMMEDIATE: 0,
+    /**
+     * A focus event's origin is always attributed to the last corresponding
+     * mousedown, keydown, or touchstart event, no matter how long ago it occured.
+     */
+    EVENTUAL: 1,
+};
+export { FocusMonitorDetectionMode };
+/**
+ * Injectable service-level options for FocusMonitor.
+ * @record
+ */
+export function FocusMonitorOptions() { }
+if (false) {
+    /** @type {?|undefined} */
+    FocusMonitorOptions.prototype.detectionMode;
+}
+/**
+ * InjectionToken for FocusMonitorOptions.
+ * @type {?}
+ */
+export const FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken('cdk-focus-monitor-default-options');
 /**
  * Event listener options that enable capturing and also
  * mark the listener as passive if the browser supports it.
@@ -51,11 +81,12 @@ export class FocusMonitor {
     /**
      * @param {?} _ngZone
      * @param {?} _platform
-     * @param {?=} document
+     * @param {?} document
+     * @param {?} options
      */
     constructor(_ngZone, _platform, 
     /** @breaking-change 11.0.0 make document required */
-    document) {
+    document, options) {
         this._ngZone = _ngZone;
         this._platform = _platform;
         /**
@@ -74,6 +105,13 @@ export class FocusMonitor {
          * 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.
@@ -91,13 +129,18 @@ export class FocusMonitor {
          * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
         this._documentMousedownListener = (/**
+         * @param {?} event
          * @return {?}
          */
-        () => {
+        (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) {
-                this._setOriginForCurrentEventQueue('mouse');
+                // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
+                // Resolve the focus source to `keyboard` if we detect one of them.
+                /** @type {?} */
+                const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
+                this._setOriginForCurrentEventQueue(source);
             }
         });
         /**
@@ -115,10 +158,7 @@ export class FocusMonitor {
             if (this._touchTimeoutId != null) {
                 clearTimeout(this._touchTimeoutId);
             }
-            // Since this listener is bound on the `document` level, any events coming from the shadow DOM
-            // will have their `target` set to the shadow root. If available, use `composedPath` to
-            // figure out the event target.
-            this._lastTouchTarget = event.composedPath ? event.composedPath()[0] : event.target;
+            this._lastTouchTarget = getTarget(event);
             this._touchTimeoutId = setTimeout((/**
              * @return {?}
              */
@@ -140,7 +180,26 @@ export class FocusMonitor {
              */
             () => 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 = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        (event) => {
+            /** @type {?} */
+            const target = getTarget(event);
+            /** @type {?} */
+            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, (/** @type {?} */ (event)), element);
+            }
+        });
         this._document = document;
+        this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
     }
     /**
      * @param {?} element
@@ -154,53 +213,27 @@ export class FocusMonitor {
         }
         /** @type {?} */
         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.
+        /** @type {?} */
+        const rootNode = ((/** @type {?} */ (_getShadowRoot(nativeElement)))) || this._getDocument();
         // Check if we're already monitoring this element.
         if (this._elementInfo.has(nativeElement)) {
             /** @type {?} */
-            let cachedInfo = this._elementInfo.get(nativeElement);
-            (/** @type {?} */ (cachedInfo)).checkChildren = checkChildren;
-            return (/** @type {?} */ (cachedInfo)).subject.asObservable();
+            const cachedInfo = (/** @type {?} */ (this._elementInfo.get(nativeElement)));
+            cachedInfo.checkChildren = checkChildren;
+            return cachedInfo.subject.asObservable();
         }
         // Create monitored element info.
         /** @type {?} */
-        let info = {
-            unlisten: (/**
-             * @return {?}
-             */
-            () => { }),
+        const info = {
             checkChildren: checkChildren,
-            subject: new Subject()
+            subject: new Subject(),
+            rootNode
         };
         this._elementInfo.set(nativeElement, info);
-        this._incrementMonitoredElementCount();
-        // Start listening. We need to listen in capture phase since focus events don't bubble.
-        /** @type {?} */
-        let focusListener = (/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => this._onFocus(event, nativeElement));
-        /** @type {?} */
-        let blurListener = (/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => this._onBlur(event, nativeElement));
-        this._ngZone.runOutsideAngular((/**
-         * @return {?}
-         */
-        () => {
-            nativeElement.addEventListener('focus', focusListener, true);
-            nativeElement.addEventListener('blur', blurListener, true);
-        }));
-        // Create an unlisten function for later.
-        info.unlisten = (/**
-         * @return {?}
-         */
-        () => {
-            nativeElement.removeEventListener('focus', focusListener, true);
-            nativeElement.removeEventListener('blur', blurListener, true);
-        });
+        this._registerGlobalListeners(info);
         return info.subject.asObservable();
     }
     /**
@@ -213,11 +246,10 @@ export class FocusMonitor {
         /** @type {?} */
         const elementInfo = this._elementInfo.get(nativeElement);
         if (elementInfo) {
-            elementInfo.unlisten();
             elementInfo.subject.complete();
             this._setClasses(nativeElement);
             this._elementInfo.delete(nativeElement);
-            this._decrementMonitoredElementCount();
+            this._removeGlobalListeners(elementInfo);
         }
     }
     /**
@@ -280,6 +312,31 @@ export class FocusMonitor {
             element.classList.remove(className);
         }
     }
+    /**
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _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';
+        }
+    }
     /**
      * Sets the focus classes on the element based on the given focus origin.
      * @private
@@ -288,18 +345,15 @@ export class FocusMonitor {
      * @return {?}
      */
     _setClasses(element, origin) {
-        /** @type {?} */
-        const elementInfo = this._elementInfo.get(element);
-        if (elementInfo) {
-            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');
-        }
+        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.
      * @private
      * @param {?} origin The origin to set.
      * @return {?}
@@ -310,13 +364,15 @@ export class FocusMonitor {
          */
         () => {
             this._origin = origin;
-            // 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((/**
-             * @return {?}
-             */
-            () => this._origin = null), 1);
+            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((/**
+                 * @return {?}
+                 */
+                () => this._origin = null), 1);
+            }
         }));
     }
     /**
@@ -344,7 +400,7 @@ export class FocusMonitor {
         // focus event. When that blur event fires we know that whatever follows is not a result of the
         // touchstart.
         /** @type {?} */
-        let focusTarget = event.target;
+        const focusTarget = getTarget(event);
         return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
             (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
     }
@@ -368,28 +424,11 @@ export class FocusMonitor {
         // monitored element itself.
         /** @type {?} */
         const elementInfo = this._elementInfo.get(element);
-        if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {
+        if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
             return;
         }
-        // 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'.
         /** @type {?} */
-        let origin = this._origin;
-        if (!origin) {
-            if (this._windowFocused && this._lastFocusOrigin) {
-                origin = this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                origin = 'touch';
-            }
-            else {
-                origin = 'program';
-            }
-        }
+        const origin = this._getFocusOrigin(event);
         this._setClasses(element, origin);
         this._emitOrigin(elementInfo.subject, origin);
         this._lastFocusOrigin = origin;
@@ -426,11 +465,29 @@ export class FocusMonitor {
     }
     /**
      * @private
+     * @param {?} elementInfo
      * @return {?}
      */
-    _incrementMonitoredElementCount() {
+    _registerGlobalListeners(elementInfo) {
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        /** @type {?} */
+        const rootNode = elementInfo.rootNode;
+        /** @type {?} */
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
+            this._ngZone.runOutsideAngular((/**
+             * @return {?}
+             */
+            () => {
+                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 && this._platform.isBrowser) {
+        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((/**
@@ -450,9 +507,24 @@ export class FocusMonitor {
     }
     /**
      * @private
+     * @param {?} elementInfo
      * @return {?}
      */
-    _decrementMonitoredElementCount() {
+    _removeGlobalListeners(elementInfo) {
+        /** @type {?} */
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            /** @type {?} */
+            const rootNodeFocusListeners = (/** @type {?} */ (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) {
             /** @type {?} */
@@ -477,9 +549,10 @@ FocusMonitor.decorators = [
 FocusMonitor.ctorParameters = () => [
     { type: NgZone },
     { type: Platform },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }
 ];
-/** @nocollapse */ FocusMonitor.ɵprov = i0.ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Platform), i0.ɵɵinject(i2.DOCUMENT, 8)); }, token: FocusMonitor, providedIn: "root" });
+/** @nocollapse */ 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" });
 if (false) {
     /**
      * The focus origin that the next focus event is a result of.
@@ -535,6 +608,22 @@ if (false) {
      * @private
      */
     FocusMonitor.prototype._monitoredElementCount;
+    /**
+     * 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.
+     * @type {?}
+     * @private
+     */
+    FocusMonitor.prototype._rootNodeFocusListenerCount;
+    /**
+     * The specified detection mode, used for attributing the origin of a focus
+     * event.
+     * @type {?}
+     * @private
+     */
+    FocusMonitor.prototype._detectionMode;
     /**
      * Event listener for `keydown` events on the document.
      * Needs to be an arrow function in order to preserve the context when it gets bound.
@@ -569,6 +658,13 @@ if (false) {
      * @protected
      */
     FocusMonitor.prototype._document;
+    /**
+     * 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.
+     * @type {?}
+     * @private
+     */
+    FocusMonitor.prototype._rootNodeFocusAndBlurListener;
     /**
      * @type {?}
      * @private
@@ -580,6 +676,16 @@ if (false) {
      */
     FocusMonitor.prototype._platform;
 }
+/**
+ * Gets the target of an event, accounting for Shadow DOM.
+ * @param {?} event
+ * @return {?}
+ */
+function getTarget(event) {
+    // If an event is bound outside the Shadow DOM, the `event.target` will
+    // point to the shadow root so we have to use `composedPath` instead.
+    return (/** @type {?} */ ((event.composedPath ? event.composedPath()[0] : event.target)));
+}
 /**
  * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
  * programmatically) and adds corresponding classes to the element.
@@ -645,4 +751,4 @@ if (false) {
      */
     CdkMonitorFocus.prototype._focusMonitor;
 }
-//# 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} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Injectable,\n  NgZone,\n  OnDestroy,\n  Output,\n  Optional,\n  Inject,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject, Subscription} from 'rxjs';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {DOCUMENT} from '@angular/common';\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\ntype MonitoredElementInfo = {\n  unlisten: Function,\n  checkChildren: boolean,\n  subject: Subject<FocusOrigin>\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   * 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 = () => {\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      this._setOriginForCurrentEventQueue('mouse');\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    // Since this listener is bound on the `document` level, any events coming from the shadow DOM\n    // will have their `target` set to the shadow root. If available, use `composedPath` to\n    // figure out the event target.\n    this._lastTouchTarget = event.composedPath ? event.composedPath()[0] : event.target;\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(private _ngZone: NgZone,\n              private _platform: Platform,\n              /** @breaking-change 11.0.0 make document required */\n              @Optional() @Inject(DOCUMENT) document?: any) {\n    this._document = document;\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    // Check if we're already monitoring this element.\n    if (this._elementInfo.has(nativeElement)) {\n      let cachedInfo = this._elementInfo.get(nativeElement);\n      cachedInfo!.checkChildren = checkChildren;\n      return cachedInfo!.subject.asObservable();\n    }\n\n    // Create monitored element info.\n    let info: MonitoredElementInfo = {\n      unlisten: () => {},\n      checkChildren: checkChildren,\n      subject: new Subject<FocusOrigin>()\n    };\n    this._elementInfo.set(nativeElement, info);\n    this._incrementMonitoredElementCount();\n\n    // Start listening. We need to listen in capture phase since focus events don't bubble.\n    let focusListener = (event: FocusEvent) => this._onFocus(event, nativeElement);\n    let blurListener = (event: FocusEvent) => this._onBlur(event, nativeElement);\n    this._ngZone.runOutsideAngular(() => {\n      nativeElement.addEventListener('focus', focusListener, true);\n      nativeElement.addEventListener('blur', blurListener, true);\n    });\n\n    // Create an unlisten function for later.\n    info.unlisten = () => {\n      nativeElement.removeEventListener('focus', focusListener, true);\n      nativeElement.removeEventListener('blur', blurListener, true);\n    };\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.unlisten();\n      elementInfo.subject.complete();\n\n      this._setClasses(nativeElement);\n      this._elementInfo.delete(nativeElement);\n      this._decrementMonitoredElementCount();\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  /**\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    const elementInfo = this._elementInfo.get(element);\n\n    if (elementInfo) {\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  /**\n   * Sets the origin and schedules an async function to clear it at the end of the event queue.\n   * @param origin The origin to set.\n   */\n  private _setOriginForCurrentEventQueue(origin: FocusOrigin): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._origin = origin;\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   * 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    let focusTarget = event.target;\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 !== event.target)) {\n      return;\n    }\n\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    let origin = this._origin;\n    if (!origin) {\n      if (this._windowFocused && this._lastFocusOrigin) {\n        origin = this._lastFocusOrigin;\n      } else if (this._wasCausedByTouch(event)) {\n        origin = 'touch';\n      } else {\n        origin = 'program';\n      }\n    }\n\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 _incrementMonitoredElementCount() {\n    // Register global listeners when first element is monitored.\n    if (++this._monitoredElementCount == 1 && this._platform.isBrowser) {\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 _decrementMonitoredElementCount() {\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\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 OnDestroy {\n  private _monitorSubscription: Subscription;\n  @Output() cdkFocusChange = new EventEmitter<FocusOrigin>();\n\n  constructor(private _elementRef: ElementRef<HTMLElement>, private _focusMonitor: FocusMonitor) {\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    this._monitorSubscription.unsubscribe();\n  }\n}\n"]}
+//# 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} 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\n    // Check if we're already monitoring this element.\n    if (this._elementInfo.has(nativeElement)) {\n      const cachedInfo = this._elementInfo.get(nativeElement)!;\n      cachedInfo.checkChildren = checkChildren;\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 OnDestroy {\n  private _monitorSubscription: Subscription;\n  @Output() cdkFocusChange = new EventEmitter<FocusOrigin>();\n\n  constructor(private _elementRef: ElementRef<HTMLElement>, private _focusMonitor: FocusMonitor) {\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    this._monitorSubscription.unsubscribe();\n  }\n}\n"]}