@angular/cdk 12.0.6 → 12.1.0

package/bundles/cdk-a11y.umd.js

@@ -576,18 +576,21 @@
     function __importDefault(mod) {
         return (mod && mod.__esModule) ? mod : { default: mod };
     }
-    function __classPrivateFieldGet(receiver, privateMap) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to get private field on non-instance");
-        }
-        return privateMap.get(receiver);
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
     }
-    function __classPrivateFieldSet(receiver, privateMap, value) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to set private field on non-instance");
-        }
-        privateMap.set(receiver, value);
-        return value;
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
     /**
@@ -1854,6 +1857,208 @@
         { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [FOCUS_TRAP_INERT_STRATEGY,] }] }
     ]; };
 
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * 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
+     */
+    /** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
+    function isFakeMousedownFromScreenReader(event) {
+        // We can typically distinguish between these faked mousedown events and real mousedown events
+        // using the "buttons" property. While real mousedowns will indicate the mouse button that was
+        // pressed (e.g. "1" for the left mouse button), faked mousedowns will usually set the property
+        // value to 0.
+        return event.buttons === 0;
+    }
+    /** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
+    function isFakeTouchstartFromScreenReader(event) {
+        var touch = (event.touches && event.touches[0]) ||
+            (event.changedTouches && event.changedTouches[0]);
+        // A fake `touchstart` can be distinguished from a real one by looking at the `identifier`
+        // which is typically >= 0 on a real device versus -1 from a screen reader. Just to be safe,
+        // we can also look at `radiusX` and `radiusY`. This behavior was observed against a Windows 10
+        // device with a touch screen running NVDA v2020.4 and Firefox 85 or Chrome 88.
+        return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) &&
+            (touch.radiusY == null || touch.radiusY === 1);
+    }
+
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * 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
+     */
+    /**
+     * Injectable options for the InputModalityDetector. These are shallowly merged with the default
+     * options.
+     */
+    var INPUT_MODALITY_DETECTOR_OPTIONS = new i0.InjectionToken('cdk-input-modality-detector-options');
+    /**
+     * Default options for the InputModalityDetector.
+     *
+     * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
+     * keyboard input modality) for two reasons:
+     *
+     * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
+     *    in new tab', and are thus less representative of actual keyboard interaction.
+     * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
+     *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
+     *    these keys so as to not update the input modality.
+     *
+     * Note that we do not by default ignore the right Meta key on Safari because it has the same key
+     * code as the ContextMenu key on other browsers. When we switch to using event.key, we can
+     * distinguish between the two.
+     */
+    var INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS = {
+        ignoreKeys: [keycodes.ALT, keycodes.CONTROL, keycodes.MAC_META, keycodes.META, keycodes.SHIFT],
+    };
+    /**
+     * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown
+     * event to be attributed as mouse and not touch.
+     *
+     * This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
+     * that a value of around 650ms seems appropriate.
+     */
+    var TOUCH_BUFFER_MS = 650;
+    /**
+     * Event listener options that enable capturing and also mark the listener as passive if the browser
+     * supports it.
+     */
+    var modalityEventListenerOptions = i1.normalizePassiveListenerOptions({
+        passive: true,
+        capture: true,
+    });
+    /**
+     * Service that detects the user's input modality.
+     *
+     * This service does not update the input modality when a user navigates with a screen reader
+     * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+     * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+     * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+     * screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+     * input interaction.
+     *
+     * When a user is not navigating but *interacting* with a screen reader, this service attempts to
+     * update the input modality to keyboard, but in general this service's behavior is largely
+     * undefined.
+     */
+    var InputModalityDetector = /** @class */ (function () {
+        function InputModalityDetector(_platform, ngZone, document, options) {
+            var _this = this;
+            this._platform = _platform;
+            /**
+             * The most recently detected input modality event target. Is null if no input modality has been
+             * detected or if the associated event target is null for some unknown reason.
+             */
+            this._mostRecentTarget = null;
+            /** The underlying BehaviorSubject that emits whenever an input modality is detected. */
+            this._modality = new rxjs.BehaviorSubject(null);
+            /**
+             * The timestamp of the last touch input modality. Used to determine whether mousedown events
+             * should be attributed to mouse or touch.
+             */
+            this._lastTouchMs = 0;
+            /**
+             * Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+             * bound.
+             */
+            this._onKeydown = function (event) {
+                var _a, _b;
+                // If this is one of the keys we should ignore, then ignore it and don't update the input
+                // modality to keyboard.
+                if ((_b = (_a = _this._options) === null || _a === void 0 ? void 0 : _a.ignoreKeys) === null || _b === void 0 ? void 0 : _b.some(function (keyCode) { return keyCode === event.keyCode; })) {
+                    return;
+                }
+                _this._modality.next('keyboard');
+                _this._mostRecentTarget = getTarget(event);
+            };
+            /**
+             * Handles mousedown events. Must be an arrow function in order to preserve the context when it
+             * gets bound.
+             */
+            this._onMousedown = function (event) {
+                // Touches trigger both touch and mouse events, so we need to distinguish between mouse events
+                // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely
+                // after the previous touch event.
+                if (Date.now() - _this._lastTouchMs < TOUCH_BUFFER_MS) {
+                    return;
+                }
+                // Fake mousedown events are fired by some screen readers when controls are activated by the
+                // screen reader. Attribute them to keyboard input modality.
+                _this._modality.next(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse');
+                _this._mostRecentTarget = getTarget(event);
+            };
+            /**
+             * Handles touchstart events. Must be an arrow function in order to preserve the context when it
+             * gets bound.
+             */
+            this._onTouchstart = function (event) {
+                // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart
+                // events are fired. Again, attribute to keyboard input modality.
+                if (isFakeTouchstartFromScreenReader(event)) {
+                    _this._modality.next('keyboard');
+                    return;
+                }
+                // Store the timestamp of this touch event, as it's used to distinguish between mouse events
+                // triggered via mouse vs touch.
+                _this._lastTouchMs = Date.now();
+                _this._modality.next('touch');
+                _this._mostRecentTarget = getTarget(event);
+            };
+            this._options = Object.assign(Object.assign({}, INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS), options);
+            // Skip the first emission as it's null.
+            this.modalityDetected = this._modality.pipe(operators.skip(1));
+            this.modalityChanged = this.modalityDetected.pipe(operators.distinctUntilChanged());
+            // If we're not in a browser, this service should do nothing, as there's no relevant input
+            // modality to detect.
+            if (!_platform.isBrowser) {
+                return;
+            }
+            // Add the event listeners used to detect the user's input modality.
+            ngZone.runOutsideAngular(function () {
+                document.addEventListener('keydown', _this._onKeydown, modalityEventListenerOptions);
+                document.addEventListener('mousedown', _this._onMousedown, modalityEventListenerOptions);
+                document.addEventListener('touchstart', _this._onTouchstart, modalityEventListenerOptions);
+            });
+        }
+        Object.defineProperty(InputModalityDetector.prototype, "mostRecentModality", {
+            /** The most recently detected input modality. */
+            get: function () {
+                return this._modality.value;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        InputModalityDetector.prototype.ngOnDestroy = function () {
+            if (!this._platform.isBrowser) {
+                return;
+            }
+            document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
+            document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
+            document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
+        };
+        return InputModalityDetector;
+    }());
+    InputModalityDetector.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function InputModalityDetector_Factory() { return new InputModalityDetector(i0__namespace.ɵɵinject(i1__namespace.Platform), i0__namespace.ɵɵinject(i0__namespace.NgZone), i0__namespace.ɵɵinject(i2__namespace.DOCUMENT), i0__namespace.ɵɵinject(INPUT_MODALITY_DETECTOR_OPTIONS, 8)); }, token: InputModalityDetector, providedIn: "root" });
+    InputModalityDetector.decorators = [
+        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    InputModalityDetector.ctorParameters = function () { return [
+        { type: i1.Platform },
+        { type: i0.NgZone },
+        { type: Document, decorators: [{ type: i0.Inject, args: [i2.DOCUMENT,] }] },
+        { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [INPUT_MODALITY_DETECTOR_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
+        // point to the shadow root so we have to use `composedPath` instead.
+        return (event.composedPath ? event.composedPath()[0] : event.target);
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -2038,36 +2243,6 @@
         politeness: [{ type: i0.Input, args: ['cdkAriaLive',] }]
     };
 
-    /**
-     * @license
-     * Copyright Google LLC All Rights Reserved.
-     *
-     * 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
-     */
-    /** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
-    function isFakeMousedownFromScreenReader(event) {
-        // We can typically distinguish between these faked mousedown events and real mousedown events
-        // using the "buttons" property. While real mousedowns will indicate the mouse button that was
-        // pressed (e.g. "1" for the left mouse button), faked mousedowns will usually set the property
-        // value to 0.
-        return event.buttons === 0;
-    }
-    /** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
-    function isFakeTouchstartFromScreenReader(event) {
-        var touch = (event.touches && event.touches[0]) ||
-            (event.changedTouches && event.changedTouches[0]);
-        // A fake `touchstart` can be distinguished from a real one by looking at the `identifier`
-        // which is typically >= 0 on a real device versus -1 from a screen reader. Just to be safe,
-        // we can also look at `radiusX` and `radiusY`. This behavior was observed against a Windows 10
-        // device with a touch screen running NVDA v2020.4 and Firefox 85 or Chrome 88.
-        return !!touch && touch.identifier === -1 && (touch.radiusX == null || touch.radiusX === 1) &&
-            (touch.radiusY == null || touch.radiusY === 1);
-    }
-
-    // This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
-    // that a value of around 650ms seems appropriate.
-    var TOUCH_BUFFER_MS = 650;
     /** InjectionToken for FocusMonitorOptions. */
     var FOCUS_MONITOR_DEFAULT_OPTIONS = new i0.InjectionToken('cdk-focus-monitor-default-options');
     /**
@@ -2080,16 +2255,22 @@
     });
     /** Monitors mouse and keyboard events to determine the cause of focus events. */
     var FocusMonitor = /** @class */ (function () {
-        function FocusMonitor(_ngZone, _platform, 
+        function FocusMonitor(_ngZone, _platform, _inputModalityDetector, 
         /** @breaking-change 11.0.0 make document required */
         document, options) {
             var _this = this;
             this._ngZone = _ngZone;
             this._platform = _platform;
+            this._inputModalityDetector = _inputModalityDetector;
             /** 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;
+            /**
+             * Whether the origin was determined via a touch interaction. Necessary as properly attributing
+             * focus events to touch interactions requires special logic.
+             */
+            this._originFromTouchInteraction = false;
             /** Map of elements being monitored to their info. */
             this._elementInfo = new Map();
             /** The number of elements currently being monitored. */
@@ -2101,50 +2282,6 @@
              * 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 = function () {
-                // 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 = function (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.
-                    var 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 = function (event) {
-                // Some screen readers will fire a fake `touchstart` event if an element is activated using
-                // the keyboard while on a device with a touchsreen. Consider such events as keyboard focus.
-                if (!isFakeTouchstartFromScreenReader(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(function () { return _this._lastTouchTarget = null; }, TOUCH_BUFFER_MS);
-                }
-                else if (!_this._lastTouchTarget) {
-                    _this._setOriginForCurrentEventQueue('keyboard');
-                }
-            };
             /**
              * Event listener for `focus` events on the window.
              * Needs to be an arrow function in order to preserve the context when it gets bound.
@@ -2155,6 +2292,8 @@
                 _this._windowFocused = true;
                 _this._windowFocusTimeoutId = setTimeout(function () { return _this._windowFocused = false; });
             };
+            /** Subject for stopping our InputModalityDetector subscription. */
+            this._stopInputModalityDetector = new rxjs.Subject();
             /**
              * 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.
@@ -2227,7 +2366,7 @@
                 });
             }
             else {
-                this._setOriginForCurrentEventQueue(origin);
+                this._setOrigin(origin);
                 // `focus` isn't available on the server
                 if (typeof nativeElement.focus === 'function') {
                     nativeElement.focus(options);
@@ -2255,25 +2394,49 @@
                 element.classList.remove(className);
             }
         };
-        FocusMonitor.prototype._getFocusOrigin = function (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'.
+        FocusMonitor.prototype._getFocusOrigin = function (focusEventTarget) {
             if (this._origin) {
-                return this._origin;
-            }
-            if (this._windowFocused && this._lastFocusOrigin) {
-                return this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                return 'touch';
-            }
-            else {
-                return 'program';
+                // If the origin was realized via a touch interaction, we need to perform additional checks
+                // to determine whether the focus origin should be attributed to touch or program.
+                if (this._originFromTouchInteraction) {
+                    return this._shouldBeAttributedToTouch(focusEventTarget) ? 'touch' : 'program';
+                }
+                else {
+                    return this._origin;
+                }
             }
+            // If the window has just regained focus, we can restore the most recent origin from before the
+            // window blurred. Otherwise, we've reached the point where we can't identify the source of the
+            // focus. This typically means one of two things happened:
+            //
+            // 1) The element was programmatically focused, or
+            // 2) The element was focused via screen reader navigation (which generally doesn't fire
+            //    events).
+            //
+            // Because we can't distinguish between these two cases, we default to setting `program`.
+            return (this._windowFocused && this._lastFocusOrigin) ? this._lastFocusOrigin : 'program';
+        };
+        /**
+         * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a
+         * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we
+         * handle a focus event following a touch interaction, we need to determine whether (1) the focus
+         * event was directly caused by the touch interaction or (2) the focus event was caused by a
+         * subsequent programmatic focus call triggered by the touch interaction.
+         * @param focusEventTarget The target of the focus event under examination.
+         */
+        FocusMonitor.prototype._shouldBeAttributedToTouch = function (focusEventTarget) {
+            // Please note that this check is not perfect. Consider the following edge case:
+            //
+            // <div #parent tabindex="0">
+            //   <div #child tabindex="0" (click)="#parent.focus()"></div>
+            // </div>
+            //
+            // Suppose there is a FocusMonitor in IMMEDIATE mode attached to #parent. When the user touches
+            // #child, #parent is programmatically focused. This code will attribute the focus to touch
+            // instead of program. This is a relatively minor edge-case that can be worked around by using
+            // focusVia(parent, 'program') to focus #parent.
+            return (this._detectionMode === 1 /* EVENTUAL */) ||
+                !!(focusEventTarget === null || focusEventTarget === void 0 ? void 0 : focusEventTarget.contains(this._inputModalityDetector._mostRecentTarget));
         };
         /**
          * Sets the focus classes on the element based on the given focus origin.
@@ -2288,49 +2451,30 @@
             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.
+         * Updates the focus origin. If we're using immediate detection mode, we schedule an async
+         * function to clear the origin at the end of a timeout. The duration of the timeout depends on
+         * the origin being set.
          * @param origin The origin to set.
+         * @param isFromInteraction Whether we are setting the origin from an interaction event.
          */
-        FocusMonitor.prototype._setOriginForCurrentEventQueue = function (origin) {
+        FocusMonitor.prototype._setOrigin = function (origin, isFromInteraction) {
             var _this = this;
+            if (isFromInteraction === void 0) { isFromInteraction = false; }
             this._ngZone.runOutsideAngular(function () {
                 _this._origin = origin;
+                _this._originFromTouchInteraction = (origin === 'touch') && isFromInteraction;
+                // If we're in IMMEDIATE mode, reset the origin at the next tick (or in `TOUCH_BUFFER_MS` ms
+                // for a touch event). We reset the origin at the next tick because Firefox focuses one tick
+                // after the interaction event. We wait `TOUCH_BUFFER_MS` ms before resetting the origin for
+                // a touch event because when a touch event is fired, the associated focus event isn't yet in
+                // the event queue. Before doing so, clear any pending timeouts.
                 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(function () { return _this._origin = null; }, 1);
+                    clearTimeout(_this._originTimeoutId);
+                    var ms = _this._originFromTouchInteraction ? TOUCH_BUFFER_MS : 1;
+                    _this._originTimeoutId = setTimeout(function () { return _this._origin = null; }, ms);
                 }
             });
         };
-        /**
-         * 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.
-         */
-        FocusMonitor.prototype._wasCausedByTouch = function (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.
-            var 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.
@@ -2344,10 +2488,11 @@
             // If we are not counting child-element-focus as focused, make sure that the event target is the
             // monitored element itself.
             var elementInfo = this._elementInfo.get(element);
-            if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
+            var focusEventTarget = getTarget(event);
+            if (!elementInfo || (!elementInfo.checkChildren && element !== focusEventTarget)) {
                 return;
             }
-            this._originChanged(element, this._getFocusOrigin(event), elementInfo);
+            this._originChanged(element, this._getFocusOrigin(focusEventTarget), elementInfo);
         };
         /**
          * Handles blur events on a registered element.
@@ -2387,13 +2532,13 @@
                 // Note: we listen to events in the capture phase so we
                 // can detect them even if the user stops propagation.
                 this._ngZone.runOutsideAngular(function () {
-                    var document = _this._getDocument();
                     var 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);
                 });
+                // The InputModalityDetector is also just a collection of global listeners.
+                this._inputModalityDetector.modalityDetected
+                    .pipe(operators.takeUntil(this._stopInputModalityDetector))
+                    .subscribe(function (modality) { _this._setOrigin(modality, true /* isFromInteraction */); });
             }
         };
         FocusMonitor.prototype._removeGlobalListeners = function (elementInfo) {
@@ -2411,15 +2556,12 @@
             }
             // Unregister global listeners when last element is unmonitored.
             if (!--this._monitoredElementCount) {
-                var document = this._getDocument();
                 var 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);
+                // Equivalently, stop our InputModalityDetector subscription.
+                this._stopInputModalityDetector.next();
                 // Clear timeouts for all potentially pending timeouts to prevent the leaks.
                 clearTimeout(this._windowFocusTimeoutId);
-                clearTimeout(this._touchTimeoutId);
                 clearTimeout(this._originTimeoutId);
             }
         };
@@ -2445,22 +2587,17 @@
         };
         return FocusMonitor;
     }());
-    FocusMonitor.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(i0__namespace.ɵɵinject(i0__namespace.NgZone), i0__namespace.ɵɵinject(i1__namespace.Platform), i0__namespace.ɵɵinject(i2__namespace.DOCUMENT, 8), i0__namespace.ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
+    FocusMonitor.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(i0__namespace.ɵɵinject(i0__namespace.NgZone), i0__namespace.ɵɵinject(i1__namespace.Platform), i0__namespace.ɵɵinject(InputModalityDetector), i0__namespace.ɵɵinject(i2__namespace.DOCUMENT, 8), i0__namespace.ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
     FocusMonitor.decorators = [
         { type: i0.Injectable, args: [{ providedIn: 'root' },] }
     ];
     FocusMonitor.ctorParameters = function () { return [
         { type: i0.NgZone },
         { type: i1.Platform },
+        { type: InputModalityDetector },
         { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [i2.DOCUMENT,] }] },
         { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.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
-        // point to the shadow root so we have to use `composedPath` instead.
-        return (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.
@@ -2644,6 +2781,9 @@
     exports.FocusTrap = FocusTrap;
     exports.FocusTrapFactory = FocusTrapFactory;
     exports.HighContrastModeDetector = HighContrastModeDetector;
+    exports.INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS = INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS;
+    exports.INPUT_MODALITY_DETECTOR_OPTIONS = INPUT_MODALITY_DETECTOR_OPTIONS;
+    exports.InputModalityDetector = InputModalityDetector;
     exports.InteractivityChecker = InteractivityChecker;
     exports.IsFocusableConfig = IsFocusableConfig;
     exports.LIVE_ANNOUNCER_DEFAULT_OPTIONS = LIVE_ANNOUNCER_DEFAULT_OPTIONS;
@@ -2652,7 +2792,6 @@
     exports.ListKeyManager = ListKeyManager;
     exports.LiveAnnouncer = LiveAnnouncer;
     exports.MESSAGES_CONTAINER_ID = MESSAGES_CONTAINER_ID;
-    exports.TOUCH_BUFFER_MS = TOUCH_BUFFER_MS;
     exports.isFakeMousedownFromScreenReader = isFakeMousedownFromScreenReader;
     exports.isFakeTouchstartFromScreenReader = isFakeTouchstartFromScreenReader;
     exports.ɵangular_material_src_cdk_a11y_a11y_a = FocusTrapManager;