@angular/cdk 2.0.0-beta.11 → 2.0.0-beta.12

package/bundles/cdk-a11y.umd.js

@@ -6,10 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/cdk/coercion'), require('@angular/cdk/platform'), require('@angular/cdk/rxjs'), require('@angular/common'), require('rxjs/Subject'), require('rxjs/observable/of'), require('rxjs/Subscription'), require('@angular/cdk/keycodes')) :
-	typeof define === 'function' && define.amd ? define(['exports', '@angular/core', '@angular/cdk/coercion', '@angular/cdk/platform', '@angular/cdk/rxjs', '@angular/common', 'rxjs/Subject', 'rxjs/observable/of', 'rxjs/Subscription', '@angular/cdk/keycodes'], factory) :
-	(factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.a11y = global.ng.cdk.a11y || {}),global.ng.core,global.ng.cdk.coercion,global.ng.cdk.platform,global.ng.cdk.rxjs,global.ng.common,global.Rx,global.Rx.Observable,global.Rx,global.ng.cdk.keycodes));
-}(this, (function (exports,_angular_core,_angular_cdk_coercion,_angular_cdk_platform,_angular_cdk_rxjs,_angular_common,rxjs_Subject,rxjs_observable_of,rxjs_Subscription,_angular_cdk_keycodes) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Subject'), require('rxjs/Subscription'), require('@angular/cdk/keycodes'), require('@angular/cdk/rxjs'), require('@angular/core'), require('@angular/cdk/platform'), require('@angular/cdk/coercion'), require('rxjs/observable/of'), require('@angular/common')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Subject', 'rxjs/Subscription', '@angular/cdk/keycodes', '@angular/cdk/rxjs', '@angular/core', '@angular/cdk/platform', '@angular/cdk/coercion', 'rxjs/observable/of', '@angular/common'], factory) :
+	(factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.a11y = global.ng.cdk.a11y || {}),global.Rx,global.Rx,global.ng.cdk.keycodes,global.ng.cdk.rxjs,global.ng.core,global.ng.cdk.platform,global.ng.cdk.coercion,global.Rx.Observable,global.ng.common));
+}(this, (function (exports,rxjs_Subject,rxjs_Subscription,_angular_cdk_keycodes,_angular_cdk_rxjs,_angular_core,_angular_cdk_platform,_angular_cdk_coercion,rxjs_observable_of,_angular_common) { 'use strict';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -38,1650 +38,1660 @@ function __extends(d, b) {
 }
 
 /**
- * Utility for checking the interactivity of an element, such as whether is is focusable or
- * tabbable.
+ * This class manages keyboard events for selectable lists. If you pass it a query list
+ * of items, it will set the active item correctly when arrow events occur.
  */
-var InteractivityChecker = (function () {
+var ListKeyManager = (function () {
     /**
-     * @param {?} _platform
+     * @param {?} _items
      */
-    function InteractivityChecker(_platform) {
-        this._platform = _platform;
+    function ListKeyManager(_items) {
+        this._items = _items;
+        this._activeItemIndex = -1;
+        this._wrap = false;
+        this._letterKeyStream = new rxjs_Subject.Subject();
+        this._typeaheadSubscription = rxjs_Subscription.Subscription.EMPTY;
+        this._pressedLetters = [];
+        /**
+         * Stream that emits any time the TAB key is pressed, so components can react
+         * when focus is shifted off of the list.
+         */
+        this.tabOut = new rxjs_Subject.Subject();
     }
     /**
-     * Gets whether an element is disabled.
-     *
-     * @param {?} element Element to be checked.
-     * @return {?} Whether the element is disabled.
-     */
-    InteractivityChecker.prototype.isDisabled = function (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.
-     *
-     * @param {?} element
-     * @return {?} Whether the element is visible.
+     * Turns on wrapping mode, which ensures that the active item will wrap to
+     * the other end of list when there are no more items in the given direction.
+     * @return {?}
      */
-    InteractivityChecker.prototype.isVisible = function (element) {
-        return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
+    ListKeyManager.prototype.withWrap = function () {
+        this._wrap = true;
+        return this;
     };
     /**
-     * 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.
-     * @return {?} Whether the element is tabbable.
+     * Turns on typeahead mode which allows users to set the active item by typing.
+     * @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.
+     * @return {?}
      */
-    InteractivityChecker.prototype.isTabbable = function (element) {
-        // Nothing is tabbable on the the server 😎
-        if (!this._platform.isBrowser) {
-            return false;
-        }
-        var /** @type {?} */ frameElement = (getWindow(element).frameElement);
-        if (frameElement) {
-            var /** @type {?} */ 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;
-            }
-        }
-        var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
-        var /** @type {?} */ 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;
-            }
-            else if (this._platform.BLINK) {
-                // In Blink <audio controls> elements are always tabbable.
-                return true;
-            }
+    ListKeyManager.prototype.withTypeAhead = function (debounceInterval) {
+        var _this = this;
+        if (debounceInterval === void 0) { debounceInterval = 200; }
+        if (this._items.length && this._items.some(function (item) { return typeof item.getLabel !== 'function'; })) {
+            throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');
         }
-        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;
+        this._typeaheadSubscription.unsubscribe();
+        // Debounce the presses of non-navigational keys, collect the ones that correspond to letters
+        // and convert those letters back into a string. Afterwards find the first item that starts
+        // with that string and select it.
+        this._typeaheadSubscription = _angular_cdk_rxjs.RxChain.from(this._letterKeyStream)
+            .call(_angular_cdk_rxjs.doOperator, function (keyCode) { return _this._pressedLetters.push(keyCode); })
+            .call(_angular_cdk_rxjs.debounceTime, debounceInterval)
+            .call(_angular_cdk_rxjs.filter, function () { return _this._pressedLetters.length > 0; })
+            .call(_angular_cdk_rxjs.map, function () { return _this._pressedLetters.join(''); })
+            .subscribe(function (inputString) {
+            var /** @type {?} */ items = _this._items.toArray();
+            // Start at 1 because we want to start searching at the item immediately
+            // following the current active item.
+            for (var /** @type {?} */ i = 1; i < items.length + 1; i++) {
+                var /** @type {?} */ index = (_this._activeItemIndex + i) % items.length;
+                var /** @type {?} */ item = items[index];
+                if (!item.disabled && ((item.getLabel))().toUpperCase().trim().indexOf(inputString) === 0) {
+                    _this.setActiveItem(index);
+                    break;
+                }
             }
-        }
-        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;
+            _this._pressedLetters = [];
+        });
+        return this;
     };
     /**
-     * Gets whether an element can be focused by the user.
-     *
-     * @param {?} element Element to be checked.
-     * @return {?} Whether the element is focusable.
+     * Sets the active item to the item at the index specified.
+     * @param {?} index The index of the item to be set as active.
+     * @return {?}
      */
-    InteractivityChecker.prototype.isFocusable = function (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);
+    ListKeyManager.prototype.setActiveItem = function (index) {
+        this._activeItemIndex = index;
+        this._activeItem = this._items.toArray()[index];
     };
-    return InteractivityChecker;
-}());
-InteractivityChecker.decorators = [
-    { type: _angular_core.Injectable },
-];
-/**
- * @nocollapse
- */
-InteractivityChecker.ctorParameters = function () { return [
-    { type: _angular_cdk_platform.Platform, },
-]; };
-/**
- * Checks whether the specified element has any geometry / rectangles.
- * @param {?} element
- * @return {?}
- */
-function hasGeometry(element) {
-    // Use logic from jQuery to check for an invisible element.
-    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
-    return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);
-}
-/**
- * Gets whether an element's
- * @param {?} element
- * @return {?}
- */
-function isNativeFormElement(element) {
-    var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
-    return nodeName === 'input' ||
-        nodeName === 'select' ||
-        nodeName === 'button' ||
-        nodeName === 'textarea';
-}
-/**
- * Gets whether an element is an <input type="hidden">.
- * @param {?} element
- * @return {?}
- */
-function isHiddenInput(element) {
-    return isInputElement(element) && element.type == 'hidden';
-}
-/**
- * Gets whether an element is an anchor that has an href attribute.
- * @param {?} element
- * @return {?}
- */
-function isAnchorWithHref(element) {
-    return isAnchorElement(element) && element.hasAttribute('href');
-}
-/**
- * Gets whether an element is an input element.
- * @param {?} element
- * @return {?}
- */
-function isInputElement(element) {
-    return element.nodeName.toLowerCase() == 'input';
-}
-/**
- * Gets whether an element is an anchor element.
- * @param {?} element
- * @return {?}
- */
-function isAnchorElement(element) {
-    return element.nodeName.toLowerCase() == 'a';
-}
-/**
- * Gets whether an element has a valid tabindex.
- * @param {?} element
- * @return {?}
- */
-function hasValidTabIndex(element) {
-    if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
-        return false;
-    }
-    var /** @type {?} */ tabIndex = element.getAttribute('tabindex');
-    // IE11 parses tabindex="" as the value "-32768"
-    if (tabIndex == '-32768') {
-        return false;
-    }
-    return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
-}
-/**
- * Returns the parsed tabindex from the element attributes instead of returning the
- * evaluated tabindex from the browsers defaults.
- * @param {?} element
- * @return {?}
- */
-function getTabIndexValue(element) {
-    if (!hasValidTabIndex(element)) {
-        return null;
-    }
-    // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
-    var /** @type {?} */ tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
-    return isNaN(tabIndex) ? -1 : tabIndex;
-}
-/**
- * Checks whether the specified element is potentially tabbable on iOS
- * @param {?} element
- * @return {?}
- */
-function isPotentiallyTabbableIOS(element) {
-    var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
-    var /** @type {?} */ inputType = nodeName === 'input' && ((element)).type;
-    return inputType === 'text'
-        || inputType === 'password'
-        || nodeName === 'select'
-        || nodeName === 'textarea';
-}
-/**
- * Gets whether an element is potentially focusable without taking current visible/disabled state
- * into account.
- * @param {?} element
- * @return {?}
- */
-function isPotentiallyFocusable(element) {
-    // Inputs are potentially focusable *unless* they're type="hidden".
-    if (isHiddenInput(element)) {
-        return false;
-    }
-    return isNativeFormElement(element) ||
-        isAnchorWithHref(element) ||
-        element.hasAttribute('contenteditable') ||
-        hasValidTabIndex(element);
-}
-/**
- * Gets the parent window of a DOM node with regards of being inside of an iframe.
- * @param {?} node
- * @return {?}
- */
-function getWindow(node) {
-    return node.ownerDocument.defaultView || window;
-}
-/**
- * Class that allows for trapping focus within a DOM element.
- *
- * NOTE: This class currently uses a very simple (naive) approach to focus trapping.
- * It assumes that the tab order is the same as DOM order, which is not necessarily true.
- * Things like tabIndex > 0, flex `order`, and shadow roots can cause to two to misalign.
- * This will be replaced with a more intelligent solution before the library is considered stable.
- */
-var FocusTrap = (function () {
     /**
-     * @param {?} _element
-     * @param {?} _platform
-     * @param {?} _checker
-     * @param {?} _ngZone
-     * @param {?=} deferAnchors
+     * Sets the active item depending on the key event passed in.
+     * @param {?} event Keyboard event to be used for determining which element should be active.
+     * @return {?}
      */
-    function FocusTrap(_element, _platform, _checker, _ngZone, deferAnchors) {
-        if (deferAnchors === void 0) { deferAnchors = false; }
-        this._element = _element;
-        this._platform = _platform;
-        this._checker = _checker;
-        this._ngZone = _ngZone;
-        this._enabled = true;
-        if (!deferAnchors) {
-            this.attachAnchors();
+    ListKeyManager.prototype.onKeydown = function (event) {
+        switch (event.keyCode) {
+            case _angular_cdk_keycodes.DOWN_ARROW:
+                this.setNextItemActive();
+                break;
+            case _angular_cdk_keycodes.UP_ARROW:
+                this.setPreviousItemActive();
+                break;
+            case _angular_cdk_keycodes.TAB:
+                this.tabOut.next();
+                return;
+            default:
+                var /** @type {?} */ keyCode = event.keyCode;
+                // Attempt to use the `event.key` which also maps it to the user's keyboard language,
+                // otherwise fall back to resolving alphanumeric characters via the keyCode.
+                if (event.key && event.key.length === 1) {
+                    this._letterKeyStream.next(event.key.toLocaleUpperCase());
+                }
+                else if ((keyCode >= _angular_cdk_keycodes.A && keyCode <= _angular_cdk_keycodes.Z) || (keyCode >= _angular_cdk_keycodes.ZERO && keyCode <= _angular_cdk_keycodes.NINE)) {
+                    this._letterKeyStream.next(String.fromCharCode(keyCode));
+                }
+                // Note that we return here, in order to avoid preventing
+                // the default action of non-navigational keys.
+                return;
         }
-    }
-    Object.defineProperty(FocusTrap.prototype, "enabled", {
+        this._pressedLetters = [];
+        event.preventDefault();
+    };
+    Object.defineProperty(ListKeyManager.prototype, "activeItemIndex", {
         /**
-         * Whether the focus trap is active.
+         * Index of the currently active item.
          * @return {?}
          */
-        get: function () { return this._enabled; },
+        get: function () {
+            return this._activeItemIndex;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListKeyManager.prototype, "activeItem", {
         /**
-         * @param {?} val
+         * The active item.
          * @return {?}
          */
-        set: function (val) {
-            this._enabled = val;
-            if (this._startAnchor && this._endAnchor) {
-                this._startAnchor.tabIndex = this._endAnchor.tabIndex = this._enabled ? 0 : -1;
-            }
+        get: function () {
+            return this._activeItem;
         },
         enumerable: true,
         configurable: true
     });
     /**
-     * Destroys the focus trap by cleaning up the anchors.
+     * Sets the active item to the first enabled item in the list.
      * @return {?}
      */
-    FocusTrap.prototype.destroy = function () {
-        if (this._startAnchor && this._startAnchor.parentNode) {
-            this._startAnchor.parentNode.removeChild(this._startAnchor);
-        }
-        if (this._endAnchor && this._endAnchor.parentNode) {
-            this._endAnchor.parentNode.removeChild(this._endAnchor);
-        }
-        this._startAnchor = this._endAnchor = null;
+    ListKeyManager.prototype.setFirstItemActive = function () {
+        this._setActiveItemByIndex(0, 1);
     };
     /**
-     * Inserts the anchors into the DOM. This is usually done automatically
-     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+     * Sets the active item to the last enabled item in the list.
      * @return {?}
      */
-    FocusTrap.prototype.attachAnchors = function () {
-        var _this = this;
-        // If we're not on the browser, there can be no focus to trap.
-        if (!this._platform.isBrowser) {
-            return;
-        }
-        if (!this._startAnchor) {
-            this._startAnchor = this._createAnchor();
-        }
-        if (!this._endAnchor) {
-            this._endAnchor = this._createAnchor();
-        }
-        this._ngZone.runOutsideAngular(function () {
-            ((_this._startAnchor)).addEventListener('focus', function () {
-                _this.focusLastTabbableElement();
-            }); /** @type {?} */
-            ((_this._endAnchor)).addEventListener('focus', function () {
-                _this.focusFirstTabbableElement();
-            });
-            if (_this._element.parentNode) {
-                _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._startAnchor)), _this._element);
-                _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._endAnchor)), _this._element.nextSibling);
-            }
-        });
-    };
-    /**
-     * Waits for the zone to stabilize, then either focuses the first element that the
-     * user specified, or the first tabbable element.
-     * @return {?} Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfuly.
-     */
-    FocusTrap.prototype.focusInitialElementWhenReady = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            _this._executeOnStable(function () { return resolve(_this.focusInitialElement()); });
-        });
-    };
-    /**
-     * Waits for the zone to stabilize, then focuses
-     * the first tabbable element within the focus trap region.
-     * @return {?} Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfuly.
-     */
-    FocusTrap.prototype.focusFirstTabbableElementWhenReady = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            _this._executeOnStable(function () { return resolve(_this.focusFirstTabbableElement()); });
-        });
-    };
-    /**
-     * Waits for the zone to stabilize, then focuses
-     * the last tabbable element within the focus trap region.
-     * @return {?} Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfuly.
-     */
-    FocusTrap.prototype.focusLastTabbableElementWhenReady = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            _this._executeOnStable(function () { return resolve(_this.focusLastTabbableElement()); });
-        });
-    };
-    /**
-     * Get the specified boundary element of the trapped region.
-     * @param {?} bound The boundary to get (start or end of trapped region).
-     * @return {?} The boundary element.
-     */
-    FocusTrap.prototype._getRegionBoundary = function (bound) {
-        // Contains the deprecated version of selector, for temporary backwards comparability.
-        var /** @type {?} */ markers = (this._element.querySelectorAll("[cdk-focus-region-" + bound + "], " +
-            ("[cdk-focus-" + bound + "]")));
-        for (var /** @type {?} */ i = 0; i < markers.length; i++) {
-            if (markers[i].hasAttribute("cdk-focus-" + bound)) {
-                console.warn("Found use of deprecated attribute 'cdk-focus-" + bound + "'," +
-                    (" use 'cdk-focus-region-" + bound + "' instead."), markers[i]);
-            }
-        }
-        if (bound == 'start') {
-            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
-        }
-        return markers.length ?
-            markers[markers.length - 1] : this._getLastTabbableElement(this._element);
+    ListKeyManager.prototype.setLastItemActive = function () {
+        this._setActiveItemByIndex(this._items.length - 1, -1);
     };
     /**
-     * Focuses the element that should be focused when the focus trap is initialized.
-     * @return {?} Returns whether focus was moved successfuly.
+     * Sets the active item to the next enabled item in the list.
+     * @return {?}
      */
-    FocusTrap.prototype.focusInitialElement = function () {
-        var /** @type {?} */ redirectToElement = (this._element.querySelector('[cdk-focus-initial]'));
-        if (redirectToElement) {
-            redirectToElement.focus();
-            return true;
-        }
-        return this.focusFirstTabbableElement();
+    ListKeyManager.prototype.setNextItemActive = function () {
+        this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);
     };
-    /**
-     * Focuses the first tabbable element within the focus trap region.
-     * @return {?} Returns whether focus was moved successfuly.
+    /**
+     * Sets the active item to a previous enabled item in the list.
+     * @return {?}
      */
-    FocusTrap.prototype.focusFirstTabbableElement = function () {
-        var /** @type {?} */ redirectToElement = this._getRegionBoundary('start');
-        if (redirectToElement) {
-            redirectToElement.focus();
-        }
-        return !!redirectToElement;
+    ListKeyManager.prototype.setPreviousItemActive = function () {
+        this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()
+            : this._setActiveItemByDelta(-1);
     };
     /**
-     * Focuses the last tabbable element within the focus trap region.
-     * @return {?} Returns whether focus was moved successfuly.
+     * Allows setting of the activeItemIndex without any other effects.
+     * @param {?} index The new activeItemIndex.
+     * @return {?}
      */
-    FocusTrap.prototype.focusLastTabbableElement = function () {
-        var /** @type {?} */ redirectToElement = this._getRegionBoundary('end');
-        if (redirectToElement) {
-            redirectToElement.focus();
-        }
-        return !!redirectToElement;
+    ListKeyManager.prototype.updateActiveItemIndex = function (index) {
+        this._activeItemIndex = index;
     };
     /**
-     * Get the first tabbable element from a DOM subtree (inclusive).
-     * @param {?} root
+     * This method sets the active item, given a list of items and the delta between the
+     * currently active item and the new active item. It will calculate differently
+     * depending on whether wrap mode is turned on.
+     * @param {?} delta
+     * @param {?=} items
      * @return {?}
      */
-    FocusTrap.prototype._getFirstTabbableElement = function (root) {
-        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
-            return root;
-        }
-        // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall
-        // back to `childNodes` which includes text nodes, comments etc.
-        var /** @type {?} */ children = root.children || root.childNodes;
-        for (var /** @type {?} */ i = 0; i < children.length; i++) {
-            var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?
-                this._getFirstTabbableElement(/** @type {?} */ (children[i])) :
-                null;
-            if (tabbableChild) {
-                return tabbableChild;
-            }
-        }
-        return null;
+    ListKeyManager.prototype._setActiveItemByDelta = function (delta, items) {
+        if (items === void 0) { items = this._items.toArray(); }
+        this._wrap ? this._setActiveInWrapMode(delta, items)
+            : this._setActiveInDefaultMode(delta, items);
     };
     /**
-     * Get the last tabbable element from a DOM subtree (inclusive).
-     * @param {?} root
+     * Sets the active item properly given "wrap" mode. In other words, it will continue to move
+     * down the list until it finds an item that is not disabled, and it will wrap if it
+     * encounters either end of the list.
+     * @param {?} delta
+     * @param {?} items
      * @return {?}
      */
-    FocusTrap.prototype._getLastTabbableElement = function (root) {
-        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
-            return root;
+    ListKeyManager.prototype._setActiveInWrapMode = function (delta, items) {
+        // when active item would leave menu, wrap to beginning or end
+        this._activeItemIndex =
+            (this._activeItemIndex + delta + items.length) % items.length;
+        // skip all disabled menu items recursively until an enabled one is reached
+        if (items[this._activeItemIndex].disabled) {
+            this._setActiveInWrapMode(delta, items);
         }
-        // Iterate in reverse DOM order.
-        var /** @type {?} */ children = root.children || root.childNodes;
-        for (var /** @type {?} */ i = children.length - 1; i >= 0; i--) {
-            var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?
-                this._getLastTabbableElement(/** @type {?} */ (children[i])) :
-                null;
-            if (tabbableChild) {
-                return tabbableChild;
-            }
+        else {
+            this.setActiveItem(this._activeItemIndex);
         }
-        return null;
     };
     /**
-     * Creates an anchor element.
+     * Sets the active item properly given the default mode. In other words, it will
+     * continue to move down the list until it finds an item that is not disabled. If
+     * it encounters either end of the list, it will stop and not wrap.
+     * @param {?} delta
+     * @param {?} items
      * @return {?}
      */
-    FocusTrap.prototype._createAnchor = function () {
-        var /** @type {?} */ anchor = document.createElement('div');
-        anchor.tabIndex = this._enabled ? 0 : -1;
-        anchor.classList.add('cdk-visually-hidden');
-        anchor.classList.add('cdk-focus-trap-anchor');
-        return anchor;
+    ListKeyManager.prototype._setActiveInDefaultMode = function (delta, items) {
+        this._setActiveItemByIndex(this._activeItemIndex + delta, delta, items);
     };
     /**
-     * Executes a function when the zone is stable.
-     * @param {?} fn
+     * Sets the active item to the first enabled item starting at the index specified. If the
+     * item is disabled, it will move in the fallbackDelta direction until it either
+     * finds an enabled item or encounters the end of the list.
+     * @param {?} index
+     * @param {?} fallbackDelta
+     * @param {?=} items
      * @return {?}
      */
-    FocusTrap.prototype._executeOnStable = function (fn) {
-        if (this._ngZone.isStable) {
-            fn();
+    ListKeyManager.prototype._setActiveItemByIndex = function (index, fallbackDelta, items) {
+        if (items === void 0) { items = this._items.toArray(); }
+        if (!items[index]) {
+            return;
         }
-        else {
-            _angular_cdk_rxjs.first.call(this._ngZone.onStable.asObservable()).subscribe(fn);
+        while (items[index].disabled) {
+            index += fallbackDelta;
+            if (!items[index]) {
+                return;
+            }
         }
+        this.setActiveItem(index);
     };
-    return FocusTrap;
+    return ListKeyManager;
 }());
-/**
- * Factory that allows easy instantiation of focus traps.
- */
-var FocusTrapFactory = (function () {
-    /**
-     * @param {?} _checker
-     * @param {?} _platform
-     * @param {?} _ngZone
-     */
-    function FocusTrapFactory(_checker, _platform, _ngZone) {
-        this._checker = _checker;
-        this._platform = _platform;
-        this._ngZone = _ngZone;
+
+var ActiveDescendantKeyManager = (function (_super) {
+    __extends(ActiveDescendantKeyManager, _super);
+    function ActiveDescendantKeyManager() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
     /**
-     * @param {?} element
-     * @param {?=} deferAnchors
+     * This method sets the active item to the item at the specified index.
+     * It also adds active styles to the newly active item and removes active
+     * styles from the previously active item.
+     * @param {?} index
      * @return {?}
      */
-    FocusTrapFactory.prototype.create = function (element, deferAnchors) {
-        if (deferAnchors === void 0) { deferAnchors = false; }
-        return new FocusTrap(element, this._platform, this._checker, this._ngZone, deferAnchors);
+    ActiveDescendantKeyManager.prototype.setActiveItem = function (index) {
+        if (this.activeItem) {
+            this.activeItem.setInactiveStyles();
+        }
+        _super.prototype.setActiveItem.call(this, index);
+        if (this.activeItem) {
+            this.activeItem.setActiveStyles();
+        }
     };
-    return FocusTrapFactory;
-}());
-FocusTrapFactory.decorators = [
-    { type: _angular_core.Injectable },
-];
+    return ActiveDescendantKeyManager;
+}(ListKeyManager));
+
 /**
- * @nocollapse
+ * IDs are deliminated by an empty space, as per the spec.
  */
-FocusTrapFactory.ctorParameters = function () { return [
-    { type: InteractivityChecker, },
-    { type: _angular_cdk_platform.Platform, },
-    { type: _angular_core.NgZone, },
-]; };
+var ID_DELIMINATOR = ' ';
 /**
- * Directive for trapping focus within a region.
- * @deprecated
+ * Adds the given ID to the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ * @param {?} el
+ * @param {?} attr
+ * @param {?} id
+ * @return {?}
  */
-var FocusTrapDeprecatedDirective = (function () {
-    /**
-     * @param {?} _elementRef
-     * @param {?} _focusTrapFactory
-     */
-    function FocusTrapDeprecatedDirective(_elementRef, _focusTrapFactory) {
-        this._elementRef = _elementRef;
-        this._focusTrapFactory = _focusTrapFactory;
-        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+function addAriaReferencedId(el, attr, id) {
+    var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
+    if (ids.some(function (existingId) { return existingId.trim() == id.trim(); })) {
+        return;
     }
-    Object.defineProperty(FocusTrapDeprecatedDirective.prototype, "disabled", {
-        /**
-         * Whether the focus trap is active.
-         * @return {?}
-         */
-        get: function () { return !this.focusTrap.enabled; },
-        /**
-         * @param {?} val
-         * @return {?}
-         */
-        set: function (val) {
-            this.focusTrap.enabled = !_angular_cdk_coercion.coerceBooleanProperty(val);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * @return {?}
-     */
-    FocusTrapDeprecatedDirective.prototype.ngOnDestroy = function () {
-        this.focusTrap.destroy();
-    };
-    /**
-     * @return {?}
-     */
-    FocusTrapDeprecatedDirective.prototype.ngAfterContentInit = function () {
-        this.focusTrap.attachAnchors();
-    };
-    return FocusTrapDeprecatedDirective;
-}());
-FocusTrapDeprecatedDirective.decorators = [
-    { type: _angular_core.Directive, args: [{
-                selector: 'cdk-focus-trap',
-            },] },
-];
+    ids.push(id.trim());
+    el.setAttribute(attr, ids.join(ID_DELIMINATOR));
+}
+/**
+ * Removes the given ID from the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ * @param {?} el
+ * @param {?} attr
+ * @param {?} id
+ * @return {?}
+ */
+function removeAriaReferencedId(el, attr, id) {
+    var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
+    var /** @type {?} */ filteredIds = ids.filter(function (val) { return val != id.trim(); });
+    el.setAttribute(attr, filteredIds.join(ID_DELIMINATOR));
+}
+/**
+ * Gets the list of IDs referenced by the given ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ * @param {?} el
+ * @param {?} attr
+ * @return {?}
+ */
+function getAriaReferenceIds(el, attr) {
+    // Get string array of all individual ids (whitespace deliminated) in the attribute value
+    return (el.getAttribute(attr) || '').match(/\S+/g) || [];
+}
+
+/**
+ * ID used for the body container where all messages are appended.
+ */
+var MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';
+/**
+ * ID prefix used for each created message element.
+ */
+var CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';
+/**
+ * Attribute given to each host element that is described by a message element.
+ */
+var CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';
+/**
+ * Global incremental identifier for each registered message element.
+ */
+var nextId = 0;
+/**
+ * Global map of all registered message elements that have been placed into the document.
+ */
+var messageRegistry = new Map();
 /**
- * @nocollapse
+ * Container for all registered messages.
  */
-FocusTrapDeprecatedDirective.ctorParameters = function () { return [
-    { type: _angular_core.ElementRef, },
-    { type: FocusTrapFactory, },
-]; };
-FocusTrapDeprecatedDirective.propDecorators = {
-    'disabled': [{ type: _angular_core.Input },],
-};
+var messagesContainer = null;
 /**
- * Directive for trapping focus within a region.
+ * Utility that creates visually hidden elements with a message content. Useful for elements that
+ * want to use aria-describedby to further describe themselves without adding additional visual
+ * content.
+ * \@docs-private
  */
-var FocusTrapDirective = (function () {
+var AriaDescriber = (function () {
     /**
-     * @param {?} _elementRef
-     * @param {?} _focusTrapFactory
+     * @param {?} _platform
      */
-    function FocusTrapDirective(_elementRef, _focusTrapFactory) {
-        this._elementRef = _elementRef;
-        this._focusTrapFactory = _focusTrapFactory;
-        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+    function AriaDescriber(_platform) {
+        this._platform = _platform;
     }
-    Object.defineProperty(FocusTrapDirective.prototype, "enabled", {
-        /**
-         * Whether the focus trap is active.
-         * @return {?}
-         */
-        get: function () { return this.focusTrap.enabled; },
-        /**
-         * @param {?} value
-         * @return {?}
-         */
-        set: function (value) { this.focusTrap.enabled = _angular_cdk_coercion.coerceBooleanProperty(value); },
-        enumerable: true,
-        configurable: true
-    });
     /**
+     * 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.
+     * @param {?} hostElement
+     * @param {?} message
      * @return {?}
      */
-    FocusTrapDirective.prototype.ngOnDestroy = function () {
-        this.focusTrap.destroy();
+    AriaDescriber.prototype.describe = function (hostElement, message) {
+        if (!this._platform.isBrowser || !message.trim()) {
+            return;
+        }
+        if (!messageRegistry.has(message)) {
+            createMessageElement(message);
+        }
+        if (!isElementDescribedByMessage(hostElement, message)) {
+            addMessageReference(hostElement, message);
+        }
     };
     /**
+     * Removes the host element's aria-describedby reference to the message element.
+     * @param {?} hostElement
+     * @param {?} message
      * @return {?}
      */
-    FocusTrapDirective.prototype.ngAfterContentInit = function () {
-        this.focusTrap.attachAnchors();
+    AriaDescriber.prototype.removeDescription = function (hostElement, message) {
+        if (!this._platform.isBrowser || !message.trim()) {
+            return;
+        }
+        if (isElementDescribedByMessage(hostElement, message)) {
+            removeMessageReference(hostElement, message);
+        }
+        var /** @type {?} */ registeredMessage = messageRegistry.get(message);
+        if (registeredMessage && registeredMessage.referenceCount === 0) {
+            deleteMessageElement(message);
+        }
+        if (messagesContainer && messagesContainer.childNodes.length === 0) {
+            deleteMessagesContainer();
+        }
     };
-    return FocusTrapDirective;
+    /**
+     * Unregisters all created message elements and removes the message container.
+     * @return {?}
+     */
+    AriaDescriber.prototype.ngOnDestroy = function () {
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        var /** @type {?} */ describedElements = document.querySelectorAll("[" + CDK_DESCRIBEDBY_HOST_ATTRIBUTE + "]");
+        for (var /** @type {?} */ i = 0; i < describedElements.length; i++) {
+            removeCdkDescribedByReferenceIds(describedElements[i]);
+            describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+        }
+        if (messagesContainer) {
+            deleteMessagesContainer();
+        }
+        messageRegistry.clear();
+    };
+    AriaDescriber.decorators = [
+        { type: _angular_core.Injectable },
+    ];
+    /**
+     * @nocollapse
+     */
+    AriaDescriber.ctorParameters = function () { return [
+        { type: _angular_cdk_platform.Platform, },
+    ]; };
+    return AriaDescriber;
 }());
-FocusTrapDirective.decorators = [
-    { type: _angular_core.Directive, args: [{
-                selector: '[cdkTrapFocus]',
-                exportAs: 'cdkTrapFocus',
-            },] },
-];
 /**
- * @nocollapse
+ * Creates a new element in the visually hidden message container element with the message
+ * as its content and adds it to the message registry.
+ * @param {?} message
+ * @return {?}
+ */
+function createMessageElement(message) {
+    var /** @type {?} */ messageElement = document.createElement('div');
+    messageElement.setAttribute('id', CDK_DESCRIBEDBY_ID_PREFIX + "-" + nextId++);
+    messageElement.appendChild(/** @type {?} */ ((document.createTextNode(message))));
+    if (!messagesContainer) {
+        createMessagesContainer();
+    } /** @type {?} */
+    ((messagesContainer)).appendChild(messageElement);
+    messageRegistry.set(message, { messageElement: messageElement, referenceCount: 0 });
+}
+/**
+ * Deletes the message element from the global messages container.
+ * @param {?} message
+ * @return {?}
+ */
+function deleteMessageElement(message) {
+    var /** @type {?} */ registeredMessage = messageRegistry.get(message);
+    var /** @type {?} */ messageElement = registeredMessage && registeredMessage.messageElement;
+    if (messagesContainer && messageElement) {
+        messagesContainer.removeChild(messageElement);
+    }
+    messageRegistry.delete(message);
+}
+/**
+ * Creates the global container for all aria-describedby messages.
+ * @return {?}
+ */
+function createMessagesContainer() {
+    messagesContainer = document.createElement('div');
+    messagesContainer.setAttribute('id', MESSAGES_CONTAINER_ID);
+    messagesContainer.setAttribute('aria-hidden', 'true');
+    messagesContainer.style.display = 'none';
+    document.body.appendChild(messagesContainer);
+}
+/**
+ * Deletes the global messages container.
+ * @return {?}
+ */
+function deleteMessagesContainer() {
+    document.body.removeChild(/** @type {?} */ ((messagesContainer)));
+    messagesContainer = null;
+}
+/**
+ * Removes all cdk-describedby messages that are hosted through the element.
+ * @param {?} element
+ * @return {?}
+ */
+function removeCdkDescribedByReferenceIds(element) {
+    // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
+    var /** @type {?} */ originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
+        .filter(function (id) { return 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.
+ * @param {?} element
+ * @param {?} message
+ * @return {?}
+ */
+function addMessageReference(element, message) {
+    var /** @type {?} */ 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.
+ * @param {?} element
+ * @param {?} message
+ * @return {?}
+ */
+function removeMessageReference(element, message) {
+    var /** @type {?} */ 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.
+ * @param {?} element
+ * @param {?} message
+ * @return {?}
+ */
+function isElementDescribedByMessage(element, message) {
+    var /** @type {?} */ referenceIds = getAriaReferenceIds(element, 'aria-describedby');
+    var /** @type {?} */ registeredMessage = messageRegistry.get(message);
+    var /** @type {?} */ messageId = registeredMessage && registeredMessage.messageElement.id;
+    return !!messageId && referenceIds.indexOf(messageId) != -1;
+}
+/**
+ * \@docs-private
+ * @param {?} parentDispatcher
+ * @param {?} platform
+ * @return {?}
+ */
+function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher, platform) {
+    return parentDispatcher || new AriaDescriber(platform);
+}
+/**
+ * \@docs-private
  */
-FocusTrapDirective.ctorParameters = function () { return [
-    { type: _angular_core.ElementRef, },
-    { type: FocusTrapFactory, },
-]; };
-FocusTrapDirective.propDecorators = {
-    'enabled': [{ type: _angular_core.Input, args: ['cdkTrapFocus',] },],
+var ARIA_DESCRIBER_PROVIDER = {
+    // If there is already an AriaDescriber available, use that. Otherwise, provide a new one.
+    provide: AriaDescriber,
+    deps: [
+        [new _angular_core.Optional(), new _angular_core.SkipSelf(), AriaDescriber],
+        _angular_cdk_platform.Platform
+    ],
+    useFactory: ARIA_DESCRIBER_PROVIDER_FACTORY
 };
-var LIVE_ANNOUNCER_ELEMENT_TOKEN = new _angular_core.InjectionToken('liveAnnouncerElement');
-var LiveAnnouncer = (function () {
+
+/**
+ * Screenreaders will often fire fake mousedown events when a focusable element
+ * is activated using the keyboard. We can typically distinguish between these faked
+ * mousedown events and real mousedown events using the "buttons" property. While
+ * real mousedowns will indicate the mouse button that was pressed (e.g. "1" for
+ * the left mouse button), faked mousedowns will usually set the property value to 0.
+ * @param {?} event
+ * @return {?}
+ */
+function isFakeMousedownFromScreenReader(event) {
+    return event.buttons === 0;
+}
+
+var FocusKeyManager = (function (_super) {
+    __extends(FocusKeyManager, _super);
+    function FocusKeyManager() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
     /**
-     * @param {?} elementToken
-     * @param {?} platform
+     * This method sets the active item to the item at the specified index.
+     * It also adds focuses the newly active item.
+     * @param {?} index
+     * @return {?}
      */
-    function LiveAnnouncer(elementToken, platform) {
-        // Only do anything if we're on the browser platform.
-        if (platform.isBrowser) {
-            // We inject the live element as `any` because the constructor signature cannot reference
-            // browser globals (HTMLElement) on non-browser environments, since having a class decorator
-            // causes TypeScript to preserve the constructor signature types.
-            this._liveElement = elementToken || this._createLiveElement();
+    FocusKeyManager.prototype.setActiveItem = function (index) {
+        _super.prototype.setActiveItem.call(this, index);
+        if (this.activeItem) {
+            this.activeItem.focus();
         }
+    };
+    return FocusKeyManager;
+}(ListKeyManager));
+
+/**
+ * Utility for checking the interactivity of an element, such as whether is is focusable or
+ * tabbable.
+ */
+var InteractivityChecker = (function () {
+    /**
+     * @param {?} _platform
+     */
+    function InteractivityChecker(_platform) {
+        this._platform = _platform;
     }
     /**
-     * Announces a message to screenreaders.
-     * @param {?} message Message to be announced to the screenreader
-     * @param {?=} politeness The politeness of the announcer element
-     * @return {?}
+     * Gets whether an element is disabled.
+     *
+     * @param {?} element Element to be checked.
+     * @return {?} Whether the element is disabled.
      */
-    LiveAnnouncer.prototype.announce = function (message, politeness) {
-        var _this = this;
-        if (politeness === void 0) { politeness = 'polite'; }
-        this._liveElement.textContent = '';
-        // 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).
-        setTimeout(function () { return _this._liveElement.textContent = message; }, 100);
+    InteractivityChecker.prototype.isDisabled = function (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');
     };
     /**
-     * @return {?}
+     * 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.
+     *
+     * @param {?} element
+     * @return {?} Whether the element is visible.
      */
-    LiveAnnouncer.prototype.ngOnDestroy = function () {
-        if (this._liveElement && this._liveElement.parentNode) {
-            this._liveElement.parentNode.removeChild(this._liveElement);
+    InteractivityChecker.prototype.isVisible = function (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.
+     * @return {?} Whether the element is tabbable.
+     */
+    InteractivityChecker.prototype.isTabbable = function (element) {
+        // Nothing is tabbable on the the server 😎
+        if (!this._platform.isBrowser) {
+            return false;
+        }
+        var /** @type {?} */ frameElement = (getWindow(element).frameElement);
+        if (frameElement) {
+            var /** @type {?} */ 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;
+            }
+        }
+        var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
+        var /** @type {?} */ 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;
+            }
+            else if (this._platform.BLINK) {
+                // In Blink <audio controls> elements are always tabbable.
+                return true;
+            }
+        }
+        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;
+            }
+        }
+        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;
     };
     /**
-     * @return {?}
+     * Gets whether an element can be focused by the user.
+     *
+     * @param {?} element Element to be checked.
+     * @return {?} Whether the element is focusable.
      */
-    LiveAnnouncer.prototype._createLiveElement = function () {
-        var /** @type {?} */ liveEl = document.createElement('div');
-        liveEl.classList.add('cdk-visually-hidden');
-        liveEl.setAttribute('aria-atomic', 'true');
-        liveEl.setAttribute('aria-live', 'polite');
-        document.body.appendChild(liveEl);
-        return liveEl;
+    InteractivityChecker.prototype.isFocusable = function (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);
     };
-    return LiveAnnouncer;
+    InteractivityChecker.decorators = [
+        { type: _angular_core.Injectable },
+    ];
+    /**
+     * @nocollapse
+     */
+    InteractivityChecker.ctorParameters = function () { return [
+        { type: _angular_cdk_platform.Platform, },
+    ]; };
+    return InteractivityChecker;
 }());
-LiveAnnouncer.decorators = [
-    { type: _angular_core.Injectable },
-];
-/**
- * @nocollapse
- */
-LiveAnnouncer.ctorParameters = function () { return [
-    { type: undefined, decorators: [{ type: _angular_core.Optional }, { type: _angular_core.Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] },] },
-    { type: _angular_cdk_platform.Platform, },
-]; };
 /**
- * \@docs-private
- * @param {?} parentDispatcher
- * @param {?} liveElement
- * @param {?} platform
+ * Checks whether the specified element has any geometry / rectangles.
+ * @param {?} element
  * @return {?}
  */
-function LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher, liveElement, platform) {
-    return parentDispatcher || new LiveAnnouncer(liveElement, platform);
+function hasGeometry(element) {
+    // Use logic from jQuery to check for an invisible element.
+    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
+    return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);
 }
 /**
- * \@docs-private
- */
-var LIVE_ANNOUNCER_PROVIDER = {
-    // If there is already a LiveAnnouncer available, use that. Otherwise, provide a new one.
-    provide: LiveAnnouncer,
-    deps: [
-        [new _angular_core.Optional(), new _angular_core.SkipSelf(), LiveAnnouncer],
-        [new _angular_core.Optional(), new _angular_core.Inject(LIVE_ANNOUNCER_ELEMENT_TOKEN)],
-        _angular_cdk_platform.Platform,
-    ],
-    useFactory: LIVE_ANNOUNCER_PROVIDER_FACTORY
-};
-/**
- * IDs are deliminated by an empty space, as per the spec.
+ * Gets whether an element's
+ * @param {?} element
+ * @return {?}
  */
-var ID_DELIMINATOR = ' ';
+function isNativeFormElement(element) {
+    var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
+    return nodeName === 'input' ||
+        nodeName === 'select' ||
+        nodeName === 'button' ||
+        nodeName === 'textarea';
+}
 /**
- * Adds the given ID to the specified ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- * @param {?} el
- * @param {?} attr
- * @param {?} id
+ * Gets whether an element is an <input type="hidden">.
+ * @param {?} element
  * @return {?}
  */
-function addAriaReferencedId(el, attr, id) {
-    var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
-    if (ids.some(function (existingId) { return existingId.trim() == id.trim(); })) {
-        return;
-    }
-    ids.push(id.trim());
-    el.setAttribute(attr, ids.join(ID_DELIMINATOR));
+function isHiddenInput(element) {
+    return isInputElement(element) && element.type == 'hidden';
 }
 /**
- * Removes the given ID from the specified ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- * @param {?} el
- * @param {?} attr
- * @param {?} id
+ * Gets whether an element is an anchor that has an href attribute.
+ * @param {?} element
  * @return {?}
  */
-function removeAriaReferencedId(el, attr, id) {
-    var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
-    var /** @type {?} */ filteredIds = ids.filter(function (val) { return val != id.trim(); });
-    el.setAttribute(attr, filteredIds.join(ID_DELIMINATOR));
+function isAnchorWithHref(element) {
+    return isAnchorElement(element) && element.hasAttribute('href');
 }
 /**
- * Gets the list of IDs referenced by the given ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- * @param {?} el
- * @param {?} attr
+ * Gets whether an element is an input element.
+ * @param {?} element
  * @return {?}
  */
-function getAriaReferenceIds(el, attr) {
-    // Get string array of all individual ids (whitespace deliminated) in the attribute value
-    return (el.getAttribute(attr) || '').match(/\S+/g) || [];
+function isInputElement(element) {
+    return element.nodeName.toLowerCase() == 'input';
 }
 /**
- * ID used for the body container where all messages are appended.
+ * Gets whether an element is an anchor element.
+ * @param {?} element
+ * @return {?}
  */
-var MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';
+function isAnchorElement(element) {
+    return element.nodeName.toLowerCase() == 'a';
+}
 /**
- * ID prefix used for each created message element.
+ * Gets whether an element has a valid tabindex.
+ * @param {?} element
+ * @return {?}
  */
-var CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';
+function hasValidTabIndex(element) {
+    if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
+        return false;
+    }
+    var /** @type {?} */ tabIndex = element.getAttribute('tabindex');
+    // IE11 parses tabindex="" as the value "-32768"
+    if (tabIndex == '-32768') {
+        return false;
+    }
+    return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+}
 /**
- * Attribute given to each host element that is described by a message element.
+ * Returns the parsed tabindex from the element attributes instead of returning the
+ * evaluated tabindex from the browsers defaults.
+ * @param {?} element
+ * @return {?}
  */
-var CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';
+function getTabIndexValue(element) {
+    if (!hasValidTabIndex(element)) {
+        return null;
+    }
+    // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+    var /** @type {?} */ tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
+    return isNaN(tabIndex) ? -1 : tabIndex;
+}
 /**
- * Global incremental identifier for each registered message element.
+ * Checks whether the specified element is potentially tabbable on iOS
+ * @param {?} element
+ * @return {?}
  */
-var nextId = 0;
+function isPotentiallyTabbableIOS(element) {
+    var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
+    var /** @type {?} */ inputType = nodeName === 'input' && ((element)).type;
+    return inputType === 'text'
+        || inputType === 'password'
+        || nodeName === 'select'
+        || nodeName === 'textarea';
+}
 /**
- * Global map of all registered message elements that have been placed into the document.
+ * Gets whether an element is potentially focusable without taking current visible/disabled state
+ * into account.
+ * @param {?} element
+ * @return {?}
  */
-var messageRegistry = new Map();
+function isPotentiallyFocusable(element) {
+    // Inputs are potentially focusable *unless* they're type="hidden".
+    if (isHiddenInput(element)) {
+        return false;
+    }
+    return isNativeFormElement(element) ||
+        isAnchorWithHref(element) ||
+        element.hasAttribute('contenteditable') ||
+        hasValidTabIndex(element);
+}
 /**
- * Container for all registered messages.
+ * Gets the parent window of a DOM node with regards of being inside of an iframe.
+ * @param {?} node
+ * @return {?}
  */
-var messagesContainer = null;
+function getWindow(node) {
+    return node.ownerDocument.defaultView || window;
+}
+
 /**
- * Utility that creates visually hidden elements with a message content. Useful for elements that
- * want to use aria-describedby to further describe themselves without adding additional visual
- * content.
- * \@docs-private
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * NOTE: This class currently uses a very simple (naive) approach to focus trapping.
+ * It assumes that the tab order is the same as DOM order, which is not necessarily true.
+ * Things like tabIndex > 0, flex `order`, and shadow roots can cause to two to misalign.
+ * This will be replaced with a more intelligent solution before the library is considered stable.
  */
-var AriaDescriber = (function () {
+var FocusTrap = (function () {
     /**
+     * @param {?} _element
      * @param {?} _platform
+     * @param {?} _checker
+     * @param {?} _ngZone
+     * @param {?=} deferAnchors
      */
-    function AriaDescriber(_platform) {
+    function FocusTrap(_element, _platform, _checker, _ngZone, deferAnchors) {
+        if (deferAnchors === void 0) { deferAnchors = false; }
+        this._element = _element;
         this._platform = _platform;
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._enabled = true;
+        if (!deferAnchors) {
+            this.attachAnchors();
+        }
     }
+    Object.defineProperty(FocusTrap.prototype, "enabled", {
+        /**
+         * Whether the focus trap is active.
+         * @return {?}
+         */
+        get: function () { return this._enabled; },
+        /**
+         * @param {?} val
+         * @return {?}
+         */
+        set: function (val) {
+            this._enabled = val;
+            if (this._startAnchor && this._endAnchor) {
+                this._startAnchor.tabIndex = this._endAnchor.tabIndex = this._enabled ? 0 : -1;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
-     * 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.
-     * @param {?} hostElement
-     * @param {?} message
+     * Destroys the focus trap by cleaning up the anchors.
      * @return {?}
      */
-    AriaDescriber.prototype.describe = function (hostElement, message) {
-        if (!this._platform.isBrowser || !message.trim()) {
+    FocusTrap.prototype.destroy = function () {
+        if (this._startAnchor && this._startAnchor.parentNode) {
+            this._startAnchor.parentNode.removeChild(this._startAnchor);
+        }
+        if (this._endAnchor && this._endAnchor.parentNode) {
+            this._endAnchor.parentNode.removeChild(this._endAnchor);
+        }
+        this._startAnchor = this._endAnchor = null;
+    };
+    /**
+     * Inserts the anchors into the DOM. This is usually done automatically
+     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+     * @return {?}
+     */
+    FocusTrap.prototype.attachAnchors = function () {
+        var _this = this;
+        // If we're not on the browser, there can be no focus to trap.
+        if (!this._platform.isBrowser) {
             return;
         }
-        if (!messageRegistry.has(message)) {
-            createMessageElement(message);
+        if (!this._startAnchor) {
+            this._startAnchor = this._createAnchor();
         }
-        if (!isElementDescribedByMessage(hostElement, message)) {
-            addMessageReference(hostElement, message);
+        if (!this._endAnchor) {
+            this._endAnchor = this._createAnchor();
         }
+        this._ngZone.runOutsideAngular(function () {
+            ((_this._startAnchor)).addEventListener('focus', function () {
+                _this.focusLastTabbableElement();
+            }); /** @type {?} */
+            ((_this._endAnchor)).addEventListener('focus', function () {
+                _this.focusFirstTabbableElement();
+            });
+            if (_this._element.parentNode) {
+                _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._startAnchor)), _this._element);
+                _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._endAnchor)), _this._element.nextSibling);
+            }
+        });
     };
     /**
-     * Removes the host element's aria-describedby reference to the message element.
-     * @param {?} hostElement
-     * @param {?} message
+     * Waits for the zone to stabilize, then either focuses the first element that the
+     * user specified, or the first tabbable element.
+     * @return {?} Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusInitialElementWhenReady = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _this._executeOnStable(function () { return resolve(_this.focusInitialElement()); });
+        });
+    };
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the first tabbable element within the focus trap region.
+     * @return {?} Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusFirstTabbableElementWhenReady = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _this._executeOnStable(function () { return resolve(_this.focusFirstTabbableElement()); });
+        });
+    };
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the last tabbable element within the focus trap region.
+     * @return {?} Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusLastTabbableElementWhenReady = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _this._executeOnStable(function () { return resolve(_this.focusLastTabbableElement()); });
+        });
+    };
+    /**
+     * Get the specified boundary element of the trapped region.
+     * @param {?} bound The boundary to get (start or end of trapped region).
+     * @return {?} The boundary element.
+     */
+    FocusTrap.prototype._getRegionBoundary = function (bound) {
+        // Contains the deprecated version of selector, for temporary backwards comparability.
+        var /** @type {?} */ markers = (this._element.querySelectorAll("[cdk-focus-region-" + bound + "], " +
+            ("[cdk-focus-" + bound + "]")));
+        for (var /** @type {?} */ i = 0; i < markers.length; i++) {
+            if (markers[i].hasAttribute("cdk-focus-" + bound)) {
+                console.warn("Found use of deprecated attribute 'cdk-focus-" + bound + "'," +
+                    (" use 'cdk-focus-region-" + bound + "' instead."), markers[i]);
+            }
+        }
+        if (bound == 'start') {
+            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
+        }
+        return markers.length ?
+            markers[markers.length - 1] : this._getLastTabbableElement(this._element);
+    };
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @return {?} Returns whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusInitialElement = function () {
+        var /** @type {?} */ redirectToElement = (this._element.querySelector('[cdk-focus-initial]'));
+        if (redirectToElement) {
+            redirectToElement.focus();
+            return true;
+        }
+        return this.focusFirstTabbableElement();
+    };
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @return {?} Returns whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusFirstTabbableElement = function () {
+        var /** @type {?} */ redirectToElement = this._getRegionBoundary('start');
+        if (redirectToElement) {
+            redirectToElement.focus();
+        }
+        return !!redirectToElement;
+    };
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @return {?} Returns whether focus was moved successfuly.
+     */
+    FocusTrap.prototype.focusLastTabbableElement = function () {
+        var /** @type {?} */ redirectToElement = this._getRegionBoundary('end');
+        if (redirectToElement) {
+            redirectToElement.focus();
+        }
+        return !!redirectToElement;
+    };
+    /**
+     * Get the first tabbable element from a DOM subtree (inclusive).
+     * @param {?} root
      * @return {?}
      */
-    AriaDescriber.prototype.removeDescription = function (hostElement, message) {
-        if (!this._platform.isBrowser || !message.trim()) {
-            return;
+    FocusTrap.prototype._getFirstTabbableElement = function (root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
         }
-        if (isElementDescribedByMessage(hostElement, message)) {
-            removeMessageReference(hostElement, message);
+        // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall
+        // back to `childNodes` which includes text nodes, comments etc.
+        var /** @type {?} */ children = root.children || root.childNodes;
+        for (var /** @type {?} */ i = 0; i < children.length; i++) {
+            var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?
+                this._getFirstTabbableElement(/** @type {?} */ (children[i])) :
+                null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
         }
-        var /** @type {?} */ registeredMessage = messageRegistry.get(message);
-        if (registeredMessage && registeredMessage.referenceCount === 0) {
-            deleteMessageElement(message);
+        return null;
+    };
+    /**
+     * Get the last tabbable element from a DOM subtree (inclusive).
+     * @param {?} root
+     * @return {?}
+     */
+    FocusTrap.prototype._getLastTabbableElement = function (root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
         }
-        if (messagesContainer && messagesContainer.childNodes.length === 0) {
-            deleteMessagesContainer();
+        // Iterate in reverse DOM order.
+        var /** @type {?} */ children = root.children || root.childNodes;
+        for (var /** @type {?} */ i = children.length - 1; i >= 0; i--) {
+            var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?
+                this._getLastTabbableElement(/** @type {?} */ (children[i])) :
+                null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
         }
+        return null;
     };
     /**
-     * Unregisters all created message elements and removes the message container.
+     * Creates an anchor element.
      * @return {?}
      */
-    AriaDescriber.prototype.ngOnDestroy = function () {
-        if (!this._platform.isBrowser) {
-            return;
-        }
-        var /** @type {?} */ describedElements = document.querySelectorAll("[" + CDK_DESCRIBEDBY_HOST_ATTRIBUTE + "]");
-        for (var /** @type {?} */ i = 0; i < describedElements.length; i++) {
-            removeCdkDescribedByReferenceIds(describedElements[i]);
-            describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+    FocusTrap.prototype._createAnchor = function () {
+        var /** @type {?} */ anchor = document.createElement('div');
+        anchor.tabIndex = this._enabled ? 0 : -1;
+        anchor.classList.add('cdk-visually-hidden');
+        anchor.classList.add('cdk-focus-trap-anchor');
+        return anchor;
+    };
+    /**
+     * Executes a function when the zone is stable.
+     * @param {?} fn
+     * @return {?}
+     */
+    FocusTrap.prototype._executeOnStable = function (fn) {
+        if (this._ngZone.isStable) {
+            fn();
         }
-        if (messagesContainer) {
-            deleteMessagesContainer();
+        else {
+            _angular_cdk_rxjs.first.call(this._ngZone.onStable.asObservable()).subscribe(fn);
         }
-        messageRegistry.clear();
     };
-    return AriaDescriber;
+    return FocusTrap;
 }());
-AriaDescriber.decorators = [
-    { type: _angular_core.Injectable },
-];
-/**
- * @nocollapse
- */
-AriaDescriber.ctorParameters = function () { return [
-    { type: _angular_cdk_platform.Platform, },
-]; };
-/**
- * Creates a new element in the visually hidden message container element with the message
- * as its content and adds it to the message registry.
- * @param {?} message
- * @return {?}
- */
-function createMessageElement(message) {
-    var /** @type {?} */ messageElement = document.createElement('div');
-    messageElement.setAttribute('id', CDK_DESCRIBEDBY_ID_PREFIX + "-" + nextId++);
-    messageElement.appendChild(/** @type {?} */ ((document.createTextNode(message))));
-    if (!messagesContainer) {
-        createMessagesContainer();
-    } /** @type {?} */
-    ((messagesContainer)).appendChild(messageElement);
-    messageRegistry.set(message, { messageElement: messageElement, referenceCount: 0 });
-}
-/**
- * Deletes the message element from the global messages container.
- * @param {?} message
- * @return {?}
- */
-function deleteMessageElement(message) {
-    var /** @type {?} */ registeredMessage = messageRegistry.get(message);
-    var /** @type {?} */ messageElement = registeredMessage && registeredMessage.messageElement;
-    if (messagesContainer && messageElement) {
-        messagesContainer.removeChild(messageElement);
-    }
-    messageRegistry.delete(message);
-}
-/**
- * Creates the global container for all aria-describedby messages.
- * @return {?}
- */
-function createMessagesContainer() {
-    messagesContainer = document.createElement('div');
-    messagesContainer.setAttribute('id', MESSAGES_CONTAINER_ID);
-    messagesContainer.setAttribute('aria-hidden', 'true');
-    messagesContainer.style.display = 'none';
-    document.body.appendChild(messagesContainer);
-}
-/**
- * Deletes the global messages container.
- * @return {?}
- */
-function deleteMessagesContainer() {
-    document.body.removeChild(/** @type {?} */ ((messagesContainer)));
-    messagesContainer = null;
-}
-/**
- * Removes all cdk-describedby messages that are hosted through the element.
- * @param {?} element
- * @return {?}
- */
-function removeCdkDescribedByReferenceIds(element) {
-    // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
-    var /** @type {?} */ originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
-        .filter(function (id) { return 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.
- * @param {?} element
- * @param {?} message
- * @return {?}
- */
-function addMessageReference(element, message) {
-    var /** @type {?} */ 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.
- * @param {?} element
- * @param {?} message
- * @return {?}
- */
-function removeMessageReference(element, message) {
-    var /** @type {?} */ 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.
- * @param {?} element
- * @param {?} message
- * @return {?}
- */
-function isElementDescribedByMessage(element, message) {
-    var /** @type {?} */ referenceIds = getAriaReferenceIds(element, 'aria-describedby');
-    var /** @type {?} */ registeredMessage = messageRegistry.get(message);
-    var /** @type {?} */ messageId = registeredMessage && registeredMessage.messageElement.id;
-    return !!messageId && referenceIds.indexOf(messageId) != -1;
-}
-/**
- * \@docs-private
- * @param {?} parentDispatcher
- * @param {?} platform
- * @return {?}
- */
-function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher, platform) {
-    return parentDispatcher || new AriaDescriber(platform);
-}
 /**
- * \@docs-private
- */
-var ARIA_DESCRIBER_PROVIDER = {
-    // If there is already an AriaDescriber available, use that. Otherwise, provide a new one.
-    provide: AriaDescriber,
-    deps: [
-        [new _angular_core.Optional(), new _angular_core.SkipSelf(), AriaDescriber],
-        _angular_cdk_platform.Platform
-    ],
-    useFactory: ARIA_DESCRIBER_PROVIDER_FACTORY
-};
-// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
-// that a value of around 650ms seems appropriate.
-var TOUCH_BUFFER_MS = 650;
-/**
- * Monitors mouse and keyboard events to determine the cause of focus events.
+ * Factory that allows easy instantiation of focus traps.
  */
-var FocusMonitor = (function () {
+var FocusTrapFactory = (function () {
     /**
-     * @param {?} _ngZone
+     * @param {?} _checker
      * @param {?} _platform
+     * @param {?} _ngZone
      */
-    function FocusMonitor(_ngZone, _platform) {
-        var _this = this;
-        this._ngZone = _ngZone;
+    function FocusTrapFactory(_checker, _platform, _ngZone) {
+        this._checker = _checker;
         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;
-        /**
-         * Weak map of elements being monitored to their info.
-         */
-        this._elementInfo = new WeakMap();
-        this._ngZone.runOutsideAngular(function () { return _this._registerDocumentEvents(); });
+        this._ngZone = _ngZone;
     }
     /**
-     * Monitors focus on an element and applies appropriate CSS classes.
-     * @param {?} element The element to monitor
-     * @param {?} renderer The renderer to use to apply CSS classes to the element.
-     * @param {?} checkChildren Whether to count the element as focused when its children are focused.
-     * @return {?} An observable that emits when the focus state of the element changes.
-     *     When the element is blurred, null will be emitted.
+     * @param {?} element
+     * @param {?=} deferAnchors
+     * @return {?}
      */
-    FocusMonitor.prototype.monitor = function (element, renderer, checkChildren) {
-        var _this = this;
-        // Do nothing if we're not on the browser platform.
-        if (!this._platform.isBrowser) {
-            return rxjs_observable_of.of(null);
-        }
-        // Check if we're already monitoring this element.
-        if (this._elementInfo.has(element)) {
-            var /** @type {?} */ cachedInfo = this._elementInfo.get(element); /** @type {?} */
-            ((cachedInfo)).checkChildren = checkChildren;
-            return ((cachedInfo)).subject.asObservable();
-        }
-        // Create monitored element info.
-        var /** @type {?} */ info = {
-            unlisten: function () { },
-            checkChildren: checkChildren,
-            renderer: renderer,
-            subject: new rxjs_Subject.Subject()
-        };
-        this._elementInfo.set(element, info);
-        // Start listening. We need to listen in capture phase since focus events don't bubble.
-        var /** @type {?} */ focusListener = function (event) { return _this._onFocus(event, element); };
-        var /** @type {?} */ blurListener = function (event) { return _this._onBlur(event, element); };
-        this._ngZone.runOutsideAngular(function () {
-            element.addEventListener('focus', focusListener, true);
-            element.addEventListener('blur', blurListener, true);
-        });
-        // Create an unlisten function for later.
-        info.unlisten = function () {
-            element.removeEventListener('focus', focusListener, true);
-            element.removeEventListener('blur', blurListener, true);
-        };
-        return info.subject.asObservable();
+    FocusTrapFactory.prototype.create = function (element, deferAnchors) {
+        if (deferAnchors === void 0) { deferAnchors = false; }
+        return new FocusTrap(element, this._platform, this._checker, this._ngZone, deferAnchors);
     };
+    FocusTrapFactory.decorators = [
+        { type: _angular_core.Injectable },
+    ];
+    /**
+     * @nocollapse
+     */
+    FocusTrapFactory.ctorParameters = function () { return [
+        { type: InteractivityChecker, },
+        { type: _angular_cdk_platform.Platform, },
+        { type: _angular_core.NgZone, },
+    ]; };
+    return FocusTrapFactory;
+}());
+/**
+ * Directive for trapping focus within a region.
+ * @deprecated
+ */
+var FocusTrapDeprecatedDirective = (function () {
+    /**
+     * @param {?} _elementRef
+     * @param {?} _focusTrapFactory
+     */
+    function FocusTrapDeprecatedDirective(_elementRef, _focusTrapFactory) {
+        this._elementRef = _elementRef;
+        this._focusTrapFactory = _focusTrapFactory;
+        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+    }
+    Object.defineProperty(FocusTrapDeprecatedDirective.prototype, "disabled", {
+        /**
+         * Whether the focus trap is active.
+         * @return {?}
+         */
+        get: function () { return !this.focusTrap.enabled; },
+        /**
+         * @param {?} val
+         * @return {?}
+         */
+        set: function (val) {
+            this.focusTrap.enabled = !_angular_cdk_coercion.coerceBooleanProperty(val);
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
-     * Stops monitoring an element and removes all focus classes.
-     * @param {?} element The element to stop monitoring.
      * @return {?}
      */
-    FocusMonitor.prototype.stopMonitoring = function (element) {
-        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
-        if (elementInfo) {
-            elementInfo.unlisten();
-            elementInfo.subject.complete();
-            this._setClasses(element);
-            this._elementInfo.delete(element);
-        }
+    FocusTrapDeprecatedDirective.prototype.ngOnDestroy = function () {
+        this.focusTrap.destroy();
     };
     /**
-     * Focuses the element via the specified focus origin.
-     * @param {?} element The element to focus.
-     * @param {?} origin The focus origin.
      * @return {?}
      */
-    FocusMonitor.prototype.focusVia = function (element, origin) {
-        this._setOriginForCurrentEventQueue(origin);
-        element.focus();
+    FocusTrapDeprecatedDirective.prototype.ngAfterContentInit = function () {
+        this.focusTrap.attachAnchors();
     };
+    FocusTrapDeprecatedDirective.decorators = [
+        { type: _angular_core.Directive, args: [{
+                    selector: 'cdk-focus-trap',
+                },] },
+    ];
     /**
-     * Register necessary event listeners on the document and window.
-     * @return {?}
+     * @nocollapse
      */
-    FocusMonitor.prototype._registerDocumentEvents = function () {
-        var _this = this;
-        // Do nothing if we're not on the browser platform.
-        if (!this._platform.isBrowser) {
-            return;
-        }
-        // Note: we listen to events in the capture phase so we can detect them even if the user stops
-        // propagation.
-        // On keydown record the origin and clear any touch event that may be in progress.
-        document.addEventListener('keydown', function () {
-            _this._lastTouchTarget = null;
-            _this._setOriginForCurrentEventQueue('keyboard');
-        }, true);
-        // On mousedown record the origin only if there is not touch target, since a mousedown can
-        // happen as a result of a touch event.
-        document.addEventListener('mousedown', function () {
-            if (!_this._lastTouchTarget) {
-                _this._setOriginForCurrentEventQueue('mouse');
-            }
-        }, true);
-        // 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 0ms). Instead we wait 650ms to
-        // see if a focus happens.
-        document.addEventListener('touchstart', function (event) {
-            if (_this._touchTimeout != null) {
-                clearTimeout(_this._touchTimeout);
-            }
-            _this._lastTouchTarget = event.target;
-            _this._touchTimeout = setTimeout(function () { return _this._lastTouchTarget = null; }, TOUCH_BUFFER_MS);
-        }, true);
-        // Make a note of when the window regains focus, so we can restore the origin info for the
-        // focused element.
-        window.addEventListener('focus', function () {
-            _this._windowFocused = true;
-            setTimeout(function () { return _this._windowFocused = false; }, 0);
-        });
+    FocusTrapDeprecatedDirective.ctorParameters = function () { return [
+        { type: _angular_core.ElementRef, },
+        { type: FocusTrapFactory, },
+    ]; };
+    FocusTrapDeprecatedDirective.propDecorators = {
+        'disabled': [{ type: _angular_core.Input },],
     };
+    return FocusTrapDeprecatedDirective;
+}());
+/**
+ * Directive for trapping focus within a region.
+ */
+var FocusTrapDirective = (function () {
+    /**
+     * @param {?} _elementRef
+     * @param {?} _focusTrapFactory
+     */
+    function FocusTrapDirective(_elementRef, _focusTrapFactory) {
+        this._elementRef = _elementRef;
+        this._focusTrapFactory = _focusTrapFactory;
+        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+    }
+    Object.defineProperty(FocusTrapDirective.prototype, "enabled", {
+        /**
+         * Whether the focus trap is active.
+         * @return {?}
+         */
+        get: function () { return this.focusTrap.enabled; },
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        set: function (value) { this.focusTrap.enabled = _angular_cdk_coercion.coerceBooleanProperty(value); },
+        enumerable: true,
+        configurable: true
+    });
     /**
-     * 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.
      * @return {?}
      */
-    FocusMonitor.prototype._setClasses = function (element, origin) {
-        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
-        if (elementInfo) {
-            var /** @type {?} */ toggleClass = function (className, shouldSet) {
-                shouldSet ? elementInfo.renderer.addClass(element, className) :
-                    elementInfo.renderer.removeClass(element, className);
-            };
-            toggleClass('cdk-focused', !!origin);
-            toggleClass('cdk-touch-focused', origin === 'touch');
-            toggleClass('cdk-keyboard-focused', origin === 'keyboard');
-            toggleClass('cdk-mouse-focused', origin === 'mouse');
-            toggleClass('cdk-program-focused', origin === 'program');
-        }
+    FocusTrapDirective.prototype.ngOnDestroy = function () {
+        this.focusTrap.destroy();
     };
     /**
-     * Sets the origin and schedules an async function to clear it at the end of the event queue.
-     * @param {?} origin The origin to set.
      * @return {?}
      */
-    FocusMonitor.prototype._setOriginForCurrentEventQueue = function (origin) {
-        var _this = this;
-        this._origin = origin;
-        setTimeout(function () { return _this._origin = null; }, 0);
+    FocusTrapDirective.prototype.ngAfterContentInit = function () {
+        this.focusTrap.attachAnchors();
     };
+    FocusTrapDirective.decorators = [
+        { type: _angular_core.Directive, args: [{
+                    selector: '[cdkTrapFocus]',
+                    exportAs: 'cdkTrapFocus',
+                },] },
+    ];
     /**
-     * Checks whether the given focus event was caused by a touchstart event.
-     * @param {?} event The focus event to check.
-     * @return {?} Whether the event was caused by a touch.
+     * @nocollapse
      */
-    FocusMonitor.prototype._wasCausedByTouch = function (event) {
-        // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
-        // Consider the following dom structure:
-        //
-        // <div #parent tabindex="0" cdkFocusClasses>
-        //   <div #child (click)="#parent.focus()"></div>
-        // </div>
-        //
-        // If the user touches the #child element and the #parent is programmatically focused as a
-        // result, this code will still consider it to have been caused by the touch event and will
-        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
-        // relatively small edge-case that can be worked around by using
-        // focusVia(parentEl, renderer,  'program') to focus the parent element.
-        //
-        // If we decide that we absolutely must handle this case correctly, we can do so by listening
-        // for the first focus event after the touchstart, and then the first blur event after that
-        // focus event. When that blur event fires we know that whatever follows is not a result of the
-        // touchstart.
-        var /** @type {?} */ focusTarget = event.target;
-        return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
-            (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
+    FocusTrapDirective.ctorParameters = function () { return [
+        { type: _angular_core.ElementRef, },
+        { type: FocusTrapFactory, },
+    ]; };
+    FocusTrapDirective.propDecorators = {
+        'enabled': [{ type: _angular_core.Input, args: ['cdkTrapFocus',] },],
     };
+    return FocusTrapDirective;
+}());
+
+var LIVE_ANNOUNCER_ELEMENT_TOKEN = new _angular_core.InjectionToken('liveAnnouncerElement');
+var LiveAnnouncer = (function () {
     /**
-     * Handles focus events on a registered element.
-     * @param {?} event The focus event.
-     * @param {?} element The monitored element.
-     * @return {?}
+     * @param {?} elementToken
+     * @param {?} platform
      */
-    FocusMonitor.prototype._onFocus = function (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.
-        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
-        if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {
-            return;
-        }
-        // If we couldn't detect a cause for the focus event, it's due to one of three reasons:
-        // 1) The window has just regained focus, in which case we want to restore the focused state of
-        //    the element from before the window blurred.
-        // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.
-        // 3) The element was programmatically focused, in which case we should mark the origin as
-        //    'program'.
-        if (!this._origin) {
-            if (this._windowFocused && this._lastFocusOrigin) {
-                this._origin = this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                this._origin = 'touch';
-            }
-            else {
-                this._origin = 'program';
-            }
+    function LiveAnnouncer(elementToken, platform) {
+        // Only do anything if we're on the browser platform.
+        if (platform.isBrowser) {
+            // We inject the live element as `any` because the constructor signature cannot reference
+            // browser globals (HTMLElement) on non-browser environments, since having a class decorator
+            // causes TypeScript to preserve the constructor signature types.
+            this._liveElement = elementToken || this._createLiveElement();
         }
-        this._setClasses(element, this._origin);
-        elementInfo.subject.next(this._origin);
-        this._lastFocusOrigin = this._origin;
-        this._origin = null;
+    }
+    /**
+     * Announces a message to screenreaders.
+     * @param {?} message Message to be announced to the screenreader
+     * @param {?=} politeness The politeness of the announcer element
+     * @return {?}
+     */
+    LiveAnnouncer.prototype.announce = function (message, politeness) {
+        var _this = this;
+        if (politeness === void 0) { politeness = 'polite'; }
+        this._liveElement.textContent = '';
+        // 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).
+        setTimeout(function () { return _this._liveElement.textContent = message; }, 100);
     };
     /**
-     * Handles blur events on a registered element.
-     * @param {?} event The blur event.
-     * @param {?} element The monitored element.
      * @return {?}
      */
-    FocusMonitor.prototype._onBlur = function (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.
-        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
-        if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
-            element.contains(event.relatedTarget))) {
-            return;
+    LiveAnnouncer.prototype.ngOnDestroy = function () {
+        if (this._liveElement && this._liveElement.parentNode) {
+            this._liveElement.parentNode.removeChild(this._liveElement);
         }
-        this._setClasses(element);
-        elementInfo.subject.next(null);
     };
-    return FocusMonitor;
-}());
-FocusMonitor.decorators = [
-    { type: _angular_core.Injectable },
-];
-/**
- * @nocollapse
- */
-FocusMonitor.ctorParameters = function () { return [
-    { type: _angular_core.NgZone, },
-    { type: _angular_cdk_platform.Platform, },
-]; };
-/**
- * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
- * programmatically) and adds corresponding classes to the element.
- *
- * There are two variants of this directive:
- * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
- *    focused.
- * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
- */
-var CdkMonitorFocus = (function () {
     /**
-     * @param {?} _elementRef
-     * @param {?} _focusMonitor
-     * @param {?} renderer
+     * @return {?}
      */
-    function CdkMonitorFocus(_elementRef, _focusMonitor, renderer) {
-        var _this = this;
-        this._elementRef = _elementRef;
-        this._focusMonitor = _focusMonitor;
-        this.cdkFocusChange = new _angular_core.EventEmitter();
-        this._monitorSubscription = this._focusMonitor.monitor(this._elementRef.nativeElement, renderer, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
-            .subscribe(function (origin) { return _this.cdkFocusChange.emit(origin); });
-    }
+    LiveAnnouncer.prototype._createLiveElement = function () {
+        var /** @type {?} */ liveEl = document.createElement('div');
+        liveEl.classList.add('cdk-visually-hidden');
+        liveEl.setAttribute('aria-atomic', 'true');
+        liveEl.setAttribute('aria-live', 'polite');
+        document.body.appendChild(liveEl);
+        return liveEl;
+    };
+    LiveAnnouncer.decorators = [
+        { type: _angular_core.Injectable },
+    ];
     /**
-     * @return {?}
+     * @nocollapse
      */
-    CdkMonitorFocus.prototype.ngOnDestroy = function () {
-        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);
-        this._monitorSubscription.unsubscribe();
-    };
-    return CdkMonitorFocus;
+    LiveAnnouncer.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: _angular_core.Optional }, { type: _angular_core.Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] },] },
+        { type: _angular_cdk_platform.Platform, },
+    ]; };
+    return LiveAnnouncer;
 }());
-CdkMonitorFocus.decorators = [
-    { type: _angular_core.Directive, args: [{
-                selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
-            },] },
-];
-/**
- * @nocollapse
- */
-CdkMonitorFocus.ctorParameters = function () { return [
-    { type: _angular_core.ElementRef, },
-    { type: FocusMonitor, },
-    { type: _angular_core.Renderer2, },
-]; };
-CdkMonitorFocus.propDecorators = {
-    'cdkFocusChange': [{ type: _angular_core.Output },],
-};
 /**
  * \@docs-private
  * @param {?} parentDispatcher
- * @param {?} ngZone
+ * @param {?} liveElement
  * @param {?} platform
  * @return {?}
  */
-function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {
-    return parentDispatcher || new FocusMonitor(ngZone, platform);
+function LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher, liveElement, platform) {
+    return parentDispatcher || new LiveAnnouncer(liveElement, platform);
 }
 /**
  * \@docs-private
  */
-var FOCUS_MONITOR_PROVIDER = {
-    // If there is already a FocusMonitor available, use that. Otherwise, provide a new one.
-    provide: FocusMonitor,
-    deps: [[new _angular_core.Optional(), new _angular_core.SkipSelf(), FocusMonitor], _angular_core.NgZone, _angular_cdk_platform.Platform],
-    useFactory: FOCUS_MONITOR_PROVIDER_FACTORY
+var LIVE_ANNOUNCER_PROVIDER = {
+    // If there is already a LiveAnnouncer available, use that. Otherwise, provide a new one.
+    provide: LiveAnnouncer,
+    deps: [
+        [new _angular_core.Optional(), new _angular_core.SkipSelf(), LiveAnnouncer],
+        [new _angular_core.Optional(), new _angular_core.Inject(LIVE_ANNOUNCER_ELEMENT_TOKEN)],
+        _angular_cdk_platform.Platform,
+    ],
+    useFactory: LIVE_ANNOUNCER_PROVIDER_FACTORY
 };
+
+// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
+// that a value of around 650ms seems appropriate.
+var TOUCH_BUFFER_MS = 650;
 /**
- * This class manages keyboard events for selectable lists. If you pass it a query list
- * of items, it will set the active item correctly when arrow events occur.
+ * Monitors mouse and keyboard events to determine the cause of focus events.
  */
-var ListKeyManager = (function () {
+var FocusMonitor = (function () {
     /**
-     * @param {?} _items
+     * @param {?} _ngZone
+     * @param {?} _platform
      */
-    function ListKeyManager(_items) {
-        this._items = _items;
-        this._activeItemIndex = -1;
-        this._wrap = false;
-        this._letterKeyStream = new rxjs_Subject.Subject();
-        this._typeaheadSubscription = rxjs_Subscription.Subscription.EMPTY;
-        this._pressedLetters = [];
+    function FocusMonitor(_ngZone, _platform) {
+        var _this = this;
+        this._ngZone = _ngZone;
+        this._platform = _platform;
         /**
-         * Stream that emits any time the TAB key is pressed, so components can react
-         * when focus is shifted off of the list.
+         * The focus origin that the next focus event is a result of.
          */
-        this.tabOut = new rxjs_Subject.Subject();
+        this._origin = null;
+        /**
+         * Whether the window has just been focused.
+         */
+        this._windowFocused = false;
+        /**
+         * Weak map of elements being monitored to their info.
+         */
+        this._elementInfo = new WeakMap();
+        this._ngZone.runOutsideAngular(function () { return _this._registerDocumentEvents(); });
     }
     /**
-     * Turns on wrapping mode, which ensures that the active item will wrap to
-     * the other end of list when there are no more items in the given direction.
-     * @return {?}
-     */
-    ListKeyManager.prototype.withWrap = function () {
-        this._wrap = true;
-        return this;
-    };
-    /**
-     * Turns on typeahead mode which allows users to set the active item by typing.
-     * @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.
-     * @return {?}
+     * Monitors focus on an element and applies appropriate CSS classes.
+     * @param {?} element The element to monitor
+     * @param {?} renderer The renderer to use to apply CSS classes to the element.
+     * @param {?} checkChildren Whether to count the element as focused when its children are focused.
+     * @return {?} An observable that emits when the focus state of the element changes.
+     *     When the element is blurred, null will be emitted.
      */
-    ListKeyManager.prototype.withTypeAhead = function (debounceInterval) {
+    FocusMonitor.prototype.monitor = function (element, renderer, checkChildren) {
         var _this = this;
-        if (debounceInterval === void 0) { debounceInterval = 200; }
-        if (this._items.length && this._items.some(function (item) { return typeof item.getLabel !== 'function'; })) {
-            throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');
+        // Do nothing if we're not on the browser platform.
+        if (!this._platform.isBrowser) {
+            return rxjs_observable_of.of(null);
         }
-        this._typeaheadSubscription.unsubscribe();
-        // Debounce the presses of non-navigational keys, collect the ones that correspond to letters
-        // and convert those letters back into a string. Afterwards find the first item that starts
-        // with that string and select it.
-        this._typeaheadSubscription = _angular_cdk_rxjs.RxChain.from(this._letterKeyStream)
-            .call(_angular_cdk_rxjs.doOperator, function (keyCode) { return _this._pressedLetters.push(keyCode); })
-            .call(_angular_cdk_rxjs.debounceTime, debounceInterval)
-            .call(_angular_cdk_rxjs.filter, function () { return _this._pressedLetters.length > 0; })
-            .call(_angular_cdk_rxjs.map, function () { return _this._pressedLetters.join(''); })
-            .subscribe(function (inputString) {
-            var /** @type {?} */ items = _this._items.toArray();
-            for (var /** @type {?} */ i = 0; i < items.length; i++) {
-                if (((items[i].getLabel))().toUpperCase().trim().indexOf(inputString) === 0) {
-                    _this.setActiveItem(i);
-                    break;
-                }
-            }
-            _this._pressedLetters = [];
+        // Check if we're already monitoring this element.
+        if (this._elementInfo.has(element)) {
+            var /** @type {?} */ cachedInfo = this._elementInfo.get(element); /** @type {?} */
+            ((cachedInfo)).checkChildren = checkChildren;
+            return ((cachedInfo)).subject.asObservable();
+        }
+        // Create monitored element info.
+        var /** @type {?} */ info = {
+            unlisten: function () { },
+            checkChildren: checkChildren,
+            renderer: renderer,
+            subject: new rxjs_Subject.Subject()
+        };
+        this._elementInfo.set(element, info);
+        // Start listening. We need to listen in capture phase since focus events don't bubble.
+        var /** @type {?} */ focusListener = function (event) { return _this._onFocus(event, element); };
+        var /** @type {?} */ blurListener = function (event) { return _this._onBlur(event, element); };
+        this._ngZone.runOutsideAngular(function () {
+            element.addEventListener('focus', focusListener, true);
+            element.addEventListener('blur', blurListener, true);
         });
-        return this;
-    };
-    /**
-     * Sets the active item to the item at the index specified.
-     * @param {?} index The index of the item to be set as active.
-     * @return {?}
-     */
-    ListKeyManager.prototype.setActiveItem = function (index) {
-        this._activeItemIndex = index;
-        this._activeItem = this._items.toArray()[index];
+        // Create an unlisten function for later.
+        info.unlisten = function () {
+            element.removeEventListener('focus', focusListener, true);
+            element.removeEventListener('blur', blurListener, true);
+        };
+        return info.subject.asObservable();
     };
     /**
-     * Sets the active item depending on the key event passed in.
-     * @param {?} event Keyboard event to be used for determining which element should be active.
+     * Stops monitoring an element and removes all focus classes.
+     * @param {?} element The element to stop monitoring.
      * @return {?}
      */
-    ListKeyManager.prototype.onKeydown = function (event) {
-        switch (event.keyCode) {
-            case _angular_cdk_keycodes.DOWN_ARROW:
-                this.setNextItemActive();
-                break;
-            case _angular_cdk_keycodes.UP_ARROW:
-                this.setPreviousItemActive();
-                break;
-            case _angular_cdk_keycodes.TAB:
-                this.tabOut.next();
-                return;
-            default:
-                var /** @type {?} */ keyCode = event.keyCode;
-                // Attempt to use the `event.key` which also maps it to the user's keyboard language,
-                // otherwise fall back to resolving alphanumeric characters via the keyCode.
-                if (event.key && event.key.length === 1) {
-                    this._letterKeyStream.next(event.key.toLocaleUpperCase());
-                }
-                else if ((keyCode >= _angular_cdk_keycodes.A && keyCode <= _angular_cdk_keycodes.Z) || (keyCode >= _angular_cdk_keycodes.ZERO && keyCode <= _angular_cdk_keycodes.NINE)) {
-                    this._letterKeyStream.next(String.fromCharCode(keyCode));
-                }
-                // Note that we return here, in order to avoid preventing
-                // the default action of non-navigational keys.
-                return;
+    FocusMonitor.prototype.stopMonitoring = function (element) {
+        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
+        if (elementInfo) {
+            elementInfo.unlisten();
+            elementInfo.subject.complete();
+            this._setClasses(element);
+            this._elementInfo.delete(element);
         }
-        this._pressedLetters = [];
-        event.preventDefault();
-    };
-    Object.defineProperty(ListKeyManager.prototype, "activeItemIndex", {
-        /**
-         * Index of the currently active item.
-         * @return {?}
-         */
-        get: function () {
-            return this._activeItemIndex;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ListKeyManager.prototype, "activeItem", {
-        /**
-         * The active item.
-         * @return {?}
-         */
-        get: function () {
-            return this._activeItem;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Sets the active item to the first enabled item in the list.
-     * @return {?}
-     */
-    ListKeyManager.prototype.setFirstItemActive = function () {
-        this._setActiveItemByIndex(0, 1);
     };
     /**
-     * Sets the active item to the last enabled item in the list.
+     * Focuses the element via the specified focus origin.
+     * @param {?} element The element to focus.
+     * @param {?} origin The focus origin.
      * @return {?}
      */
-    ListKeyManager.prototype.setLastItemActive = function () {
-        this._setActiveItemByIndex(this._items.length - 1, -1);
+    FocusMonitor.prototype.focusVia = function (element, origin) {
+        this._setOriginForCurrentEventQueue(origin);
+        element.focus();
     };
     /**
-     * Sets the active item to the next enabled item in the list.
+     * Register necessary event listeners on the document and window.
      * @return {?}
      */
-    ListKeyManager.prototype.setNextItemActive = function () {
-        this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);
+    FocusMonitor.prototype._registerDocumentEvents = function () {
+        var _this = this;
+        // Do nothing if we're not on the browser platform.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Note: we listen to events in the capture phase so we can detect them even if the user stops
+        // propagation.
+        // On keydown record the origin and clear any touch event that may be in progress.
+        document.addEventListener('keydown', function () {
+            _this._lastTouchTarget = null;
+            _this._setOriginForCurrentEventQueue('keyboard');
+        }, true);
+        // On mousedown record the origin only if there is not touch target, since a mousedown can
+        // happen as a result of a touch event.
+        document.addEventListener('mousedown', function () {
+            if (!_this._lastTouchTarget) {
+                _this._setOriginForCurrentEventQueue('mouse');
+            }
+        }, true);
+        // 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 0ms). Instead we wait 650ms to
+        // see if a focus happens.
+        document.addEventListener('touchstart', function (event) {
+            if (_this._touchTimeout != null) {
+                clearTimeout(_this._touchTimeout);
+            }
+            _this._lastTouchTarget = event.target;
+            _this._touchTimeout = setTimeout(function () { return _this._lastTouchTarget = null; }, TOUCH_BUFFER_MS);
+        }, true);
+        // Make a note of when the window regains focus, so we can restore the origin info for the
+        // focused element.
+        window.addEventListener('focus', function () {
+            _this._windowFocused = true;
+            setTimeout(function () { return _this._windowFocused = false; }, 0);
+        });
     };
     /**
-     * Sets the active item to a previous enabled item in the list.
+     * 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.
      * @return {?}
      */
-    ListKeyManager.prototype.setPreviousItemActive = function () {
-        this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()
-            : this._setActiveItemByDelta(-1);
+    FocusMonitor.prototype._setClasses = function (element, origin) {
+        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
+        if (elementInfo) {
+            var /** @type {?} */ toggleClass = function (className, shouldSet) {
+                shouldSet ? elementInfo.renderer.addClass(element, className) :
+                    elementInfo.renderer.removeClass(element, className);
+            };
+            toggleClass('cdk-focused', !!origin);
+            toggleClass('cdk-touch-focused', origin === 'touch');
+            toggleClass('cdk-keyboard-focused', origin === 'keyboard');
+            toggleClass('cdk-mouse-focused', origin === 'mouse');
+            toggleClass('cdk-program-focused', origin === 'program');
+        }
     };
     /**
-     * Allows setting of the activeItemIndex without any other effects.
-     * @param {?} index The new activeItemIndex.
+     * Sets the origin and schedules an async function to clear it at the end of the event queue.
+     * @param {?} origin The origin to set.
      * @return {?}
      */
-    ListKeyManager.prototype.updateActiveItemIndex = function (index) {
-        this._activeItemIndex = index;
+    FocusMonitor.prototype._setOriginForCurrentEventQueue = function (origin) {
+        var _this = this;
+        this._origin = origin;
+        setTimeout(function () { return _this._origin = null; }, 0);
     };
     /**
-     * This method sets the active item, given a list of items and the delta between the
-     * currently active item and the new active item. It will calculate differently
-     * depending on whether wrap mode is turned on.
-     * @param {?} delta
-     * @param {?=} items
-     * @return {?}
+     * Checks whether the given focus event was caused by a touchstart event.
+     * @param {?} event The focus event to check.
+     * @return {?} Whether the event was caused by a touch.
      */
-    ListKeyManager.prototype._setActiveItemByDelta = function (delta, items) {
-        if (items === void 0) { items = this._items.toArray(); }
-        this._wrap ? this._setActiveInWrapMode(delta, items)
-            : this._setActiveInDefaultMode(delta, items);
+    FocusMonitor.prototype._wasCausedByTouch = function (event) {
+        // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
+        // Consider the following dom structure:
+        //
+        // <div #parent tabindex="0" cdkFocusClasses>
+        //   <div #child (click)="#parent.focus()"></div>
+        // </div>
+        //
+        // If the user touches the #child element and the #parent is programmatically focused as a
+        // result, this code will still consider it to have been caused by the touch event and will
+        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
+        // relatively small edge-case that can be worked around by using
+        // focusVia(parentEl, renderer,  'program') to focus the parent element.
+        //
+        // If we decide that we absolutely must handle this case correctly, we can do so by listening
+        // for the first focus event after the touchstart, and then the first blur event after that
+        // focus event. When that blur event fires we know that whatever follows is not a result of the
+        // touchstart.
+        var /** @type {?} */ focusTarget = event.target;
+        return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
+            (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
     };
     /**
-     * Sets the active item properly given "wrap" mode. In other words, it will continue to move
-     * down the list until it finds an item that is not disabled, and it will wrap if it
-     * encounters either end of the list.
-     * @param {?} delta
-     * @param {?} items
+     * Handles focus events on a registered element.
+     * @param {?} event The focus event.
+     * @param {?} element The monitored element.
      * @return {?}
      */
-    ListKeyManager.prototype._setActiveInWrapMode = function (delta, items) {
-        // when active item would leave menu, wrap to beginning or end
-        this._activeItemIndex =
-            (this._activeItemIndex + delta + items.length) % items.length;
-        // skip all disabled menu items recursively until an enabled one is reached
-        if (items[this._activeItemIndex].disabled) {
-            this._setActiveInWrapMode(delta, items);
+    FocusMonitor.prototype._onFocus = function (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.
+        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {
+            return;
         }
-        else {
-            this.setActiveItem(this._activeItemIndex);
+        // 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) {
+            if (this._windowFocused && this._lastFocusOrigin) {
+                this._origin = this._lastFocusOrigin;
+            }
+            else if (this._wasCausedByTouch(event)) {
+                this._origin = 'touch';
+            }
+            else {
+                this._origin = 'program';
+            }
         }
+        this._setClasses(element, this._origin);
+        elementInfo.subject.next(this._origin);
+        this._lastFocusOrigin = this._origin;
+        this._origin = null;
     };
     /**
-     * Sets the active item properly given the default mode. In other words, it will
-     * continue to move down the list until it finds an item that is not disabled. If
-     * it encounters either end of the list, it will stop and not wrap.
-     * @param {?} delta
-     * @param {?} items
-     * @return {?}
-     */
-    ListKeyManager.prototype._setActiveInDefaultMode = function (delta, items) {
-        this._setActiveItemByIndex(this._activeItemIndex + delta, delta, items);
-    };
-    /**
-     * Sets the active item to the first enabled item starting at the index specified. If the
-     * item is disabled, it will move in the fallbackDelta direction until it either
-     * finds an enabled item or encounters the end of the list.
-     * @param {?} index
-     * @param {?} fallbackDelta
-     * @param {?=} items
+     * Handles blur events on a registered element.
+     * @param {?} event The blur event.
+     * @param {?} element The monitored element.
      * @return {?}
      */
-    ListKeyManager.prototype._setActiveItemByIndex = function (index, fallbackDelta, items) {
-        if (items === void 0) { items = this._items.toArray(); }
-        if (!items[index]) {
+    FocusMonitor.prototype._onBlur = function (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.
+        var /** @type {?} */ elementInfo = this._elementInfo.get(element);
+        if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
+            element.contains(event.relatedTarget))) {
             return;
         }
-        while (items[index].disabled) {
-            index += fallbackDelta;
-            if (!items[index]) {
-                return;
-            }
-        }
-        this.setActiveItem(index);
+        this._setClasses(element);
+        elementInfo.subject.next(null);
     };
-    return ListKeyManager;
+    FocusMonitor.decorators = [
+        { type: _angular_core.Injectable },
+    ];
+    /**
+     * @nocollapse
+     */
+    FocusMonitor.ctorParameters = function () { return [
+        { type: _angular_core.NgZone, },
+        { type: _angular_cdk_platform.Platform, },
+    ]; };
+    return FocusMonitor;
 }());
-var ActiveDescendantKeyManager = (function (_super) {
-    __extends(ActiveDescendantKeyManager, _super);
-    function ActiveDescendantKeyManager() {
-        return _super !== null && _super.apply(this, arguments) || this;
+/**
+ * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
+ * programmatically) and adds corresponding classes to the element.
+ *
+ * There are two variants of this directive:
+ * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
+ *    focused.
+ * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
+ */
+var CdkMonitorFocus = (function () {
+    /**
+     * @param {?} _elementRef
+     * @param {?} _focusMonitor
+     * @param {?} renderer
+     */
+    function CdkMonitorFocus(_elementRef, _focusMonitor, renderer) {
+        var _this = this;
+        this._elementRef = _elementRef;
+        this._focusMonitor = _focusMonitor;
+        this.cdkFocusChange = new _angular_core.EventEmitter();
+        this._monitorSubscription = this._focusMonitor.monitor(this._elementRef.nativeElement, renderer, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
+            .subscribe(function (origin) { return _this.cdkFocusChange.emit(origin); });
     }
     /**
-     * This method sets the active item to the item at the specified index.
-     * It also adds active styles to the newly active item and removes active
-     * styles from the previously active item.
-     * @param {?} index
      * @return {?}
      */
-    ActiveDescendantKeyManager.prototype.setActiveItem = function (index) {
-        var _this = this;
-        Promise.resolve().then(function () {
-            if (_this.activeItem) {
-                _this.activeItem.setInactiveStyles();
-            }
-            _super.prototype.setActiveItem.call(_this, index);
-            if (_this.activeItem) {
-                _this.activeItem.setActiveStyles();
-            }
-        });
+    CdkMonitorFocus.prototype.ngOnDestroy = function () {
+        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);
+        this._monitorSubscription.unsubscribe();
     };
-    return ActiveDescendantKeyManager;
-}(ListKeyManager));
+    CdkMonitorFocus.decorators = [
+        { type: _angular_core.Directive, args: [{
+                    selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
+                },] },
+    ];
+    /**
+     * @nocollapse
+     */
+    CdkMonitorFocus.ctorParameters = function () { return [
+        { type: _angular_core.ElementRef, },
+        { type: FocusMonitor, },
+        { type: _angular_core.Renderer2, },
+    ]; };
+    CdkMonitorFocus.propDecorators = {
+        'cdkFocusChange': [{ type: _angular_core.Output },],
+    };
+    return CdkMonitorFocus;
+}());
 /**
- * Screenreaders will often fire fake mousedown events when a focusable element
- * is activated using the keyboard. We can typically distinguish between these faked
- * mousedown events and real mousedown events using the "buttons" property. While
- * real mousedowns will indicate the mouse button that was pressed (e.g. "1" for
- * the left mouse button), faked mousedowns will usually set the property value to 0.
- * @param {?} event
+ * \@docs-private
+ * @param {?} parentDispatcher
+ * @param {?} ngZone
+ * @param {?} platform
  * @return {?}
  */
-function isFakeMousedownFromScreenReader(event) {
-    return event.buttons === 0;
+function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {
+    return parentDispatcher || new FocusMonitor(ngZone, platform);
 }
-var FocusKeyManager = (function (_super) {
-    __extends(FocusKeyManager, _super);
-    function FocusKeyManager() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    /**
-     * This method sets the active item to the item at the specified index.
-     * It also adds focuses the newly active item.
-     * @param {?} index
-     * @return {?}
-     */
-    FocusKeyManager.prototype.setActiveItem = function (index) {
-        _super.prototype.setActiveItem.call(this, index);
-        if (this.activeItem) {
-            this.activeItem.focus();
-        }
-    };
-    return FocusKeyManager;
-}(ListKeyManager));
+/**
+ * \@docs-private
+ */
+var FOCUS_MONITOR_PROVIDER = {
+    // If there is already a FocusMonitor available, use that. Otherwise, provide a new one.
+    provide: FocusMonitor,
+    deps: [[new _angular_core.Optional(), new _angular_core.SkipSelf(), FocusMonitor], _angular_core.NgZone, _angular_cdk_platform.Platform],
+    useFactory: FOCUS_MONITOR_PROVIDER_FACTORY
+};
+
 var A11yModule = (function () {
     function A11yModule() {
     }
+    A11yModule.decorators = [
+        { type: _angular_core.NgModule, args: [{
+                    imports: [_angular_common.CommonModule, _angular_cdk_platform.PlatformModule],
+                    declarations: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],
+                    exports: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],
+                    providers: [
+                        InteractivityChecker,
+                        FocusTrapFactory,
+                        AriaDescriber,
+                        LIVE_ANNOUNCER_PROVIDER,
+                        ARIA_DESCRIBER_PROVIDER,
+                        FOCUS_MONITOR_PROVIDER,
+                    ]
+                },] },
+    ];
+    /**
+     * @nocollapse
+     */
+    A11yModule.ctorParameters = function () { return []; };
     return A11yModule;
 }());
-A11yModule.decorators = [
-    { type: _angular_core.NgModule, args: [{
-                imports: [_angular_common.CommonModule, _angular_cdk_platform.PlatformModule],
-                declarations: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],
-                exports: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],
-                providers: [
-                    InteractivityChecker,
-                    FocusTrapFactory,
-                    AriaDescriber,
-                    LIVE_ANNOUNCER_PROVIDER,
-                    ARIA_DESCRIBER_PROVIDER,
-                    FOCUS_MONITOR_PROVIDER,
-                ]
-            },] },
-];
-/**
- * @nocollapse
- */
-A11yModule.ctorParameters = function () { return []; };
 
-exports.A11yModule = A11yModule;
 exports.ActiveDescendantKeyManager = ActiveDescendantKeyManager;
 exports.MESSAGES_CONTAINER_ID = MESSAGES_CONTAINER_ID;
 exports.CDK_DESCRIBEDBY_ID_PREFIX = CDK_DESCRIBEDBY_ID_PREFIX;
@@ -1706,6 +1716,7 @@ exports.FocusMonitor = FocusMonitor;
 exports.CdkMonitorFocus = CdkMonitorFocus;
 exports.FOCUS_MONITOR_PROVIDER_FACTORY = FOCUS_MONITOR_PROVIDER_FACTORY;
 exports.FOCUS_MONITOR_PROVIDER = FOCUS_MONITOR_PROVIDER;
+exports.A11yModule = A11yModule;
 
 Object.defineProperty(exports, '__esModule', { value: true });