@angular/cdk 10.0.0-rc.3 → 10.1.0

package/fesm2015/a11y.js

@@ -1,10 +1,10 @@
 import { DOCUMENT } from '@angular/common';
 import { ɵɵdefineInjectable, ɵɵinject, Injectable, Inject, QueryList, isDevMode, NgZone, Directive, ElementRef, Input, InjectionToken, Optional, EventEmitter, Output, NgModule } from '@angular/core';
+import { Platform, normalizePassiveListenerOptions, _getShadowRoot, PlatformModule } from '@angular/cdk/platform';
 import { Subject, Subscription, of } from 'rxjs';
-import { hasModifierKey, A, Z, ZERO, NINE, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';
+import { hasModifierKey, A, Z, ZERO, NINE, END, HOME, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';
 import { tap, debounceTime, filter, map, take } from 'rxjs/operators';
 import { coerceBooleanProperty, coerceElement } from '@angular/cdk/coercion';
-import { Platform, normalizePassiveListenerOptions, _getShadowRoot, PlatformModule } from '@angular/cdk/platform';
 import { ContentObserver, ObserversModule } from '@angular/cdk/observers';
 
 /**
@@ -75,183 +75,192 @@ let messagesContainer = null;
  * want to use aria-describedby to further describe themselves without adding additional visual
  * content.
  */
-let AriaDescriber = /** @class */ (() => {
-    class AriaDescriber {
-        constructor(_document) {
-            this._document = _document;
+class AriaDescriber {
+    constructor(_document, 
+    /**
+     * @breaking-change 8.0.0 `_platform` parameter to be made required.
+     */
+    _platform) {
+        this._platform = _platform;
+        this._document = _document;
+    }
+    /**
+     * Adds to the host element an aria-describedby reference to a hidden element that contains
+     * the message. If the same message has already been registered, then it will reuse the created
+     * message element.
+     */
+    describe(hostElement, message) {
+        if (!this._canBeDescribed(hostElement, message)) {
+            return;
         }
-        /**
-         * Adds to the host element an aria-describedby reference to a hidden element that contains
-         * the message. If the same message has already been registered, then it will reuse the created
-         * message element.
-         */
-        describe(hostElement, message) {
-            if (!this._canBeDescribed(hostElement, message)) {
-                return;
-            }
-            if (typeof message !== 'string') {
-                // We need to ensure that the element has an ID.
-                this._setMessageId(message);
-                messageRegistry.set(message, { messageElement: message, referenceCount: 0 });
-            }
-            else if (!messageRegistry.has(message)) {
-                this._createMessageElement(message);
-            }
-            if (!this._isElementDescribedByMessage(hostElement, message)) {
-                this._addMessageReference(hostElement, message);
-            }
+        if (typeof message !== 'string') {
+            // We need to ensure that the element has an ID.
+            this._setMessageId(message);
+            messageRegistry.set(message, { messageElement: message, referenceCount: 0 });
         }
-        /** Removes the host element's aria-describedby reference to the message element. */
-        removeDescription(hostElement, message) {
-            if (!this._isElementNode(hostElement)) {
-                return;
-            }
-            if (this._isElementDescribedByMessage(hostElement, message)) {
-                this._removeMessageReference(hostElement, message);
-            }
-            // If the message is a string, it means that it's one that we created for the
-            // consumer so we can remove it safely, otherwise we should leave it in place.
-            if (typeof message === 'string') {
-                const registeredMessage = messageRegistry.get(message);
-                if (registeredMessage && registeredMessage.referenceCount === 0) {
-                    this._deleteMessageElement(message);
-                }
-            }
-            if (messagesContainer && messagesContainer.childNodes.length === 0) {
-                this._deleteMessagesContainer();
-            }
+        else if (!messageRegistry.has(message)) {
+            this._createMessageElement(message);
         }
-        /** Unregisters all created message elements and removes the message container. */
-        ngOnDestroy() {
-            const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);
-            for (let i = 0; i < describedElements.length; i++) {
-                this._removeCdkDescribedByReferenceIds(describedElements[i]);
-                describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
-            }
-            if (messagesContainer) {
-                this._deleteMessagesContainer();
-            }
-            messageRegistry.clear();
+        if (!this._isElementDescribedByMessage(hostElement, message)) {
+            this._addMessageReference(hostElement, message);
         }
-        /**
-         * Creates a new element in the visually hidden message container element with the message
-         * as its content and adds it to the message registry.
-         */
-        _createMessageElement(message) {
-            const messageElement = this._document.createElement('div');
-            this._setMessageId(messageElement);
-            messageElement.textContent = message;
-            this._createMessagesContainer();
-            messagesContainer.appendChild(messageElement);
-            messageRegistry.set(message, { messageElement, referenceCount: 0 });
-        }
-        /** Assigns a unique ID to an element, if it doesn't have one already. */
-        _setMessageId(element) {
-            if (!element.id) {
-                element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;
-            }
+    }
+    /** Removes the host element's aria-describedby reference to the message element. */
+    removeDescription(hostElement, message) {
+        if (!this._isElementNode(hostElement)) {
+            return;
         }
-        /** Deletes the message element from the global messages container. */
-        _deleteMessageElement(message) {
-            const registeredMessage = messageRegistry.get(message);
-            const messageElement = registeredMessage && registeredMessage.messageElement;
-            if (messagesContainer && messageElement) {
-                messagesContainer.removeChild(messageElement);
-            }
-            messageRegistry.delete(message);
-        }
-        /** Creates the global container for all aria-describedby messages. */
-        _createMessagesContainer() {
-            if (!messagesContainer) {
-                const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);
-                // When going from the server to the client, we may end up in a situation where there's
-                // already a container on the page, but we don't have a reference to it. Clear the
-                // old container so we don't get duplicates. Doing this, instead of emptying the previous
-                // container, should be slightly faster.
-                if (preExistingContainer) {
-                    preExistingContainer.parentNode.removeChild(preExistingContainer);
-                }
-                messagesContainer = this._document.createElement('div');
-                messagesContainer.id = MESSAGES_CONTAINER_ID;
-                messagesContainer.setAttribute('aria-hidden', 'true');
-                messagesContainer.style.display = 'none';
-                this._document.body.appendChild(messagesContainer);
-            }
+        if (this._isElementDescribedByMessage(hostElement, message)) {
+            this._removeMessageReference(hostElement, message);
         }
-        /** Deletes the global messages container. */
-        _deleteMessagesContainer() {
-            if (messagesContainer && messagesContainer.parentNode) {
-                messagesContainer.parentNode.removeChild(messagesContainer);
-                messagesContainer = null;
+        // If the message is a string, it means that it's one that we created for the
+        // consumer so we can remove it safely, otherwise we should leave it in place.
+        if (typeof message === 'string') {
+            const registeredMessage = messageRegistry.get(message);
+            if (registeredMessage && registeredMessage.referenceCount === 0) {
+                this._deleteMessageElement(message);
             }
         }
-        /** Removes all cdk-describedby messages that are hosted through the element. */
-        _removeCdkDescribedByReferenceIds(element) {
-            // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
-            const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
-                .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);
-            element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
+        if (messagesContainer && messagesContainer.childNodes.length === 0) {
+            this._deleteMessagesContainer();
         }
-        /**
-         * Adds a message reference to the element using aria-describedby and increments the registered
-         * message's reference count.
-         */
-        _addMessageReference(element, message) {
-            const registeredMessage = messageRegistry.get(message);
-            // Add the aria-describedby reference and set the
-            // describedby_host attribute to mark the element.
-            addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
-            element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
-            registeredMessage.referenceCount++;
+    }
+    /** Unregisters all created message elements and removes the message container. */
+    ngOnDestroy() {
+        const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);
+        for (let i = 0; i < describedElements.length; i++) {
+            this._removeCdkDescribedByReferenceIds(describedElements[i]);
+            describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
         }
-        /**
-         * Removes a message reference from the element using aria-describedby
-         * and decrements the registered message's reference count.
-         */
-        _removeMessageReference(element, message) {
-            const registeredMessage = messageRegistry.get(message);
-            registeredMessage.referenceCount--;
-            removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
-            element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+        if (messagesContainer) {
+            this._deleteMessagesContainer();
         }
-        /** Returns true if the element has been described by the provided message ID. */
-        _isElementDescribedByMessage(element, message) {
-            const referenceIds = getAriaReferenceIds(element, 'aria-describedby');
-            const registeredMessage = messageRegistry.get(message);
-            const messageId = registeredMessage && registeredMessage.messageElement.id;
-            return !!messageId && referenceIds.indexOf(messageId) != -1;
+        messageRegistry.clear();
+    }
+    /**
+     * Creates a new element in the visually hidden message container element with the message
+     * as its content and adds it to the message registry.
+     */
+    _createMessageElement(message) {
+        const messageElement = this._document.createElement('div');
+        this._setMessageId(messageElement);
+        messageElement.textContent = message;
+        this._createMessagesContainer();
+        messagesContainer.appendChild(messageElement);
+        messageRegistry.set(message, { messageElement, referenceCount: 0 });
+    }
+    /** Assigns a unique ID to an element, if it doesn't have one already. */
+    _setMessageId(element) {
+        if (!element.id) {
+            element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;
+        }
+    }
+    /** Deletes the message element from the global messages container. */
+    _deleteMessageElement(message) {
+        const registeredMessage = messageRegistry.get(message);
+        const messageElement = registeredMessage && registeredMessage.messageElement;
+        if (messagesContainer && messageElement) {
+            messagesContainer.removeChild(messageElement);
+        }
+        messageRegistry.delete(message);
+    }
+    /** Creates the global container for all aria-describedby messages. */
+    _createMessagesContainer() {
+        if (!messagesContainer) {
+            // @breaking-change 8.0.0 `_platform` null check can be removed once the parameter is required
+            const canBeAriaHidden = !this._platform || (!this._platform.EDGE && !this._platform.TRIDENT);
+            const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);
+            // When going from the server to the client, we may end up in a situation where there's
+            // already a container on the page, but we don't have a reference to it. Clear the
+            // old container so we don't get duplicates. Doing this, instead of emptying the previous
+            // container, should be slightly faster.
+            if (preExistingContainer) {
+                preExistingContainer.parentNode.removeChild(preExistingContainer);
+            }
+            messagesContainer = this._document.createElement('div');
+            messagesContainer.id = MESSAGES_CONTAINER_ID;
+            messagesContainer.classList.add('cdk-visually-hidden');
+            // IE and Edge won't read out the messages if they're in an `aria-hidden` container.
+            // We only disable `aria-hidden` for these platforms, because it comes with the
+            // disadvantage that people might hit the messages when they've navigated past
+            // the end of the document using the arrow keys.
+            messagesContainer.setAttribute('aria-hidden', canBeAriaHidden + '');
+            this._document.body.appendChild(messagesContainer);
+        }
+    }
+    /** Deletes the global messages container. */
+    _deleteMessagesContainer() {
+        if (messagesContainer && messagesContainer.parentNode) {
+            messagesContainer.parentNode.removeChild(messagesContainer);
+            messagesContainer = null;
+        }
+    }
+    /** Removes all cdk-describedby messages that are hosted through the element. */
+    _removeCdkDescribedByReferenceIds(element) {
+        // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
+        const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
+            .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);
+        element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
+    }
+    /**
+     * Adds a message reference to the element using aria-describedby and increments the registered
+     * message's reference count.
+     */
+    _addMessageReference(element, message) {
+        const registeredMessage = messageRegistry.get(message);
+        // Add the aria-describedby reference and set the
+        // describedby_host attribute to mark the element.
+        addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+        element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
+        registeredMessage.referenceCount++;
+    }
+    /**
+     * Removes a message reference from the element using aria-describedby
+     * and decrements the registered message's reference count.
+     */
+    _removeMessageReference(element, message) {
+        const registeredMessage = messageRegistry.get(message);
+        registeredMessage.referenceCount--;
+        removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+        element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+    }
+    /** Returns true if the element has been described by the provided message ID. */
+    _isElementDescribedByMessage(element, message) {
+        const referenceIds = getAriaReferenceIds(element, 'aria-describedby');
+        const registeredMessage = messageRegistry.get(message);
+        const messageId = registeredMessage && registeredMessage.messageElement.id;
+        return !!messageId && referenceIds.indexOf(messageId) != -1;
+    }
+    /** Determines whether a message can be described on a particular element. */
+    _canBeDescribed(element, message) {
+        if (!this._isElementNode(element)) {
+            return false;
+        }
+        if (message && typeof message === 'object') {
+            // We'd have to make some assumptions about the description element's text, if the consumer
+            // passed in an element. Assume that if an element is passed in, the consumer has verified
+            // that it can be used as a description.
+            return true;
         }
-        /** Determines whether a message can be described on a particular element. */
-        _canBeDescribed(element, message) {
-            if (!this._isElementNode(element)) {
-                return false;
-            }
-            if (message && typeof message === 'object') {
-                // We'd have to make some assumptions about the description element's text, if the consumer
-                // passed in an element. Assume that if an element is passed in, the consumer has verified
-                // that it can be used as a description.
-                return true;
-            }
-            const trimmedMessage = message == null ? '' : `${message}`.trim();
-            const ariaLabel = element.getAttribute('aria-label');
-            // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the
-            // element, because screen readers will end up reading out the same text twice in a row.
-            return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;
-        }
-        /** Checks whether a node is an Element node. */
-        _isElementNode(element) {
-            return element.nodeType === this._document.ELEMENT_NODE;
-        }
-    }
-    AriaDescriber.ɵprov = ɵɵdefineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(ɵɵinject(DOCUMENT)); }, token: AriaDescriber, providedIn: "root" });
-    AriaDescriber.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    AriaDescriber.ctorParameters = () => [
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    return AriaDescriber;
-})();
+        const trimmedMessage = message == null ? '' : `${message}`.trim();
+        const ariaLabel = element.getAttribute('aria-label');
+        // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the
+        // element, because screen readers will end up reading out the same text twice in a row.
+        return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;
+    }
+    /** Checks whether a node is an Element node. */
+    _isElementNode(element) {
+        return element.nodeType === this._document.ELEMENT_NODE;
+    }
+}
+AriaDescriber.ɵprov = ɵɵdefineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(ɵɵinject(DOCUMENT), ɵɵinject(Platform)); }, token: AriaDescriber, providedIn: "root" });
+AriaDescriber.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+AriaDescriber.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: Platform }
+];
 
 /**
  * @license
@@ -274,6 +283,7 @@ class ListKeyManager {
         this._typeaheadSubscription = Subscription.EMPTY;
         this._vertical = true;
         this._allowedModifierKeys = [];
+        this._homeAndEnd = false;
         /**
          * Predicate function that can be used to check whether an item should be skipped
          * by the key manager. By default, disabled items are skipped.
@@ -375,10 +385,18 @@ class ListKeyManager {
         });
         return this;
     }
+    /**
+     * Configures the key manager to focus the first and last items
+     * respectively when the Home key and End Key are pressed.
+     */
+    withHomeAndEnd() {
+        this._homeAndEnd = true;
+        return this;
+    }
     setActiveItem(item) {
-        const previousIndex = this._activeItemIndex;
+        const previousActiveItem = this._activeItem;
         this.updateActiveItem(item);
-        if (this._activeItemIndex !== previousIndex) {
+        if (this._activeItem !== previousActiveItem) {
             this.change.next(this._activeItemIndex);
         }
     }
@@ -428,6 +446,22 @@ class ListKeyManager {
                 else {
                     return;
                 }
+            case HOME:
+                if (this._homeAndEnd && isModifierAllowed) {
+                    this.setFirstItemActive();
+                    break;
+                }
+                else {
+                    return;
+                }
+            case END:
+                if (this._homeAndEnd && isModifierAllowed) {
+                    this.setLastItemActive();
+                    break;
+                }
+                else {
+                    return;
+                }
             default:
                 if (isModifierAllowed || hasModifierKey(event, 'shiftKey')) {
                     // Attempt to use the `event.key` which also maps it to the user's keyboard language,
@@ -593,6 +627,17 @@ class FocusKeyManager extends ListKeyManager {
  * 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
  */
+/**
+ * Configuration for the isFocusable method.
+ */
+class IsFocusableConfig {
+    constructor() {
+        /**
+         * Whether to count an element as focusable even if it is not currently visible.
+         */
+        this.ignoreVisibility = false;
+    }
+}
 // The InteractivityChecker leans heavily on the ally.js accessibility utilities.
 // Methods like `isTabbable` are only covering specific edge-cases for the browsers which are
 // supported.
@@ -600,122 +645,121 @@ class FocusKeyManager extends ListKeyManager {
  * Utility for checking the interactivity of an element, such as whether is is focusable or
  * tabbable.
  */
-let InteractivityChecker = /** @class */ (() => {
-    class InteractivityChecker {
-        constructor(_platform) {
-            this._platform = _platform;
-        }
-        /**
-         * Gets whether an element is disabled.
-         *
-         * @param element Element to be checked.
-         * @returns Whether the element is disabled.
-         */
-        isDisabled(element) {
-            // This does not capture some cases, such as a non-form control with a disabled attribute or
-            // a form control inside of a disabled form, but should capture the most common cases.
-            return element.hasAttribute('disabled');
-        }
-        /**
-         * Gets whether an element is visible for the purposes of interactivity.
-         *
-         * This will capture states like `display: none` and `visibility: hidden`, but not things like
-         * being clipped by an `overflow: hidden` parent or being outside the viewport.
-         *
-         * @returns Whether the element is visible.
-         */
-        isVisible(element) {
-            return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
-        }
-        /**
-         * Gets whether an element can be reached via Tab key.
-         * Assumes that the element has already been checked with isFocusable.
-         *
-         * @param element Element to be checked.
-         * @returns Whether the element is tabbable.
-         */
-        isTabbable(element) {
-            // Nothing is tabbable on the server 😎
-            if (!this._platform.isBrowser) {
+class InteractivityChecker {
+    constructor(_platform) {
+        this._platform = _platform;
+    }
+    /**
+     * Gets whether an element is disabled.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is disabled.
+     */
+    isDisabled(element) {
+        // This does not capture some cases, such as a non-form control with a disabled attribute or
+        // a form control inside of a disabled form, but should capture the most common cases.
+        return element.hasAttribute('disabled');
+    }
+    /**
+     * Gets whether an element is visible for the purposes of interactivity.
+     *
+     * This will capture states like `display: none` and `visibility: hidden`, but not things like
+     * being clipped by an `overflow: hidden` parent or being outside the viewport.
+     *
+     * @returns Whether the element is visible.
+     */
+    isVisible(element) {
+        return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
+    }
+    /**
+     * Gets whether an element can be reached via Tab key.
+     * Assumes that the element has already been checked with isFocusable.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is tabbable.
+     */
+    isTabbable(element) {
+        // Nothing is tabbable on the server 😎
+        if (!this._platform.isBrowser) {
+            return false;
+        }
+        const frameElement = getFrameElement(getWindow(element));
+        if (frameElement) {
+            const frameType = frameElement && frameElement.nodeName.toLowerCase();
+            // Frame elements inherit their tabindex onto all child elements.
+            if (getTabIndexValue(frameElement) === -1) {
                 return false;
             }
-            const frameElement = getFrameElement(getWindow(element));
-            if (frameElement) {
-                const frameType = frameElement && frameElement.nodeName.toLowerCase();
-                // Frame elements inherit their tabindex onto all child elements.
-                if (getTabIndexValue(frameElement) === -1) {
-                    return false;
-                }
-                // Webkit and Blink consider anything inside of an <object> element as non-tabbable.
-                if ((this._platform.BLINK || this._platform.WEBKIT) && frameType === 'object') {
-                    return false;
-                }
-                // Webkit and Blink disable tabbing to an element inside of an invisible frame.
-                if ((this._platform.BLINK || this._platform.WEBKIT) && !this.isVisible(frameElement)) {
-                    return false;
-                }
-            }
-            let nodeName = element.nodeName.toLowerCase();
-            let tabIndexValue = getTabIndexValue(element);
-            if (element.hasAttribute('contenteditable')) {
-                return tabIndexValue !== -1;
+            // Webkit and Blink consider anything inside of an <object> element as non-tabbable.
+            if ((this._platform.BLINK || this._platform.WEBKIT) && frameType === 'object') {
+                return false;
             }
-            if (nodeName === 'iframe') {
-                // The frames may be tabbable depending on content, but it's not possibly to reliably
-                // investigate the content of the frames.
+            // Webkit and Blink disable tabbing to an element inside of an invisible frame.
+            if ((this._platform.BLINK || this._platform.WEBKIT) && !this.isVisible(frameElement)) {
                 return false;
             }
-            if (nodeName === 'audio') {
-                if (!element.hasAttribute('controls')) {
-                    // By default an <audio> element without the controls enabled is not tabbable.
-                    return false;
-                }
-                else if (this._platform.BLINK) {
-                    // In Blink <audio controls> elements are always tabbable.
-                    return true;
-                }
+        }
+        let nodeName = element.nodeName.toLowerCase();
+        let tabIndexValue = getTabIndexValue(element);
+        if (element.hasAttribute('contenteditable')) {
+            return tabIndexValue !== -1;
+        }
+        if (nodeName === 'iframe') {
+            // The frames may be tabbable depending on content, but it's not possibly to reliably
+            // investigate the content of the frames.
+            return false;
+        }
+        if (nodeName === 'audio') {
+            if (!element.hasAttribute('controls')) {
+                // By default an <audio> element without the controls enabled is not tabbable.
+                return false;
             }
-            if (nodeName === 'video') {
-                if (!element.hasAttribute('controls') && this._platform.TRIDENT) {
-                    // In Trident a <video> element without the controls enabled is not tabbable.
-                    return false;
-                }
-                else if (this._platform.BLINK || this._platform.FIREFOX) {
-                    // In Chrome and Firefox <video controls> elements are always tabbable.
-                    return true;
-                }
+            else if (this._platform.BLINK) {
+                // In Blink <audio controls> elements are always tabbable.
+                return true;
             }
-            if (nodeName === 'object' && (this._platform.BLINK || this._platform.WEBKIT)) {
-                // In all Blink and WebKit based browsers <object> elements are never tabbable.
+        }
+        if (nodeName === 'video') {
+            if (!element.hasAttribute('controls') && this._platform.TRIDENT) {
+                // In Trident a <video> element without the controls enabled is not tabbable.
                 return false;
             }
-            // In iOS the browser only considers some specific elements as tabbable.
-            if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {
-                return false;
+            else if (this._platform.BLINK || this._platform.FIREFOX) {
+                // In Chrome and Firefox <video controls> elements are always tabbable.
+                return true;
             }
-            return element.tabIndex >= 0;
         }
-        /**
-         * Gets whether an element can be focused by the user.
-         *
-         * @param element Element to be checked.
-         * @returns Whether the element is focusable.
-         */
-        isFocusable(element) {
-            // Perform checks in order of left to most expensive.
-            // Again, naive approach that does not capture many edge cases and browser quirks.
-            return isPotentiallyFocusable(element) && !this.isDisabled(element) && this.isVisible(element);
-        }
-    }
-    InteractivityChecker.ɵprov = ɵɵdefineInjectable({ factory: function InteractivityChecker_Factory() { return new InteractivityChecker(ɵɵinject(Platform)); }, token: InteractivityChecker, providedIn: "root" });
-    InteractivityChecker.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    InteractivityChecker.ctorParameters = () => [
-        { type: Platform }
-    ];
-    return InteractivityChecker;
-})();
+        if (nodeName === 'object' && (this._platform.BLINK || this._platform.WEBKIT)) {
+            // In all Blink and WebKit based browsers <object> elements are never tabbable.
+            return false;
+        }
+        // In iOS the browser only considers some specific elements as tabbable.
+        if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {
+            return false;
+        }
+        return element.tabIndex >= 0;
+    }
+    /**
+     * Gets whether an element can be focused by the user.
+     *
+     * @param element Element to be checked.
+     * @param config The config object with options to customize this method's behavior
+     * @returns Whether the element is focusable.
+     */
+    isFocusable(element, config) {
+        // Perform checks in order of left to most expensive.
+        // Again, naive approach that does not capture many edge cases and browser quirks.
+        return isPotentiallyFocusable(element) && !this.isDisabled(element) &&
+            ((config === null || config === void 0 ? void 0 : config.ignoreVisibility) || this.isVisible(element));
+    }
+}
+InteractivityChecker.ɵprov = ɵɵdefineInjectable({ factory: function InteractivityChecker_Factory() { return new InteractivityChecker(ɵɵinject(Platform)); }, token: InteractivityChecker, providedIn: "root" });
+InteractivityChecker.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+InteractivityChecker.ctorParameters = () => [
+    { type: Platform }
+];
 /**
  * Returns the frame element from a window object. Since browsers like MS Edge throw errors if
  * the frameElement property is being accessed from a different host address, this property
@@ -871,6 +915,7 @@ class FocusTrap {
             }
         }
         this._startAnchor = this._endAnchor = null;
+        this._hasAttached = false;
     }
     /**
      * Inserts the anchors into the DOM. This is usually done automatically
@@ -1094,94 +1139,98 @@ class FocusTrap {
  * @deprecated Use `ConfigurableFocusTrapFactory` instead.
  * @breaking-change for 11.0.0 Remove this class.
  */
-let FocusTrapFactory = /** @class */ (() => {
-    class FocusTrapFactory {
-        constructor(_checker, _ngZone, _document) {
-            this._checker = _checker;
-            this._ngZone = _ngZone;
-            this._document = _document;
-        }
-        /**
-         * Creates a focus-trapped region around the given element.
-         * @param element The element around which focus will be trapped.
-         * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
-         *     manually by the user.
-         * @returns The created focus trap instance.
-         */
-        create(element, deferCaptureElements = false) {
-            return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
-        }
-    }
-    FocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapFactory_Factory() { return new FocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(DOCUMENT)); }, token: FocusTrapFactory, providedIn: "root" });
-    FocusTrapFactory.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    FocusTrapFactory.ctorParameters = () => [
-        { type: InteractivityChecker },
-        { type: NgZone },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    return FocusTrapFactory;
-})();
+class FocusTrapFactory {
+    constructor(_checker, _ngZone, _document) {
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._document = _document;
+    }
+    /**
+     * Creates a focus-trapped region around the given element.
+     * @param element The element around which focus will be trapped.
+     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
+     *     manually by the user.
+     * @returns The created focus trap instance.
+     */
+    create(element, deferCaptureElements = false) {
+        return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
+    }
+}
+FocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapFactory_Factory() { return new FocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(DOCUMENT)); }, token: FocusTrapFactory, providedIn: "root" });
+FocusTrapFactory.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+FocusTrapFactory.ctorParameters = () => [
+    { type: InteractivityChecker },
+    { type: NgZone },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
 /** Directive for trapping focus within a region. */
-let CdkTrapFocus = /** @class */ (() => {
-    class CdkTrapFocus {
-        constructor(_elementRef, _focusTrapFactory, _document) {
-            this._elementRef = _elementRef;
-            this._focusTrapFactory = _focusTrapFactory;
-            /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+class CdkTrapFocus {
+    constructor(_elementRef, _focusTrapFactory, _document) {
+        this._elementRef = _elementRef;
+        this._focusTrapFactory = _focusTrapFactory;
+        /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+        this._previouslyFocusedElement = null;
+        this._document = _document;
+        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+    }
+    /** Whether the focus trap is active. */
+    get enabled() { return this.focusTrap.enabled; }
+    set enabled(value) { this.focusTrap.enabled = coerceBooleanProperty(value); }
+    /**
+     * Whether the directive should automatially move focus into the trapped region upon
+     * initialization and return focus to the previous activeElement upon destruction.
+     */
+    get autoCapture() { return this._autoCapture; }
+    set autoCapture(value) { this._autoCapture = coerceBooleanProperty(value); }
+    ngOnDestroy() {
+        this.focusTrap.destroy();
+        // If we stored a previously focused element when using autoCapture, return focus to that
+        // element now that the trapped region is being destroyed.
+        if (this._previouslyFocusedElement) {
+            this._previouslyFocusedElement.focus();
             this._previouslyFocusedElement = null;
-            this._document = _document;
-            this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
         }
-        /** Whether the focus trap is active. */
-        get enabled() { return this.focusTrap.enabled; }
-        set enabled(value) { this.focusTrap.enabled = coerceBooleanProperty(value); }
-        /**
-         * Whether the directive should automatially move focus into the trapped region upon
-         * initialization and return focus to the previous activeElement upon destruction.
-         */
-        get autoCapture() { return this._autoCapture; }
-        set autoCapture(value) { this._autoCapture = coerceBooleanProperty(value); }
-        ngOnDestroy() {
-            this.focusTrap.destroy();
-            // If we stored a previously focused element when using autoCapture, return focus to that
-            // element now that the trapped region is being destroyed.
-            if (this._previouslyFocusedElement) {
-                this._previouslyFocusedElement.focus();
-                this._previouslyFocusedElement = null;
-            }
+    }
+    ngAfterContentInit() {
+        this.focusTrap.attachAnchors();
+        if (this.autoCapture) {
+            this._captureFocus();
         }
-        ngAfterContentInit() {
+    }
+    ngDoCheck() {
+        if (!this.focusTrap.hasAttached()) {
             this.focusTrap.attachAnchors();
-            if (this.autoCapture) {
-                this._previouslyFocusedElement = this._document.activeElement;
-                this.focusTrap.focusInitialElementWhenReady();
-            }
         }
-        ngDoCheck() {
-            if (!this.focusTrap.hasAttached()) {
-                this.focusTrap.attachAnchors();
-            }
+    }
+    ngOnChanges(changes) {
+        const autoCaptureChange = changes['autoCapture'];
+        if (autoCaptureChange && !autoCaptureChange.firstChange && this.autoCapture &&
+            this.focusTrap.hasAttached()) {
+            this._captureFocus();
         }
     }
-    CdkTrapFocus.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkTrapFocus]',
-                    exportAs: 'cdkTrapFocus',
-                },] }
-    ];
-    CdkTrapFocus.ctorParameters = () => [
-        { type: ElementRef },
-        { type: FocusTrapFactory },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    CdkTrapFocus.propDecorators = {
-        enabled: [{ type: Input, args: ['cdkTrapFocus',] }],
-        autoCapture: [{ type: Input, args: ['cdkTrapFocusAutoCapture',] }]
-    };
-    return CdkTrapFocus;
-})();
+    _captureFocus() {
+        this._previouslyFocusedElement = this._document.activeElement;
+        this.focusTrap.focusInitialElementWhenReady();
+    }
+}
+CdkTrapFocus.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkTrapFocus]',
+                exportAs: 'cdkTrapFocus',
+            },] }
+];
+CdkTrapFocus.ctorParameters = () => [
+    { type: ElementRef },
+    { type: FocusTrapFactory },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+CdkTrapFocus.propDecorators = {
+    enabled: [{ type: Input, args: ['cdkTrapFocus',] }],
+    autoCapture: [{ type: Input, args: ['cdkTrapFocusAutoCapture',] }]
+};
 
 /**
  * @license
@@ -1366,49 +1415,46 @@ const FOCUS_TRAP_INERT_STRATEGY = new InjectionToken('FOCUS_TRAP_INERT_STRATEGY'
  * found in the LICENSE file at https://angular.io/license
  */
 /** Injectable that ensures only the most recently enabled FocusTrap is active. */
-let FocusTrapManager = /** @class */ (() => {
-    class FocusTrapManager {
-        constructor() {
-            // A stack of the FocusTraps on the page. Only the FocusTrap at the
-            // top of the stack is active.
-            this._focusTrapStack = [];
+class FocusTrapManager {
+    constructor() {
+        // A stack of the FocusTraps on the page. Only the FocusTrap at the
+        // top of the stack is active.
+        this._focusTrapStack = [];
+    }
+    /**
+     * Disables the FocusTrap at the top of the stack, and then pushes
+     * the new FocusTrap onto the stack.
+     */
+    register(focusTrap) {
+        // Dedupe focusTraps that register multiple times.
+        this._focusTrapStack = this._focusTrapStack.filter((ft) => ft !== focusTrap);
+        let stack = this._focusTrapStack;
+        if (stack.length) {
+            stack[stack.length - 1]._disable();
         }
-        /**
-         * Disables the FocusTrap at the top of the stack, and then pushes
-         * the new FocusTrap onto the stack.
-         */
-        register(focusTrap) {
-            // Dedupe focusTraps that register multiple times.
-            this._focusTrapStack = this._focusTrapStack.filter((ft) => ft !== focusTrap);
-            let stack = this._focusTrapStack;
+        stack.push(focusTrap);
+        focusTrap._enable();
+    }
+    /**
+     * Removes the FocusTrap from the stack, and activates the
+     * FocusTrap that is the new top of the stack.
+     */
+    deregister(focusTrap) {
+        focusTrap._disable();
+        const stack = this._focusTrapStack;
+        const i = stack.indexOf(focusTrap);
+        if (i !== -1) {
+            stack.splice(i, 1);
             if (stack.length) {
-                stack[stack.length - 1]._disable();
-            }
-            stack.push(focusTrap);
-            focusTrap._enable();
-        }
-        /**
-         * Removes the FocusTrap from the stack, and activates the
-         * FocusTrap that is the new top of the stack.
-         */
-        deregister(focusTrap) {
-            focusTrap._disable();
-            const stack = this._focusTrapStack;
-            const i = stack.indexOf(focusTrap);
-            if (i !== -1) {
-                stack.splice(i, 1);
-                if (stack.length) {
-                    stack[stack.length - 1]._enable();
-                }
+                stack[stack.length - 1]._enable();
             }
         }
     }
-    FocusTrapManager.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapManager_Factory() { return new FocusTrapManager(); }, token: FocusTrapManager, providedIn: "root" });
-    FocusTrapManager.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    return FocusTrapManager;
-})();
+}
+FocusTrapManager.ɵprov = ɵɵdefineInjectable({ factory: function FocusTrapManager_Factory() { return new FocusTrapManager(); }, token: FocusTrapManager, providedIn: "root" });
+FocusTrapManager.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
 
 /**
  * @license
@@ -1418,41 +1464,38 @@ let FocusTrapManager = /** @class */ (() => {
  * found in the LICENSE file at https://angular.io/license
  */
 /** Factory that allows easy instantiation of configurable focus traps. */
-let ConfigurableFocusTrapFactory = /** @class */ (() => {
-    class ConfigurableFocusTrapFactory {
-        constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {
-            this._checker = _checker;
-            this._ngZone = _ngZone;
-            this._focusTrapManager = _focusTrapManager;
-            this._document = _document;
-            // TODO split up the strategies into different modules, similar to DateAdapter.
-            this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();
-        }
-        create(element, config = new ConfigurableFocusTrapConfig()) {
-            let configObject;
-            if (typeof config === 'boolean') {
-                configObject = new ConfigurableFocusTrapConfig();
-                configObject.defer = config;
-            }
-            else {
-                configObject = config;
-            }
-            return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);
-        }
-    }
-    ConfigurableFocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function ConfigurableFocusTrapFactory_Factory() { return new ConfigurableFocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(FocusTrapManager), ɵɵinject(DOCUMENT), ɵɵinject(FOCUS_TRAP_INERT_STRATEGY, 8)); }, token: ConfigurableFocusTrapFactory, providedIn: "root" });
-    ConfigurableFocusTrapFactory.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    ConfigurableFocusTrapFactory.ctorParameters = () => [
-        { type: InteractivityChecker },
-        { type: NgZone },
-        { type: FocusTrapManager },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_TRAP_INERT_STRATEGY,] }] }
-    ];
-    return ConfigurableFocusTrapFactory;
-})();
+class ConfigurableFocusTrapFactory {
+    constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._focusTrapManager = _focusTrapManager;
+        this._document = _document;
+        // TODO split up the strategies into different modules, similar to DateAdapter.
+        this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();
+    }
+    create(element, config = new ConfigurableFocusTrapConfig()) {
+        let configObject;
+        if (typeof config === 'boolean') {
+            configObject = new ConfigurableFocusTrapConfig();
+            configObject.defer = config;
+        }
+        else {
+            configObject = config;
+        }
+        return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);
+    }
+}
+ConfigurableFocusTrapFactory.ɵprov = ɵɵdefineInjectable({ factory: function ConfigurableFocusTrapFactory_Factory() { return new ConfigurableFocusTrapFactory(ɵɵinject(InteractivityChecker), ɵɵinject(NgZone), ɵɵinject(FocusTrapManager), ɵɵinject(DOCUMENT), ɵɵinject(FOCUS_TRAP_INERT_STRATEGY, 8)); }, token: ConfigurableFocusTrapFactory, providedIn: "root" });
+ConfigurableFocusTrapFactory.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+ConfigurableFocusTrapFactory.ctorParameters = () => [
+    { type: InteractivityChecker },
+    { type: NgZone },
+    { type: FocusTrapManager },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_TRAP_INERT_STRATEGY,] }] }
+];
 
 /**
  * @license
@@ -1479,164 +1522,158 @@ const LIVE_ANNOUNCER_DEFAULT_OPTIONS = new InjectionToken('LIVE_ANNOUNCER_DEFAUL
  * 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
  */
-let LiveAnnouncer = /** @class */ (() => {
-    class LiveAnnouncer {
-        constructor(elementToken, _ngZone, _document, _defaultOptions) {
-            this._ngZone = _ngZone;
-            this._defaultOptions = _defaultOptions;
-            // We inject the live element and document as `any` because the constructor signature cannot
-            // reference browser globals (HTMLElement, Document) on non-browser environments, since having
-            // a class decorator causes TypeScript to preserve the constructor signature types.
-            this._document = _document;
-            this._liveElement = elementToken || this._createLiveElement();
-        }
-        announce(message, ...args) {
-            const defaultOptions = this._defaultOptions;
-            let politeness;
-            let duration;
-            if (args.length === 1 && typeof args[0] === 'number') {
-                duration = args[0];
-            }
-            else {
-                [politeness, duration] = args;
-            }
-            this.clear();
-            clearTimeout(this._previousTimeout);
-            if (!politeness) {
-                politeness =
-                    (defaultOptions && defaultOptions.politeness) ? defaultOptions.politeness : 'polite';
-            }
-            if (duration == null && defaultOptions) {
-                duration = defaultOptions.duration;
-            }
-            // TODO: ensure changing the politeness works on all environments we support.
-            this._liveElement.setAttribute('aria-live', politeness);
-            // This 100ms timeout is necessary for some browser + screen-reader combinations:
-            // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
-            // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
-            //   second time without clearing and then using a non-zero delay.
-            // (using JAWS 17 at time of this writing).
-            return this._ngZone.runOutsideAngular(() => {
-                return new Promise(resolve => {
-                    clearTimeout(this._previousTimeout);
-                    this._previousTimeout = setTimeout(() => {
-                        this._liveElement.textContent = message;
-                        resolve();
-                        if (typeof duration === 'number') {
-                            this._previousTimeout = setTimeout(() => this.clear(), duration);
-                        }
-                    }, 100);
-                });
+class LiveAnnouncer {
+    constructor(elementToken, _ngZone, _document, _defaultOptions) {
+        this._ngZone = _ngZone;
+        this._defaultOptions = _defaultOptions;
+        // We inject the live element and document as `any` because the constructor signature cannot
+        // reference browser globals (HTMLElement, Document) on non-browser environments, since having
+        // a class decorator causes TypeScript to preserve the constructor signature types.
+        this._document = _document;
+        this._liveElement = elementToken || this._createLiveElement();
+    }
+    announce(message, ...args) {
+        const defaultOptions = this._defaultOptions;
+        let politeness;
+        let duration;
+        if (args.length === 1 && typeof args[0] === 'number') {
+            duration = args[0];
+        }
+        else {
+            [politeness, duration] = args;
+        }
+        this.clear();
+        clearTimeout(this._previousTimeout);
+        if (!politeness) {
+            politeness =
+                (defaultOptions && defaultOptions.politeness) ? defaultOptions.politeness : 'polite';
+        }
+        if (duration == null && defaultOptions) {
+            duration = defaultOptions.duration;
+        }
+        // TODO: ensure changing the politeness works on all environments we support.
+        this._liveElement.setAttribute('aria-live', politeness);
+        // This 100ms timeout is necessary for some browser + screen-reader combinations:
+        // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
+        // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
+        //   second time without clearing and then using a non-zero delay.
+        // (using JAWS 17 at time of this writing).
+        return this._ngZone.runOutsideAngular(() => {
+            return new Promise(resolve => {
+                clearTimeout(this._previousTimeout);
+                this._previousTimeout = setTimeout(() => {
+                    this._liveElement.textContent = message;
+                    resolve();
+                    if (typeof duration === 'number') {
+                        this._previousTimeout = setTimeout(() => this.clear(), duration);
+                    }
+                }, 100);
             });
+        });
+    }
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear() {
+        if (this._liveElement) {
+            this._liveElement.textContent = '';
         }
-        /**
-         * Clears the current text from the announcer element. Can be used to prevent
-         * screen readers from reading the text out again while the user is going
-         * through the page landmarks.
-         */
-        clear() {
-            if (this._liveElement) {
-                this._liveElement.textContent = '';
-            }
+    }
+    ngOnDestroy() {
+        clearTimeout(this._previousTimeout);
+        if (this._liveElement && this._liveElement.parentNode) {
+            this._liveElement.parentNode.removeChild(this._liveElement);
+            this._liveElement = null;
         }
-        ngOnDestroy() {
-            clearTimeout(this._previousTimeout);
-            if (this._liveElement && this._liveElement.parentNode) {
-                this._liveElement.parentNode.removeChild(this._liveElement);
-                this._liveElement = null;
-            }
+    }
+    _createLiveElement() {
+        const elementClass = 'cdk-live-announcer-element';
+        const previousElements = this._document.getElementsByClassName(elementClass);
+        const liveEl = this._document.createElement('div');
+        // Remove any old containers. This can happen when coming in from a server-side-rendered page.
+        for (let i = 0; i < previousElements.length; i++) {
+            previousElements[i].parentNode.removeChild(previousElements[i]);
         }
-        _createLiveElement() {
-            const elementClass = 'cdk-live-announcer-element';
-            const previousElements = this._document.getElementsByClassName(elementClass);
-            const liveEl = this._document.createElement('div');
-            // Remove any old containers. This can happen when coming in from a server-side-rendered page.
-            for (let i = 0; i < previousElements.length; i++) {
-                previousElements[i].parentNode.removeChild(previousElements[i]);
-            }
-            liveEl.classList.add(elementClass);
-            liveEl.classList.add('cdk-visually-hidden');
-            liveEl.setAttribute('aria-atomic', 'true');
-            liveEl.setAttribute('aria-live', 'polite');
-            this._document.body.appendChild(liveEl);
-            return liveEl;
-        }
-    }
-    LiveAnnouncer.ɵprov = ɵɵdefineInjectable({ factory: function LiveAnnouncer_Factory() { return new LiveAnnouncer(ɵɵinject(LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), ɵɵinject(NgZone), ɵɵinject(DOCUMENT), ɵɵinject(LIVE_ANNOUNCER_DEFAULT_OPTIONS, 8)); }, token: LiveAnnouncer, providedIn: "root" });
-    LiveAnnouncer.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    LiveAnnouncer.ctorParameters = () => [
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] }] },
-        { type: NgZone },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS,] }] }
-    ];
-    return LiveAnnouncer;
-})();
+        liveEl.classList.add(elementClass);
+        liveEl.classList.add('cdk-visually-hidden');
+        liveEl.setAttribute('aria-atomic', 'true');
+        liveEl.setAttribute('aria-live', 'polite');
+        this._document.body.appendChild(liveEl);
+        return liveEl;
+    }
+}
+LiveAnnouncer.ɵprov = ɵɵdefineInjectable({ factory: function LiveAnnouncer_Factory() { return new LiveAnnouncer(ɵɵinject(LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), ɵɵinject(NgZone), ɵɵinject(DOCUMENT), ɵɵinject(LIVE_ANNOUNCER_DEFAULT_OPTIONS, 8)); }, token: LiveAnnouncer, providedIn: "root" });
+LiveAnnouncer.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+LiveAnnouncer.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] }] },
+    { type: NgZone },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_DEFAULT_OPTIONS,] }] }
+];
 /**
  * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
  * with a wider range of browsers and screen readers.
  */
-let CdkAriaLive = /** @class */ (() => {
-    class CdkAriaLive {
-        constructor(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {
-            this._elementRef = _elementRef;
-            this._liveAnnouncer = _liveAnnouncer;
-            this._contentObserver = _contentObserver;
-            this._ngZone = _ngZone;
-            this._politeness = 'off';
-        }
-        /** The aria-live politeness level to use when announcing messages. */
-        get politeness() { return this._politeness; }
-        set politeness(value) {
-            this._politeness = value === 'polite' || value === 'assertive' ? value : 'off';
-            if (this._politeness === 'off') {
-                if (this._subscription) {
-                    this._subscription.unsubscribe();
-                    this._subscription = null;
-                }
-            }
-            else if (!this._subscription) {
-                this._subscription = this._ngZone.runOutsideAngular(() => {
-                    return this._contentObserver
-                        .observe(this._elementRef)
-                        .subscribe(() => {
-                        // Note that we use textContent here, rather than innerText, in order to avoid a reflow.
-                        const elementText = this._elementRef.nativeElement.textContent;
-                        // The `MutationObserver` fires also for attribute
-                        // changes which we don't want to announce.
-                        if (elementText !== this._previousAnnouncedText) {
-                            this._liveAnnouncer.announce(elementText, this._politeness);
-                            this._previousAnnouncedText = elementText;
-                        }
-                    });
-                });
-            }
-        }
-        ngOnDestroy() {
+class CdkAriaLive {
+    constructor(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {
+        this._elementRef = _elementRef;
+        this._liveAnnouncer = _liveAnnouncer;
+        this._contentObserver = _contentObserver;
+        this._ngZone = _ngZone;
+        this._politeness = 'off';
+    }
+    /** The aria-live politeness level to use when announcing messages. */
+    get politeness() { return this._politeness; }
+    set politeness(value) {
+        this._politeness = value === 'polite' || value === 'assertive' ? value : 'off';
+        if (this._politeness === 'off') {
             if (this._subscription) {
                 this._subscription.unsubscribe();
-            }
+                this._subscription = null;
+            }
+        }
+        else if (!this._subscription) {
+            this._subscription = this._ngZone.runOutsideAngular(() => {
+                return this._contentObserver
+                    .observe(this._elementRef)
+                    .subscribe(() => {
+                    // Note that we use textContent here, rather than innerText, in order to avoid a reflow.
+                    const elementText = this._elementRef.nativeElement.textContent;
+                    // The `MutationObserver` fires also for attribute
+                    // changes which we don't want to announce.
+                    if (elementText !== this._previousAnnouncedText) {
+                        this._liveAnnouncer.announce(elementText, this._politeness);
+                        this._previousAnnouncedText = elementText;
+                    }
+                });
+            });
         }
     }
-    CdkAriaLive.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkAriaLive]',
-                    exportAs: 'cdkAriaLive',
-                },] }
-    ];
-    CdkAriaLive.ctorParameters = () => [
-        { type: ElementRef },
-        { type: LiveAnnouncer },
-        { type: ContentObserver },
-        { type: NgZone }
-    ];
-    CdkAriaLive.propDecorators = {
-        politeness: [{ type: Input, args: ['cdkAriaLive',] }]
-    };
-    return CdkAriaLive;
-})();
+    ngOnDestroy() {
+        if (this._subscription) {
+            this._subscription.unsubscribe();
+        }
+    }
+}
+CdkAriaLive.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkAriaLive]',
+                exportAs: 'cdkAriaLive',
+            },] }
+];
+CdkAriaLive.ctorParameters = () => [
+    { type: ElementRef },
+    { type: LiveAnnouncer },
+    { type: ContentObserver },
+    { type: NgZone }
+];
+CdkAriaLive.propDecorators = {
+    politeness: [{ type: Input, args: ['cdkAriaLive',] }]
+};
 
 /**
  * @license
@@ -1677,342 +1714,339 @@ const captureEventListenerOptions = normalizePassiveListenerOptions({
     capture: true
 });
 /** Monitors mouse and keyboard events to determine the cause of focus events. */
-let FocusMonitor = /** @class */ (() => {
-    class FocusMonitor {
-        constructor(_ngZone, _platform, 
-        /** @breaking-change 11.0.0 make document required */
-        document, options) {
-            this._ngZone = _ngZone;
-            this._platform = _platform;
-            /** The focus origin that the next focus event is a result of. */
-            this._origin = null;
-            /** Whether the window has just been focused. */
-            this._windowFocused = false;
-            /** Map of elements being monitored to their info. */
-            this._elementInfo = new Map();
-            /** The number of elements currently being monitored. */
-            this._monitoredElementCount = 0;
-            /**
-             * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
-             * as well as the number of monitored elements that they contain. We have to treat focus/blur
-             * handlers differently from the rest of the events, because the browser won't emit events
-             * to the document when focus moves inside of a shadow root.
-             */
-            this._rootNodeFocusListenerCount = new Map();
-            /**
-             * Event listener for `keydown` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentKeydownListener = () => {
-                // On keydown record the origin and clear any touch event that may be in progress.
-                this._lastTouchTarget = null;
-                this._setOriginForCurrentEventQueue('keyboard');
-            };
-            /**
-             * Event listener for `mousedown` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentMousedownListener = (event) => {
-                // On mousedown record the origin only if there is not touch
-                // target, since a mousedown can happen as a result of a touch event.
-                if (!this._lastTouchTarget) {
-                    // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
-                    // Resolve the focus source to `keyboard` if we detect one of them.
-                    const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
-                    this._setOriginForCurrentEventQueue(source);
-                }
-            };
-            /**
-             * Event listener for `touchstart` events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._documentTouchstartListener = (event) => {
-                // When the touchstart event fires the focus event is not yet in the event queue. This means
-                // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to
-                // see if a focus happens.
-                if (this._touchTimeoutId != null) {
-                    clearTimeout(this._touchTimeoutId);
-                }
-                this._lastTouchTarget = getTarget(event);
-                this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);
-            };
-            /**
-             * Event listener for `focus` events on the window.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._windowFocusListener = () => {
-                // Make a note of when the window regains focus, so we can
-                // restore the origin info for the focused element.
-                this._windowFocused = true;
-                this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);
-            };
-            /**
-             * Event listener for `focus` and 'blur' events on the document.
-             * Needs to be an arrow function in order to preserve the context when it gets bound.
-             */
-            this._rootNodeFocusAndBlurListener = (event) => {
-                const target = getTarget(event);
-                const handler = event.type === 'focus' ? this._onFocus : this._onBlur;
-                // We need to walk up the ancestor chain in order to support `checkChildren`.
-                for (let element = target; element; element = element.parentElement) {
-                    handler.call(this, event, element);
-                }
-            };
-            this._document = document;
-            this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
-        }
-        monitor(element, checkChildren = false) {
-            // Do nothing if we're not on the browser platform.
-            if (!this._platform.isBrowser) {
-                return of(null);
-            }
-            const nativeElement = coerceElement(element);
-            // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
-            // the shadow root, rather than the `document`, because the browser won't emit focus events
-            // to the `document`, if focus is moving within the same shadow root.
-            const rootNode = _getShadowRoot(nativeElement) || this._getDocument();
-            const cachedInfo = this._elementInfo.get(nativeElement);
-            // Check if we're already monitoring this element.
-            if (cachedInfo) {
-                if (checkChildren) {
-                    // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
-                    // observers into ones that behave as if `checkChildren` was turned on. We need a more
-                    // robust solution.
-                    cachedInfo.checkChildren = true;
-                }
-                return cachedInfo.subject.asObservable();
-            }
-            // Create monitored element info.
-            const info = {
-                checkChildren: checkChildren,
-                subject: new Subject(),
-                rootNode
-            };
-            this._elementInfo.set(nativeElement, info);
-            this._registerGlobalListeners(info);
-            return info.subject.asObservable();
-        }
-        stopMonitoring(element) {
-            const nativeElement = coerceElement(element);
-            const elementInfo = this._elementInfo.get(nativeElement);
-            if (elementInfo) {
-                elementInfo.subject.complete();
-                this._setClasses(nativeElement);
-                this._elementInfo.delete(nativeElement);
-                this._removeGlobalListeners(elementInfo);
-            }
-        }
-        focusVia(element, origin, options) {
-            const nativeElement = coerceElement(element);
-            this._setOriginForCurrentEventQueue(origin);
-            // `focus` isn't available on the server
-            if (typeof nativeElement.focus === 'function') {
-                // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.
-                nativeElement.focus(options);
-            }
-        }
-        ngOnDestroy() {
-            this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
-        }
-        /** Access injected document if available or fallback to global document reference */
-        _getDocument() {
-            return this._document || document;
-        }
-        /** Use defaultView of injected document if available or fallback to global window reference */
-        _getWindow() {
-            const doc = this._getDocument();
-            return doc.defaultView || window;
-        }
-        _toggleClass(element, className, shouldSet) {
-            if (shouldSet) {
-                element.classList.add(className);
-            }
-            else {
-                element.classList.remove(className);
-            }
-        }
-        _getFocusOrigin(event) {
-            // If we couldn't detect a cause for the focus event, it's due to one of three reasons:
-            // 1) The window has just regained focus, in which case we want to restore the focused state of
-            //    the element from before the window blurred.
-            // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.
-            // 3) The element was programmatically focused, in which case we should mark the origin as
-            //    'program'.
-            if (this._origin) {
-                return this._origin;
-            }
-            if (this._windowFocused && this._lastFocusOrigin) {
-                return this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                return 'touch';
-            }
-            else {
-                return 'program';
-            }
-        }
+class FocusMonitor {
+    constructor(_ngZone, _platform, 
+    /** @breaking-change 11.0.0 make document required */
+    document, options) {
+        this._ngZone = _ngZone;
+        this._platform = _platform;
+        /** The focus origin that the next focus event is a result of. */
+        this._origin = null;
+        /** Whether the window has just been focused. */
+        this._windowFocused = false;
+        /** Map of elements being monitored to their info. */
+        this._elementInfo = new Map();
+        /** The number of elements currently being monitored. */
+        this._monitoredElementCount = 0;
         /**
-         * Sets the focus classes on the element based on the given focus origin.
-         * @param element The element to update the classes on.
-         * @param origin The focus origin.
+         * 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.
          */
-        _setClasses(element, origin) {
-            this._toggleClass(element, 'cdk-focused', !!origin);
-            this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');
-            this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');
-            this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');
-            this._toggleClass(element, 'cdk-program-focused', origin === 'program');
-        }
+        this._rootNodeFocusListenerCount = new Map();
         /**
-         * Sets the origin and schedules an async function to clear it at the end of the event queue.
-         * If the detection mode is 'eventual', the origin is never cleared.
-         * @param origin The origin to set.
+         * Event listener for `keydown` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
-        _setOriginForCurrentEventQueue(origin) {
-            this._ngZone.runOutsideAngular(() => {
-                this._origin = origin;
-                if (this._detectionMode === 0 /* IMMEDIATE */) {
-                    // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
-                    // tick after the interaction event fired. To ensure the focus origin is always correct,
-                    // the focus origin will be determined at the beginning of the next tick.
-                    this._originTimeoutId = setTimeout(() => this._origin = null, 1);
-                }
-            });
-        }
+        this._documentKeydownListener = () => {
+            // On keydown record the origin and clear any touch event that may be in progress.
+            this._lastTouchTarget = null;
+            this._setOriginForCurrentEventQueue('keyboard');
+        };
         /**
-         * 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.
+         * Event listener for `mousedown` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
-        _wasCausedByTouch(event) {
-            // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
-            // Consider the following dom structure:
-            //
-            // <div #parent tabindex="0" cdkFocusClasses>
-            //   <div #child (click)="#parent.focus()"></div>
-            // </div>
-            //
-            // If the user touches the #child element and the #parent is programmatically focused as a
-            // result, this code will still consider it to have been caused by the touch event and will
-            // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
-            // relatively small edge-case that can be worked around by using
-            // focusVia(parentEl, 'program') to focus the parent element.
-            //
-            // If we decide that we absolutely must handle this case correctly, we can do so by listening
-            // for the first focus event after the touchstart, and then the first blur event after that
-            // focus event. When that blur event fires we know that whatever follows is not a result of the
-            // touchstart.
-            const focusTarget = getTarget(event);
-            return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
-                (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
-        }
+        this._documentMousedownListener = (event) => {
+            // On mousedown record the origin only if there is not touch
+            // target, since a mousedown can happen as a result of a touch event.
+            if (!this._lastTouchTarget) {
+                // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
+                // Resolve the focus source to `keyboard` if we detect one of them.
+                const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
+                this._setOriginForCurrentEventQueue(source);
+            }
+        };
         /**
-         * Handles focus events on a registered element.
-         * @param event The focus event.
-         * @param element The monitored element.
+         * Event listener for `touchstart` events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
-        _onFocus(event, element) {
-            // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
-            // focus event affecting the monitored element. If we want to use the origin of the first event
-            // instead we should check for the cdk-focused class here and return if the element already has
-            // it. (This only matters for elements that have includesChildren = true).
-            // If we are not counting child-element-focus as focused, make sure that the event target is the
-            // monitored element itself.
-            const elementInfo = this._elementInfo.get(element);
-            if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
-                return;
+        this._documentTouchstartListener = (event) => {
+            // When the touchstart event fires the focus event is not yet in the event queue. This means
+            // we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to
+            // see if a focus happens.
+            if (this._touchTimeoutId != null) {
+                clearTimeout(this._touchTimeoutId);
             }
-            const origin = this._getFocusOrigin(event);
-            this._setClasses(element, origin);
-            this._emitOrigin(elementInfo.subject, origin);
-            this._lastFocusOrigin = origin;
-        }
+            this._lastTouchTarget = getTarget(event);
+            this._touchTimeoutId = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);
+        };
         /**
-         * Handles blur events on a registered element.
-         * @param event The blur event.
-         * @param element The monitored element.
+         * Event listener for `focus` events on the window.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
-        _onBlur(event, element) {
-            // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
-            // order to focus another child of the monitored element.
-            const elementInfo = this._elementInfo.get(element);
-            if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
-                element.contains(event.relatedTarget))) {
-                return;
-            }
-            this._setClasses(element);
-            this._emitOrigin(elementInfo.subject, null);
+        this._windowFocusListener = () => {
+            // Make a note of when the window regains focus, so we can
+            // restore the origin info for the focused element.
+            this._windowFocused = true;
+            this._windowFocusTimeoutId = setTimeout(() => this._windowFocused = false);
+        };
+        /**
+         * Event listener for `focus` and 'blur' events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._rootNodeFocusAndBlurListener = (event) => {
+            const target = getTarget(event);
+            const handler = event.type === 'focus' ? this._onFocus : this._onBlur;
+            // We need to walk up the ancestor chain in order to support `checkChildren`.
+            for (let element = target; element; element = element.parentElement) {
+                handler.call(this, event, element);
+            }
+        };
+        this._document = document;
+        this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
+    }
+    monitor(element, checkChildren = false) {
+        // Do nothing if we're not on the browser platform.
+        if (!this._platform.isBrowser) {
+            return of(null);
+        }
+        const nativeElement = coerceElement(element);
+        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
+        // the shadow root, rather than the `document`, because the browser won't emit focus events
+        // to the `document`, if focus is moving within the same shadow root.
+        const rootNode = _getShadowRoot(nativeElement) || this._getDocument();
+        const cachedInfo = this._elementInfo.get(nativeElement);
+        // Check if we're already monitoring this element.
+        if (cachedInfo) {
+            if (checkChildren) {
+                // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
+                // observers into ones that behave as if `checkChildren` was turned on. We need a more
+                // robust solution.
+                cachedInfo.checkChildren = true;
+            }
+            return cachedInfo.subject.asObservable();
+        }
+        // Create monitored element info.
+        const info = {
+            checkChildren: checkChildren,
+            subject: new Subject(),
+            rootNode
+        };
+        this._elementInfo.set(nativeElement, info);
+        this._registerGlobalListeners(info);
+        return info.subject.asObservable();
+    }
+    stopMonitoring(element) {
+        const nativeElement = coerceElement(element);
+        const elementInfo = this._elementInfo.get(nativeElement);
+        if (elementInfo) {
+            elementInfo.subject.complete();
+            this._setClasses(nativeElement);
+            this._elementInfo.delete(nativeElement);
+            this._removeGlobalListeners(elementInfo);
+        }
+    }
+    focusVia(element, origin, options) {
+        const nativeElement = coerceElement(element);
+        this._setOriginForCurrentEventQueue(origin);
+        // `focus` isn't available on the server
+        if (typeof nativeElement.focus === 'function') {
+            // Cast the element to `any`, because the TS typings don't have the `options` parameter yet.
+            nativeElement.focus(options);
+        }
+    }
+    ngOnDestroy() {
+        this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
+    }
+    /** Access injected document if available or fallback to global document reference */
+    _getDocument() {
+        return this._document || document;
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        const doc = this._getDocument();
+        return doc.defaultView || window;
+    }
+    _toggleClass(element, className, shouldSet) {
+        if (shouldSet) {
+            element.classList.add(className);
         }
-        _emitOrigin(subject, origin) {
-            this._ngZone.run(() => subject.next(origin));
+        else {
+            element.classList.remove(className);
         }
-        _registerGlobalListeners(elementInfo) {
-            if (!this._platform.isBrowser) {
-                return;
-            }
-            const rootNode = elementInfo.rootNode;
-            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
-            if (!rootNodeFocusListeners) {
-                this._ngZone.runOutsideAngular(() => {
-                    rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                });
-            }
-            this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
-            // Register global listeners when first element is monitored.
-            if (++this._monitoredElementCount === 1) {
-                // Note: we listen to events in the capture phase so we
-                // can detect them even if the user stops propagation.
-                this._ngZone.runOutsideAngular(() => {
-                    const document = this._getDocument();
-                    const window = this._getWindow();
-                    document.addEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
-                    document.addEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
-                    document.addEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
-                    window.addEventListener('focus', this._windowFocusListener);
-                });
-            }
+    }
+    _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;
         }
-        _removeGlobalListeners(elementInfo) {
-            const rootNode = elementInfo.rootNode;
-            if (this._rootNodeFocusListenerCount.has(rootNode)) {
-                const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
-                if (rootNodeFocusListeners > 1) {
-                    this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
-                }
-                else {
-                    rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
-                    this._rootNodeFocusListenerCount.delete(rootNode);
-                }
+        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.
+     * @param element The element to update the classes on.
+     * @param origin The focus origin.
+     */
+    _setClasses(element, origin) {
+        this._toggleClass(element, 'cdk-focused', !!origin);
+        this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');
+        this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');
+        this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');
+        this._toggleClass(element, 'cdk-program-focused', origin === 'program');
+    }
+    /**
+     * Sets the origin and schedules an async function to clear it at the end of the event queue.
+     * If the detection mode is 'eventual', the origin is never cleared.
+     * @param origin The origin to set.
+     */
+    _setOriginForCurrentEventQueue(origin) {
+        this._ngZone.runOutsideAngular(() => {
+            this._origin = origin;
+            if (this._detectionMode === 0 /* IMMEDIATE */) {
+                // Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
+                // tick after the interaction event fired. To ensure the focus origin is always correct,
+                // the focus origin will be determined at the beginning of the next tick.
+                this._originTimeoutId = setTimeout(() => this._origin = null, 1);
             }
-            // Unregister global listeners when last element is unmonitored.
-            if (!--this._monitoredElementCount) {
+        });
+    }
+    /**
+     * Checks whether the given focus event was caused by a touchstart event.
+     * @param event The focus event to check.
+     * @returns Whether the event was caused by a touch.
+     */
+    _wasCausedByTouch(event) {
+        // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
+        // Consider the following dom structure:
+        //
+        // <div #parent tabindex="0" cdkFocusClasses>
+        //   <div #child (click)="#parent.focus()"></div>
+        // </div>
+        //
+        // If the user touches the #child element and the #parent is programmatically focused as a
+        // result, this code will still consider it to have been caused by the touch event and will
+        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
+        // relatively small edge-case that can be worked around by using
+        // focusVia(parentEl, 'program') to focus the parent element.
+        //
+        // If we decide that we absolutely must handle this case correctly, we can do so by listening
+        // for the first focus event after the touchstart, and then the first blur event after that
+        // focus event. When that blur event fires we know that whatever follows is not a result of the
+        // touchstart.
+        const focusTarget = getTarget(event);
+        return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
+            (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
+    }
+    /**
+     * Handles focus events on a registered element.
+     * @param event The focus event.
+     * @param element The monitored element.
+     */
+    _onFocus(event, element) {
+        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
+        // focus event affecting the monitored element. If we want to use the origin of the first event
+        // instead we should check for the cdk-focused class here and return if the element already has
+        // it. (This only matters for elements that have includesChildren = true).
+        // If we are not counting child-element-focus as focused, make sure that the event target is the
+        // monitored element itself.
+        const elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
+            return;
+        }
+        const origin = this._getFocusOrigin(event);
+        this._setClasses(element, origin);
+        this._emitOrigin(elementInfo.subject, origin);
+        this._lastFocusOrigin = origin;
+    }
+    /**
+     * Handles blur events on a registered element.
+     * @param event The blur event.
+     * @param element The monitored element.
+     */
+    _onBlur(event, element) {
+        // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
+        // order to focus another child of the monitored element.
+        const elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
+            element.contains(event.relatedTarget))) {
+            return;
+        }
+        this._setClasses(element);
+        this._emitOrigin(elementInfo.subject, null);
+    }
+    _emitOrigin(subject, origin) {
+        this._ngZone.run(() => subject.next(origin));
+    }
+    _registerGlobalListeners(elementInfo) {
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        const rootNode = elementInfo.rootNode;
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
+            this._ngZone.runOutsideAngular(() => {
+                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+            });
+        }
+        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
+        // Register global listeners when first element is monitored.
+        if (++this._monitoredElementCount === 1) {
+            // Note: we listen to events in the capture phase so we
+            // can detect them even if the user stops propagation.
+            this._ngZone.runOutsideAngular(() => {
                 const document = this._getDocument();
                 const window = this._getWindow();
-                document.removeEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
-                document.removeEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
-                document.removeEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
-                window.removeEventListener('focus', this._windowFocusListener);
-                // Clear timeouts for all potentially pending timeouts to prevent the leaks.
-                clearTimeout(this._windowFocusTimeoutId);
-                clearTimeout(this._touchTimeoutId);
-                clearTimeout(this._originTimeoutId);
+                document.addEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
+                document.addEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
+                document.addEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
+                window.addEventListener('focus', this._windowFocusListener);
+            });
+        }
+    }
+    _removeGlobalListeners(elementInfo) {
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
+            if (rootNodeFocusListeners > 1) {
+                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
             }
+            else {
+                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                this._rootNodeFocusListenerCount.delete(rootNode);
+            }
+        }
+        // Unregister global listeners when last element is unmonitored.
+        if (!--this._monitoredElementCount) {
+            const document = this._getDocument();
+            const window = this._getWindow();
+            document.removeEventListener('keydown', this._documentKeydownListener, captureEventListenerOptions);
+            document.removeEventListener('mousedown', this._documentMousedownListener, captureEventListenerOptions);
+            document.removeEventListener('touchstart', this._documentTouchstartListener, captureEventListenerOptions);
+            window.removeEventListener('focus', this._windowFocusListener);
+            // Clear timeouts for all potentially pending timeouts to prevent the leaks.
+            clearTimeout(this._windowFocusTimeoutId);
+            clearTimeout(this._touchTimeoutId);
+            clearTimeout(this._originTimeoutId);
         }
     }
-    FocusMonitor.ɵprov = ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(ɵɵinject(NgZone), ɵɵinject(Platform), ɵɵinject(DOCUMENT, 8), ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
-    FocusMonitor.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    FocusMonitor.ctorParameters = () => [
-        { type: NgZone },
-        { type: Platform },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }
-    ];
-    return FocusMonitor;
-})();
+}
+FocusMonitor.ɵprov = ɵɵdefineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(ɵɵinject(NgZone), ɵɵinject(Platform), ɵɵinject(DOCUMENT, 8), ɵɵinject(FOCUS_MONITOR_DEFAULT_OPTIONS, 8)); }, token: FocusMonitor, providedIn: "root" });
+FocusMonitor.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+FocusMonitor.ctorParameters = () => [
+    { type: NgZone },
+    { type: Platform },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FOCUS_MONITOR_DEFAULT_OPTIONS,] }] }
+];
 /** Gets the target of an event, accounting for Shadow DOM. */
 function getTarget(event) {
     // If an event is bound outside the Shadow DOM, the `event.target` will
@@ -2028,38 +2062,35 @@ function getTarget(event) {
  *    focused.
  * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
  */
-let CdkMonitorFocus = /** @class */ (() => {
-    class CdkMonitorFocus {
-        constructor(_elementRef, _focusMonitor) {
-            this._elementRef = _elementRef;
-            this._focusMonitor = _focusMonitor;
-            this.cdkFocusChange = new EventEmitter();
-        }
-        ngAfterViewInit() {
-            this._monitorSubscription = this._focusMonitor.monitor(this._elementRef, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
-                .subscribe(origin => this.cdkFocusChange.emit(origin));
-        }
-        ngOnDestroy() {
-            this._focusMonitor.stopMonitoring(this._elementRef);
-            if (this._monitorSubscription) {
-                this._monitorSubscription.unsubscribe();
-            }
+class CdkMonitorFocus {
+    constructor(_elementRef, _focusMonitor) {
+        this._elementRef = _elementRef;
+        this._focusMonitor = _focusMonitor;
+        this.cdkFocusChange = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        this._monitorSubscription = this._focusMonitor.monitor(this._elementRef, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
+            .subscribe(origin => this.cdkFocusChange.emit(origin));
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        if (this._monitorSubscription) {
+            this._monitorSubscription.unsubscribe();
         }
     }
-    CdkMonitorFocus.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
-                },] }
-    ];
-    CdkMonitorFocus.ctorParameters = () => [
-        { type: ElementRef },
-        { type: FocusMonitor }
-    ];
-    CdkMonitorFocus.propDecorators = {
-        cdkFocusChange: [{ type: Output }]
-    };
-    return CdkMonitorFocus;
-})();
+}
+CdkMonitorFocus.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
+            },] }
+];
+CdkMonitorFocus.ctorParameters = () => [
+    { type: ElementRef },
+    { type: FocusMonitor }
+];
+CdkMonitorFocus.propDecorators = {
+    cdkFocusChange: [{ type: Output }]
+};
 
 /**
  * @license
@@ -2085,69 +2116,66 @@ const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';
  * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
  * browser extension.
  */
-let HighContrastModeDetector = /** @class */ (() => {
-    class HighContrastModeDetector {
-        constructor(_platform, document) {
-            this._platform = _platform;
-            this._document = document;
-        }
-        /** Gets the current high-contrast-mode for the page. */
-        getHighContrastMode() {
-            if (!this._platform.isBrowser) {
-                return 0 /* NONE */;
-            }
-            // Create a test element with an arbitrary background-color that is neither black nor
-            // white; high-contrast mode will coerce the color to either black or white. Also ensure that
-            // appending the test element to the DOM does not affect layout by absolutely positioning it
-            const testElement = this._document.createElement('div');
-            testElement.style.backgroundColor = 'rgb(1,2,3)';
-            testElement.style.position = 'absolute';
-            this._document.body.appendChild(testElement);
-            // Get the computed style for the background color, collapsing spaces to normalize between
-            // browsers. Once we get this color, we no longer need the test element. Access the `window`
-            // via the document so we can fake it in tests. Note that we have extra null checks, because
-            // this logic will likely run during app bootstrap and throwing can break the entire app.
-            const documentWindow = this._document.defaultView || window;
-            const computedStyle = (documentWindow && documentWindow.getComputedStyle) ?
-                documentWindow.getComputedStyle(testElement) : null;
-            const computedColor = (computedStyle && computedStyle.backgroundColor || '').replace(/ /g, '');
-            this._document.body.removeChild(testElement);
-            switch (computedColor) {
-                case 'rgb(0,0,0)': return 2 /* WHITE_ON_BLACK */;
-                case 'rgb(255,255,255)': return 1 /* BLACK_ON_WHITE */;
-            }
+class HighContrastModeDetector {
+    constructor(_platform, document) {
+        this._platform = _platform;
+        this._document = document;
+    }
+    /** Gets the current high-contrast-mode for the page. */
+    getHighContrastMode() {
+        if (!this._platform.isBrowser) {
             return 0 /* NONE */;
         }
-        /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
-        _applyBodyHighContrastModeCssClasses() {
-            if (this._platform.isBrowser && this._document.body) {
-                const bodyClasses = this._document.body.classList;
-                // IE11 doesn't support `classList` operations with multiple arguments
-                bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
-                bodyClasses.remove(BLACK_ON_WHITE_CSS_CLASS);
-                bodyClasses.remove(WHITE_ON_BLACK_CSS_CLASS);
-                const mode = this.getHighContrastMode();
-                if (mode === 1 /* BLACK_ON_WHITE */) {
-                    bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
-                    bodyClasses.add(BLACK_ON_WHITE_CSS_CLASS);
-                }
-                else if (mode === 2 /* WHITE_ON_BLACK */) {
-                    bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
-                    bodyClasses.add(WHITE_ON_BLACK_CSS_CLASS);
-                }
+        // Create a test element with an arbitrary background-color that is neither black nor
+        // white; high-contrast mode will coerce the color to either black or white. Also ensure that
+        // appending the test element to the DOM does not affect layout by absolutely positioning it
+        const testElement = this._document.createElement('div');
+        testElement.style.backgroundColor = 'rgb(1,2,3)';
+        testElement.style.position = 'absolute';
+        this._document.body.appendChild(testElement);
+        // Get the computed style for the background color, collapsing spaces to normalize between
+        // browsers. Once we get this color, we no longer need the test element. Access the `window`
+        // via the document so we can fake it in tests. Note that we have extra null checks, because
+        // this logic will likely run during app bootstrap and throwing can break the entire app.
+        const documentWindow = this._document.defaultView || window;
+        const computedStyle = (documentWindow && documentWindow.getComputedStyle) ?
+            documentWindow.getComputedStyle(testElement) : null;
+        const computedColor = (computedStyle && computedStyle.backgroundColor || '').replace(/ /g, '');
+        this._document.body.removeChild(testElement);
+        switch (computedColor) {
+            case 'rgb(0,0,0)': return 2 /* WHITE_ON_BLACK */;
+            case 'rgb(255,255,255)': return 1 /* BLACK_ON_WHITE */;
+        }
+        return 0 /* NONE */;
+    }
+    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
+    _applyBodyHighContrastModeCssClasses() {
+        if (this._platform.isBrowser && this._document.body) {
+            const bodyClasses = this._document.body.classList;
+            // IE11 doesn't support `classList` operations with multiple arguments
+            bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+            bodyClasses.remove(BLACK_ON_WHITE_CSS_CLASS);
+            bodyClasses.remove(WHITE_ON_BLACK_CSS_CLASS);
+            const mode = this.getHighContrastMode();
+            if (mode === 1 /* BLACK_ON_WHITE */) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+                bodyClasses.add(BLACK_ON_WHITE_CSS_CLASS);
+            }
+            else if (mode === 2 /* WHITE_ON_BLACK */) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS);
+                bodyClasses.add(WHITE_ON_BLACK_CSS_CLASS);
             }
         }
     }
-    HighContrastModeDetector.ɵprov = ɵɵdefineInjectable({ factory: function HighContrastModeDetector_Factory() { return new HighContrastModeDetector(ɵɵinject(Platform), ɵɵinject(DOCUMENT)); }, token: HighContrastModeDetector, providedIn: "root" });
-    HighContrastModeDetector.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    HighContrastModeDetector.ctorParameters = () => [
-        { type: Platform },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    return HighContrastModeDetector;
-})();
+}
+HighContrastModeDetector.ɵprov = ɵɵdefineInjectable({ factory: function HighContrastModeDetector_Factory() { return new HighContrastModeDetector(ɵɵinject(Platform), ɵɵinject(DOCUMENT)); }, token: HighContrastModeDetector, providedIn: "root" });
+HighContrastModeDetector.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+HighContrastModeDetector.ctorParameters = () => [
+    { type: Platform },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
 
 /**
  * @license
@@ -2156,24 +2184,21 @@ let HighContrastModeDetector = /** @class */ (() => {
  * 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
  */
-let A11yModule = /** @class */ (() => {
-    class A11yModule {
-        constructor(highContrastModeDetector) {
-            highContrastModeDetector._applyBodyHighContrastModeCssClasses();
-        }
-    }
-    A11yModule.decorators = [
-        { type: NgModule, args: [{
-                    imports: [PlatformModule, ObserversModule],
-                    declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
-                    exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
-                },] }
-    ];
-    A11yModule.ctorParameters = () => [
-        { type: HighContrastModeDetector }
-    ];
-    return A11yModule;
-})();
+class A11yModule {
+    constructor(highContrastModeDetector) {
+        highContrastModeDetector._applyBodyHighContrastModeCssClasses();
+    }
+}
+A11yModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [PlatformModule, ObserversModule],
+                declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
+                exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
+            },] }
+];
+A11yModule.ctorParameters = () => [
+    { type: HighContrastModeDetector }
+];
 
 /**
  * @license
@@ -2187,5 +2212,5 @@ let A11yModule = /** @class */ (() => {
  * Generated bundle index. Do not edit.
  */
 
-export { A11yModule, ActiveDescendantKeyManager, AriaDescriber, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, CDK_DESCRIBEDBY_ID_PREFIX, CdkAriaLive, CdkMonitorFocus, CdkTrapFocus, ConfigurableFocusTrap, ConfigurableFocusTrapFactory, EventListenerFocusTrapInertStrategy, FOCUS_MONITOR_DEFAULT_OPTIONS, FOCUS_TRAP_INERT_STRATEGY, FocusKeyManager, FocusMonitor, FocusTrap, FocusTrapFactory, HighContrastModeDetector, InteractivityChecker, LIVE_ANNOUNCER_DEFAULT_OPTIONS, LIVE_ANNOUNCER_ELEMENT_TOKEN, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, ListKeyManager, LiveAnnouncer, MESSAGES_CONTAINER_ID, TOUCH_BUFFER_MS, isFakeMousedownFromScreenReader, FocusTrapManager as ɵangular_material_src_cdk_a11y_a11y_a, ConfigurableFocusTrapConfig as ɵangular_material_src_cdk_a11y_a11y_b };
+export { A11yModule, ActiveDescendantKeyManager, AriaDescriber, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, CDK_DESCRIBEDBY_ID_PREFIX, CdkAriaLive, CdkMonitorFocus, CdkTrapFocus, ConfigurableFocusTrap, ConfigurableFocusTrapFactory, EventListenerFocusTrapInertStrategy, FOCUS_MONITOR_DEFAULT_OPTIONS, FOCUS_TRAP_INERT_STRATEGY, FocusKeyManager, FocusMonitor, FocusTrap, FocusTrapFactory, HighContrastModeDetector, InteractivityChecker, IsFocusableConfig, LIVE_ANNOUNCER_DEFAULT_OPTIONS, LIVE_ANNOUNCER_ELEMENT_TOKEN, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, ListKeyManager, LiveAnnouncer, MESSAGES_CONTAINER_ID, TOUCH_BUFFER_MS, isFakeMousedownFromScreenReader, FocusTrapManager as ɵangular_material_src_cdk_a11y_a11y_a, ConfigurableFocusTrapConfig as ɵangular_material_src_cdk_a11y_a11y_b };
 //# sourceMappingURL=a11y.js.map