You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by sc...@apache.org on 2018/04/23 20:03:27 UTC
[17/51] [partial] nifi-fds git commit: [NIFIREG-168] upgrade to
angular v5.2.0, angular-material v5.2.0, covalent v1.0.1
http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/f85188ec/node_modules/@angular/cdk/bundles/cdk-a11y.umd.js.map
----------------------------------------------------------------------
diff --git a/node_modules/@angular/cdk/bundles/cdk-a11y.umd.js.map b/node_modules/@angular/cdk/bundles/cdk-a11y.umd.js.map
index ae7640b..b818875 100644
--- a/node_modules/@angular/cdk/bundles/cdk-a11y.umd.js.map
+++ b/node_modules/@angular/cdk/bundles/cdk-a11y.umd.js.map
@@ -1 +1 @@
-{"version":3,"file":"cdk-a11y.umd.js","sources":["../../node_modules/tslib/tslib.es6.js","cdk/a11y.es5.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Refle
ct, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nexport function __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for
(var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n t[p[i]] = s[p[i]];\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"func
tion\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }
), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [0, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] ===
6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Sy
mbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return
i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { if (o[n]) i[n] = function (v) { return (p = !p) ? { v
alue: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; }; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator];\r\n return m ? m.call(o) : typeof __values === \"function\" ? __values(o) : o[Symbol.iterator]();\r\n}","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { __extends } from 'tslib';\nimport * as tslib_1 from 'tslib';\nimport { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { A, DOWN_ARROW, NINE, TAB, UP_ARROW, Z, ZERO } from '@angular/cdk/keycodes';\nimport { RxChain, debounceTime, doOperator, filter, first, map } from '@angular/cdk/rxjs';\nimport { Directive, ElementRef, EventEmitter, Inject, Injectable, InjectionToken, In
put, NgModule, NgZone, Optional, Output, Renderer2, SkipSelf } from '@angular/core';\nimport { Platform, PlatformModule } from '@angular/cdk/platform';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { of } from 'rxjs/observable/of';\nimport { CommonModule } from '@angular/common';\n\n/**\n * This class manages keyboard events for selectable lists. If you pass it a query list\n * of items, it will set the active item correctly when arrow events occur.\n */\nvar ListKeyManager = (function () {\n /**\n * @param {?} _items\n */\n function ListKeyManager(_items) {\n this._items = _items;\n this._activeItemIndex = -1;\n this._wrap = false;\n this._letterKeyStream = new Subject();\n this._typeaheadSubscription = Subscription.EMPTY;\n this._pressedLetters = [];\n /**\n * Stream that emits any time the TAB key is pressed, so components can react\n * when focus is shifted off of the list.\n
*/\n this.tabOut = new Subject();\n }\n /**\n * Turns on wrapping mode, which ensures that the active item will wrap to\n * the other end of list when there are no more items in the given direction.\n * @return {?}\n */\n ListKeyManager.prototype.withWrap = function () {\n this._wrap = true;\n return this;\n };\n /**\n * Turns on typeahead mode which allows users to set the active item by typing.\n * @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.\n * @return {?}\n */\n ListKeyManager.prototype.withTypeAhead = function (debounceInterval) {\n var _this = this;\n if (debounceInterval === void 0) { debounceInterval = 200; }\n if (this._items.length && this._items.some(function (item) { return typeof item.getLabel !== 'function'; })) {\n throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.'
);\n }\n this._typeaheadSubscription.unsubscribe();\n // Debounce the presses of non-navigational keys, collect the ones that correspond to letters\n // and convert those letters back into a string. Afterwards find the first item that starts\n // with that string and select it.\n this._typeaheadSubscription = RxChain.from(this._letterKeyStream)\n .call(doOperator, function (keyCode) { return _this._pressedLetters.push(keyCode); })\n .call(debounceTime, debounceInterval)\n .call(filter, function () { return _this._pressedLetters.length > 0; })\n .call(map, function () { return _this._pressedLetters.join(''); })\n .subscribe(function (inputString) {\n var /** @type {?} */ items = _this._items.toArray();\n // Start at 1 because we want to start searching at the item immediately\n // following the current active item.\n for (var /** @type {?} */ i
= 1; i < items.length + 1; i++) {\n var /** @type {?} */ index = (_this._activeItemIndex + i) % items.length;\n var /** @type {?} */ item = items[index];\n if (!item.disabled && ((item.getLabel))().toUpperCase().trim().indexOf(inputString) === 0) {\n _this.setActiveItem(index);\n break;\n }\n }\n _this._pressedLetters = [];\n });\n return this;\n };\n /**\n * Sets the active item to the item at the index specified.\n * @param {?} index The index of the item to be set as active.\n * @return {?}\n */\n ListKeyManager.prototype.setActiveItem = function (index) {\n this._activeItemIndex = index;\n this._activeItem = this._items.toArray()[index];\n };\n /**\n * Sets the active item depending on the key event passed in.\n * @param {?} event Keyboard event to be used for determining which element should be
active.\n * @return {?}\n */\n ListKeyManager.prototype.onKeydown = function (event) {\n switch (event.keyCode) {\n case DOWN_ARROW:\n this.setNextItemActive();\n break;\n case UP_ARROW:\n this.setPreviousItemActive();\n break;\n case TAB:\n this.tabOut.next();\n return;\n default:\n var /** @type {?} */ keyCode = event.keyCode;\n // Attempt to use the `event.key` which also maps it to the user's keyboard language,\n // otherwise fall back to resolving alphanumeric characters via the keyCode.\n if (event.key && event.key.length === 1) {\n this._letterKeyStream.next(event.key.toLocaleUpperCase());\n }\n else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {\n this._letterKeyStream
.next(String.fromCharCode(keyCode));\n }\n // Note that we return here, in order to avoid preventing\n // the default action of non-navigational keys.\n return;\n }\n this._pressedLetters = [];\n event.preventDefault();\n };\n Object.defineProperty(ListKeyManager.prototype, \"activeItemIndex\", {\n /**\n * Index of the currently active item.\n * @return {?}\n */\n get: function () {\n return this._activeItemIndex;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ListKeyManager.prototype, \"activeItem\", {\n /**\n * The active item.\n * @return {?}\n */\n get: function () {\n return this._activeItem;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Sets the active item to the first enabled item in the list
.\n * @return {?}\n */\n ListKeyManager.prototype.setFirstItemActive = function () {\n this._setActiveItemByIndex(0, 1);\n };\n /**\n * Sets the active item to the last enabled item in the list.\n * @return {?}\n */\n ListKeyManager.prototype.setLastItemActive = function () {\n this._setActiveItemByIndex(this._items.length - 1, -1);\n };\n /**\n * Sets the active item to the next enabled item in the list.\n * @return {?}\n */\n ListKeyManager.prototype.setNextItemActive = function () {\n this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);\n };\n /**\n * Sets the active item to a previous enabled item in the list.\n * @return {?}\n */\n ListKeyManager.prototype.setPreviousItemActive = function () {\n this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()\n : this._setActiveItemByDelta(-1);\n };\n /**\n * Allows setti
ng of the activeItemIndex without any other effects.\n * @param {?} index The new activeItemIndex.\n * @return {?}\n */\n ListKeyManager.prototype.updateActiveItemIndex = function (index) {\n this._activeItemIndex = index;\n };\n /**\n * This method sets the active item, given a list of items and the delta between the\n * currently active item and the new active item. It will calculate differently\n * depending on whether wrap mode is turned on.\n * @param {?} delta\n * @param {?=} items\n * @return {?}\n */\n ListKeyManager.prototype._setActiveItemByDelta = function (delta, items) {\n if (items === void 0) { items = this._items.toArray(); }\n this._wrap ? this._setActiveInWrapMode(delta, items)\n : this._setActiveInDefaultMode(delta, items);\n };\n /**\n * Sets the active item properly given \"wrap\" mode. In other words, it will continue to move\n * down the list until it finds an ite
m that is not disabled, and it will wrap if it\n * encounters either end of the list.\n * @param {?} delta\n * @param {?} items\n * @return {?}\n */\n ListKeyManager.prototype._setActiveInWrapMode = function (delta, items) {\n // when active item would leave menu, wrap to beginning or end\n this._activeItemIndex =\n (this._activeItemIndex + delta + items.length) % items.length;\n // skip all disabled menu items recursively until an enabled one is reached\n if (items[this._activeItemIndex].disabled) {\n this._setActiveInWrapMode(delta, items);\n }\n else {\n this.setActiveItem(this._activeItemIndex);\n }\n };\n /**\n * Sets the active item properly given the default mode. In other words, it will\n * continue to move down the list until it finds an item that is not disabled. If\n * it encounters either end of the list, it will stop and not wrap.\n * @param {?}
delta\n * @param {?} items\n * @return {?}\n */\n ListKeyManager.prototype._setActiveInDefaultMode = function (delta, items) {\n this._setActiveItemByIndex(this._activeItemIndex + delta, delta, items);\n };\n /**\n * Sets the active item to the first enabled item starting at the index specified. If the\n * item is disabled, it will move in the fallbackDelta direction until it either\n * finds an enabled item or encounters the end of the list.\n * @param {?} index\n * @param {?} fallbackDelta\n * @param {?=} items\n * @return {?}\n */\n ListKeyManager.prototype._setActiveItemByIndex = function (index, fallbackDelta, items) {\n if (items === void 0) { items = this._items.toArray(); }\n if (!items[index]) {\n return;\n }\n while (items[index].disabled) {\n index += fallbackDelta;\n if (!items[index]) {\n return;\n }\n }\n t
his.setActiveItem(index);\n };\n return ListKeyManager;\n}());\n\nvar ActiveDescendantKeyManager = (function (_super) {\n __extends(ActiveDescendantKeyManager, _super);\n function ActiveDescendantKeyManager() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * This method sets the active item to the item at the specified index.\n * It also adds active styles to the newly active item and removes active\n * styles from the previously active item.\n * @param {?} index\n * @return {?}\n */\n ActiveDescendantKeyManager.prototype.setActiveItem = function (index) {\n if (this.activeItem) {\n this.activeItem.setInactiveStyles();\n }\n _super.prototype.setActiveItem.call(this, index);\n if (this.activeItem) {\n this.activeItem.setActiveStyles();\n }\n };\n return ActiveDescendantKeyManager;\n}(ListKeyManager));\n\n/**\n * IDs are deliminated by an
empty space, as per the spec.\n */\nvar ID_DELIMINATOR = ' ';\n/**\n * Adds the given ID to the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @param {?} id\n * @return {?}\n */\nfunction addAriaReferencedId(el, attr, id) {\n var /** @type {?} */ ids = getAriaReferenceIds(el, attr);\n if (ids.some(function (existingId) { return existingId.trim() == id.trim(); })) {\n return;\n }\n ids.push(id.trim());\n el.setAttribute(attr, ids.join(ID_DELIMINATOR));\n}\n/**\n * Removes the given ID from the specified ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @param {?} id\n * @return {?}\n */\nfunction removeAriaReferencedId(el, attr, id) {\n var /** @type {?} */ ids = getAriaReferenceIds(el, attr);\n var /** @type {?} */ filteredIds = ids.filter(function (val) { return val != i
d.trim(); });\n el.setAttribute(attr, filteredIds.join(ID_DELIMINATOR));\n}\n/**\n * Gets the list of IDs referenced by the given ARIA attribute on an element.\n * Used for attributes such as aria-labelledby, aria-owns, etc.\n * @param {?} el\n * @param {?} attr\n * @return {?}\n */\nfunction getAriaReferenceIds(el, attr) {\n // Get string array of all individual ids (whitespace deliminated) in the attribute value\n return (el.getAttribute(attr) || '').match(/\\S+/g) || [];\n}\n\n/**\n * ID used for the body container where all messages are appended.\n */\nvar MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n/**\n * ID prefix used for each created message element.\n */\nvar CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n/**\n * Attribute given to each host element that is described by a message element.\n */\nvar CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n/**\n * Global incremental identifier for each registered message element.\n */\nva
r nextId = 0;\n/**\n * Global map of all registered message elements that have been placed into the document.\n */\nvar messageRegistry = new Map();\n/**\n * Container for all registered messages.\n */\nvar messagesContainer = null;\n/**\n * Utility that creates visually hidden elements with a message content. Useful for elements that\n * want to use aria-describedby to further describe themselves without adding additional visual\n * content.\n * \\@docs-private\n */\nvar AriaDescriber = (function () {\n /**\n * @param {?} _platform\n */\n function AriaDescriber(_platform) {\n this._platform = _platform;\n }\n /**\n * Adds to the host element an aria-describedby reference to a hidden element that contains\n * the message. If the same message has already been registered, then it will reuse the created\n * message element.\n * @param {?} hostElement\n * @param {?} message\n * @return {?}\n */\n AriaDescriber.prototype.describe
= function (hostElement, message) {\n if (!this._platform.isBrowser || !message.trim()) {\n return;\n }\n if (!messageRegistry.has(message)) {\n createMessageElement(message);\n }\n if (!isElementDescribedByMessage(hostElement, message)) {\n addMessageReference(hostElement, message);\n }\n };\n /**\n * Removes the host element's aria-describedby reference to the message element.\n * @param {?} hostElement\n * @param {?} message\n * @return {?}\n */\n AriaDescriber.prototype.removeDescription = function (hostElement, message) {\n if (!this._platform.isBrowser || !message.trim()) {\n return;\n }\n if (isElementDescribedByMessage(hostElement, message)) {\n removeMessageReference(hostElement, message);\n }\n var /** @type {?} */ registeredMessage = messageRegistry.get(message);\n if (registeredMessage && registeredMessage
.referenceCount === 0) {\n deleteMessageElement(message);\n }\n if (messagesContainer && messagesContainer.childNodes.length === 0) {\n deleteMessagesContainer();\n }\n };\n /**\n * Unregisters all created message elements and removes the message container.\n * @return {?}\n */\n AriaDescriber.prototype.ngOnDestroy = function () {\n if (!this._platform.isBrowser) {\n return;\n }\n var /** @type {?} */ describedElements = document.querySelectorAll(\"[\" + CDK_DESCRIBEDBY_HOST_ATTRIBUTE + \"]\");\n for (var /** @type {?} */ i = 0; i < describedElements.length; i++) {\n removeCdkDescribedByReferenceIds(describedElements[i]);\n describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n }\n if (messagesContainer) {\n deleteMessagesContainer();\n }\n messageRegistry.clear();\n };\n AriaDescriber.decorators =
[\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n AriaDescriber.ctorParameters = function () { return [\n { type: Platform, },\n ]; };\n return AriaDescriber;\n}());\n/**\n * Creates a new element in the visually hidden message container element with the message\n * as its content and adds it to the message registry.\n * @param {?} message\n * @return {?}\n */\nfunction createMessageElement(message) {\n var /** @type {?} */ messageElement = document.createElement('div');\n messageElement.setAttribute('id', CDK_DESCRIBEDBY_ID_PREFIX + \"-\" + nextId++);\n messageElement.appendChild(/** @type {?} */ ((document.createTextNode(message))));\n if (!messagesContainer) {\n createMessagesContainer();\n } /** @type {?} */\n ((messagesContainer)).appendChild(messageElement);\n messageRegistry.set(message, { messageElement: messageElement, referenceCount: 0 });\n}\n/**\n * Deletes the message element from the global mess
ages container.\n * @param {?} message\n * @return {?}\n */\nfunction deleteMessageElement(message) {\n var /** @type {?} */ registeredMessage = messageRegistry.get(message);\n var /** @type {?} */ messageElement = registeredMessage && registeredMessage.messageElement;\n if (messagesContainer && messageElement) {\n messagesContainer.removeChild(messageElement);\n }\n messageRegistry.delete(message);\n}\n/**\n * Creates the global container for all aria-describedby messages.\n * @return {?}\n */\nfunction createMessagesContainer() {\n messagesContainer = document.createElement('div');\n messagesContainer.setAttribute('id', MESSAGES_CONTAINER_ID);\n messagesContainer.setAttribute('aria-hidden', 'true');\n messagesContainer.style.display = 'none';\n document.body.appendChild(messagesContainer);\n}\n/**\n * Deletes the global messages container.\n * @return {?}\n */\nfunction deleteMessagesContainer() {\n document.body.removeChild(/** @type {?} */
((messagesContainer)));\n messagesContainer = null;\n}\n/**\n * Removes all cdk-describedby messages that are hosted through the element.\n * @param {?} element\n * @return {?}\n */\nfunction removeCdkDescribedByReferenceIds(element) {\n // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX\n var /** @type {?} */ originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')\n .filter(function (id) { return id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0; });\n element.setAttribute('aria-describedby', originalReferenceIds.join(' '));\n}\n/**\n * Adds a message reference to the element using aria-describedby and increments the registered\n * message's reference count.\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\nfunction addMessageReference(element, message) {\n var /** @type {?} */ registeredMessage = ((messageRegistry.get(message)));\n // Add the aria-describedby reference and set the describ
edby_host attribute to mark the element.\n addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');\n registeredMessage.referenceCount++;\n}\n/**\n * Removes a message reference from the element using aria-describedby and decrements the registered\n * message's reference count.\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\nfunction removeMessageReference(element, message) {\n var /** @type {?} */ registeredMessage = ((messageRegistry.get(message)));\n registeredMessage.referenceCount--;\n removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n}\n/**\n * Returns true if the element has been described by the provided message ID.\n * @param {?} element\n * @param {?} message\n * @return {?}\n */\nfunction isElementDescribedByMessage(element, message) {\n var
/** @type {?} */ referenceIds = getAriaReferenceIds(element, 'aria-describedby');\n var /** @type {?} */ registeredMessage = messageRegistry.get(message);\n var /** @type {?} */ messageId = registeredMessage && registeredMessage.messageElement.id;\n return !!messageId && referenceIds.indexOf(messageId) != -1;\n}\n/**\n * \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} platform\n * @return {?}\n */\nfunction ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher, platform) {\n return parentDispatcher || new AriaDescriber(platform);\n}\n/**\n * \\@docs-private\n */\nvar ARIA_DESCRIBER_PROVIDER = {\n // If there is already an AriaDescriber available, use that. Otherwise, provide a new one.\n provide: AriaDescriber,\n deps: [\n [new Optional(), new SkipSelf(), AriaDescriber],\n Platform\n ],\n useFactory: ARIA_DESCRIBER_PROVIDER_FACTORY\n};\n\n/**\n * Screenreaders will often fire fake mousedown events when a focusable element\n * is act
ivated using the keyboard. We can typically distinguish between these faked\n * mousedown events and real mousedown events using the \"buttons\" property. While\n * real mousedowns will indicate the mouse button that was pressed (e.g. \"1\" for\n * the left mouse button), faked mousedowns will usually set the property value to 0.\n * @param {?} event\n * @return {?}\n */\nfunction isFakeMousedownFromScreenReader(event) {\n return event.buttons === 0;\n}\n\nvar FocusKeyManager = (function (_super) {\n __extends(FocusKeyManager, _super);\n function FocusKeyManager() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * This method sets the active item to the item at the specified index.\n * It also adds focuses the newly active item.\n * @param {?} index\n * @return {?}\n */\n FocusKeyManager.prototype.setActiveItem = function (index) {\n _super.prototype.setActiveItem.call(this, index);\n if (this
.activeItem) {\n this.activeItem.focus();\n }\n };\n return FocusKeyManager;\n}(ListKeyManager));\n\n/**\n * Utility for checking the interactivity of an element, such as whether is is focusable or\n * tabbable.\n */\nvar InteractivityChecker = (function () {\n /**\n * @param {?} _platform\n */\n function InteractivityChecker(_platform) {\n this._platform = _platform;\n }\n /**\n * Gets whether an element is disabled.\n *\n * @param {?} element Element to be checked.\n * @return {?} Whether the element is disabled.\n */\n InteractivityChecker.prototype.isDisabled = function (element) {\n // This does not capture some cases, such as a non-form control with a disabled attribute or\n // a form control inside of a disabled form, but should capture the most common cases.\n return element.hasAttribute('disabled');\n };\n /**\n * Gets whether an element is visible for the purposes of in
teractivity.\n *\n * This will capture states like `display: none` and `visibility: hidden`, but not things like\n * being clipped by an `overflow: hidden` parent or being outside the viewport.\n *\n * @param {?} element\n * @return {?} Whether the element is visible.\n */\n InteractivityChecker.prototype.isVisible = function (element) {\n return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';\n };\n /**\n * Gets whether an element can be reached via Tab key.\n * Assumes that the element has already been checked with isFocusable.\n *\n * @param {?} element Element to be checked.\n * @return {?} Whether the element is tabbable.\n */\n InteractivityChecker.prototype.isTabbable = function (element) {\n // Nothing is tabbable on the the server 😎\n if (!this._platform.isBrowser) {\n return false;\n }\n var /** @type {?} */ frameElement = (getWindow(
element).frameElement);\n if (frameElement) {\n var /** @type {?} */ frameType = frameElement && frameElement.nodeName.toLowerCase();\n // Frame elements inherit their tabindex onto all child elements.\n if (getTabIndexValue(frameElement) === -1) {\n return false;\n }\n // Webkit and Blink consider anything inside of an <object> element as non-tabbable.\n if ((this._platform.BLINK || this._platform.WEBKIT) && frameType === 'object') {\n return false;\n }\n // Webkit and Blink disable tabbing to an element inside of an invisible frame.\n if ((this._platform.BLINK || this._platform.WEBKIT) && !this.isVisible(frameElement)) {\n return false;\n }\n }\n var /** @type {?} */ nodeName = element.nodeName.toLowerCase();\n var /** @type {?} */ tabIndexValue = getTabIndexValue(element);\n if (element.hasAtt
ribute('contenteditable')) {\n return tabIndexValue !== -1;\n }\n if (nodeName === 'iframe') {\n // The frames may be tabbable depending on content, but it's not possibly to reliably\n // investigate the content of the frames.\n return false;\n }\n if (nodeName === 'audio') {\n if (!element.hasAttribute('controls')) {\n // By default an <audio> element without the controls enabled is not tabbable.\n return false;\n }\n else if (this._platform.BLINK) {\n // In Blink <audio controls> elements are always tabbable.\n return true;\n }\n }\n if (nodeName === 'video') {\n if (!element.hasAttribute('controls') && this._platform.TRIDENT) {\n // In Trident a <video> element without the controls enabled is not tabbable.\n return false;\n }\n els
e if (this._platform.BLINK || this._platform.FIREFOX) {\n // In Chrome and Firefox <video controls> elements are always tabbable.\n return true;\n }\n }\n if (nodeName === 'object' && (this._platform.BLINK || this._platform.WEBKIT)) {\n // In all Blink and WebKit based browsers <object> elements are never tabbable.\n return false;\n }\n // In iOS the browser only considers some specific elements as tabbable.\n if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {\n return false;\n }\n return element.tabIndex >= 0;\n };\n /**\n * Gets whether an element can be focused by the user.\n *\n * @param {?} element Element to be checked.\n * @return {?} Whether the element is focusable.\n */\n InteractivityChecker.prototype.isFocusable = function (element) {\n // Perform checks in order of left to mos
t expensive.\n // Again, naive approach that does not capture many edge cases and browser quirks.\n return isPotentiallyFocusable(element) && !this.isDisabled(element) && this.isVisible(element);\n };\n InteractivityChecker.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n InteractivityChecker.ctorParameters = function () { return [\n { type: Platform, },\n ]; };\n return InteractivityChecker;\n}());\n/**\n * Checks whether the specified element has any geometry / rectangles.\n * @param {?} element\n * @return {?}\n */\nfunction hasGeometry(element) {\n // Use logic from jQuery to check for an invisible element.\n // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12\n return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);\n}\n/**\n * Gets whether an element's\n * @param {?} element\n * @return {?}\n */\nfunction isNativeFor
mElement(element) {\n var /** @type {?} */ nodeName = element.nodeName.toLowerCase();\n return nodeName === 'input' ||\n nodeName === 'select' ||\n nodeName === 'button' ||\n nodeName === 'textarea';\n}\n/**\n * Gets whether an element is an <input type=\"hidden\">.\n * @param {?} element\n * @return {?}\n */\nfunction isHiddenInput(element) {\n return isInputElement(element) && element.type == 'hidden';\n}\n/**\n * Gets whether an element is an anchor that has an href attribute.\n * @param {?} element\n * @return {?}\n */\nfunction isAnchorWithHref(element) {\n return isAnchorElement(element) && element.hasAttribute('href');\n}\n/**\n * Gets whether an element is an input element.\n * @param {?} element\n * @return {?}\n */\nfunction isInputElement(element) {\n return element.nodeName.toLowerCase() == 'input';\n}\n/**\n * Gets whether an element is an anchor element.\n * @param {?} element\n * @return {?}\n */\nfunction isAnchorElement(element) {
\n return element.nodeName.toLowerCase() == 'a';\n}\n/**\n * Gets whether an element has a valid tabindex.\n * @param {?} element\n * @return {?}\n */\nfunction hasValidTabIndex(element) {\n if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {\n return false;\n }\n var /** @type {?} */ tabIndex = element.getAttribute('tabindex');\n // IE11 parses tabindex=\"\" as the value \"-32768\"\n if (tabIndex == '-32768') {\n return false;\n }\n return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));\n}\n/**\n * Returns the parsed tabindex from the element attributes instead of returning the\n * evaluated tabindex from the browsers defaults.\n * @param {?} element\n * @return {?}\n */\nfunction getTabIndexValue(element) {\n if (!hasValidTabIndex(element)) {\n return null;\n }\n // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054\n var /** @type {?} */ tabIndex = parseInt(element.getAttr
ibute('tabindex') || '', 10);\n return isNaN(tabIndex) ? -1 : tabIndex;\n}\n/**\n * Checks whether the specified element is potentially tabbable on iOS\n * @param {?} element\n * @return {?}\n */\nfunction isPotentiallyTabbableIOS(element) {\n var /** @type {?} */ nodeName = element.nodeName.toLowerCase();\n var /** @type {?} */ inputType = nodeName === 'input' && ((element)).type;\n return inputType === 'text'\n || inputType === 'password'\n || nodeName === 'select'\n || nodeName === 'textarea';\n}\n/**\n * Gets whether an element is potentially focusable without taking current visible/disabled state\n * into account.\n * @param {?} element\n * @return {?}\n */\nfunction isPotentiallyFocusable(element) {\n // Inputs are potentially focusable *unless* they're type=\"hidden\".\n if (isHiddenInput(element)) {\n return false;\n }\n return isNativeFormElement(element) ||\n isAnchorWithHref(element) ||\n element.hasAttribu
te('contenteditable') ||\n hasValidTabIndex(element);\n}\n/**\n * Gets the parent window of a DOM node with regards of being inside of an iframe.\n * @param {?} node\n * @return {?}\n */\nfunction getWindow(node) {\n return node.ownerDocument.defaultView || window;\n}\n\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * NOTE: This class currently uses a very simple (naive) approach to focus trapping.\n * It assumes that the tab order is the same as DOM order, which is not necessarily true.\n * Things like tabIndex > 0, flex `order`, and shadow roots can cause to two to misalign.\n * This will be replaced with a more intelligent solution before the library is considered stable.\n */\nvar FocusTrap = (function () {\n /**\n * @param {?} _element\n * @param {?} _platform\n * @param {?} _checker\n * @param {?} _ngZone\n * @param {?=} deferAnchors\n */\n function FocusTrap(_element, _platform, _checker, _ngZone, deferAnchors
) {\n if (deferAnchors === void 0) { deferAnchors = false; }\n this._element = _element;\n this._platform = _platform;\n this._checker = _checker;\n this._ngZone = _ngZone;\n this._enabled = true;\n if (!deferAnchors) {\n this.attachAnchors();\n }\n }\n Object.defineProperty(FocusTrap.prototype, \"enabled\", {\n /**\n * Whether the focus trap is active.\n * @return {?}\n */\n get: function () { return this._enabled; },\n /**\n * @param {?} val\n * @return {?}\n */\n set: function (val) {\n this._enabled = val;\n if (this._startAnchor && this._endAnchor) {\n this._startAnchor.tabIndex = this._endAnchor.tabIndex = this._enabled ? 0 : -1;\n }\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Destroys the focus trap by cleaning up the anchors.\n *
@return {?}\n */\n FocusTrap.prototype.destroy = function () {\n if (this._startAnchor && this._startAnchor.parentNode) {\n this._startAnchor.parentNode.removeChild(this._startAnchor);\n }\n if (this._endAnchor && this._endAnchor.parentNode) {\n this._endAnchor.parentNode.removeChild(this._endAnchor);\n }\n this._startAnchor = this._endAnchor = null;\n };\n /**\n * Inserts the anchors into the DOM. This is usually done automatically\n * in the constructor, but can be deferred for cases like directives with `*ngIf`.\n * @return {?}\n */\n FocusTrap.prototype.attachAnchors = function () {\n var _this = this;\n // If we're not on the browser, there can be no focus to trap.\n if (!this._platform.isBrowser) {\n return;\n }\n if (!this._startAnchor) {\n this._startAnchor = this._createAnchor();\n }\n if (!this._endAnchor) {\n
this._endAnchor = this._createAnchor();\n }\n this._ngZone.runOutsideAngular(function () {\n ((_this._startAnchor)).addEventListener('focus', function () {\n _this.focusLastTabbableElement();\n }); /** @type {?} */\n ((_this._endAnchor)).addEventListener('focus', function () {\n _this.focusFirstTabbableElement();\n });\n if (_this._element.parentNode) {\n _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._startAnchor)), _this._element);\n _this._element.parentNode.insertBefore(/** @type {?} */ ((_this._endAnchor)), _this._element.nextSibling);\n }\n });\n };\n /**\n * Waits for the zone to stabilize, then either focuses the first element that the\n * user specified, or the first tabbable element.\n * @return {?} Returns a promise that resolves with a boolean, depending\n * on whether focus was mo
ved successfuly.\n */\n FocusTrap.prototype.focusInitialElementWhenReady = function () {\n var _this = this;\n return new Promise(function (resolve) {\n _this._executeOnStable(function () { return resolve(_this.focusInitialElement()); });\n });\n };\n /**\n * Waits for the zone to stabilize, then focuses\n * the first tabbable element within the focus trap region.\n * @return {?} Returns a promise that resolves with a boolean, depending\n * on whether focus was moved successfuly.\n */\n FocusTrap.prototype.focusFirstTabbableElementWhenReady = function () {\n var _this = this;\n return new Promise(function (resolve) {\n _this._executeOnStable(function () { return resolve(_this.focusFirstTabbableElement()); });\n });\n };\n /**\n * Waits for the zone to stabilize, then focuses\n * the last tabbable element within the focus trap region.\n * @return {?} Returns a promise
that resolves with a boolean, depending\n * on whether focus was moved successfuly.\n */\n FocusTrap.prototype.focusLastTabbableElementWhenReady = function () {\n var _this = this;\n return new Promise(function (resolve) {\n _this._executeOnStable(function () { return resolve(_this.focusLastTabbableElement()); });\n });\n };\n /**\n * Get the specified boundary element of the trapped region.\n * @param {?} bound The boundary to get (start or end of trapped region).\n * @return {?} The boundary element.\n */\n FocusTrap.prototype._getRegionBoundary = function (bound) {\n // Contains the deprecated version of selector, for temporary backwards comparability.\n var /** @type {?} */ markers = (this._element.querySelectorAll(\"[cdk-focus-region-\" + bound + \"], \" +\n (\"[cdk-focus-\" + bound + \"]\")));\n for (var /** @type {?} */ i = 0; i < markers.length; i++) {\n if (marker
s[i].hasAttribute(\"cdk-focus-\" + bound)) {\n console.warn(\"Found use of deprecated attribute 'cdk-focus-\" + bound + \"',\" +\n (\" use 'cdk-focus-region-\" + bound + \"' instead.\"), markers[i]);\n }\n }\n if (bound == 'start') {\n return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);\n }\n return markers.length ?\n markers[markers.length - 1] : this._getLastTabbableElement(this._element);\n };\n /**\n * Focuses the element that should be focused when the focus trap is initialized.\n * @return {?} Returns whether focus was moved successfuly.\n */\n FocusTrap.prototype.focusInitialElement = function () {\n var /** @type {?} */ redirectToElement = (this._element.querySelector('[cdk-focus-initial]'));\n if (redirectToElement) {\n redirectToElement.focus();\n return true;\n }\n return this.f
ocusFirstTabbableElement();\n };\n /**\n * Focuses the first tabbable element within the focus trap region.\n * @return {?} Returns whether focus was moved successfuly.\n */\n FocusTrap.prototype.focusFirstTabbableElement = function () {\n var /** @type {?} */ redirectToElement = this._getRegionBoundary('start');\n if (redirectToElement) {\n redirectToElement.focus();\n }\n return !!redirectToElement;\n };\n /**\n * Focuses the last tabbable element within the focus trap region.\n * @return {?} Returns whether focus was moved successfuly.\n */\n FocusTrap.prototype.focusLastTabbableElement = function () {\n var /** @type {?} */ redirectToElement = this._getRegionBoundary('end');\n if (redirectToElement) {\n redirectToElement.focus();\n }\n return !!redirectToElement;\n };\n /**\n * Get the first tabbable element from a DOM subtree (inclusive).\n * @pa
ram {?} root\n * @return {?}\n */\n FocusTrap.prototype._getFirstTabbableElement = function (root) {\n if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n return root;\n }\n // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall\n // back to `childNodes` which includes text nodes, comments etc.\n var /** @type {?} */ children = root.children || root.childNodes;\n for (var /** @type {?} */ i = 0; i < children.length; i++) {\n var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?\n this._getFirstTabbableElement(/** @type {?} */ (children[i])) :\n null;\n if (tabbableChild) {\n return tabbableChild;\n }\n }\n return null;\n };\n /**\n * Get the last tabbable element from a DOM subtree (inclusive).\n * @param {?} root\n * @return {?}\n
*/\n FocusTrap.prototype._getLastTabbableElement = function (root) {\n if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n return root;\n }\n // Iterate in reverse DOM order.\n var /** @type {?} */ children = root.children || root.childNodes;\n for (var /** @type {?} */ i = children.length - 1; i >= 0; i--) {\n var /** @type {?} */ tabbableChild = children[i].nodeType === Node.ELEMENT_NODE ?\n this._getLastTabbableElement(/** @type {?} */ (children[i])) :\n null;\n if (tabbableChild) {\n return tabbableChild;\n }\n }\n return null;\n };\n /**\n * Creates an anchor element.\n * @return {?}\n */\n FocusTrap.prototype._createAnchor = function () {\n var /** @type {?} */ anchor = document.createElement('div');\n anchor.tabIndex = this._enabled ? 0 : -1;\n anchor.classList.add('cdk-vis
ually-hidden');\n anchor.classList.add('cdk-focus-trap-anchor');\n return anchor;\n };\n /**\n * Executes a function when the zone is stable.\n * @param {?} fn\n * @return {?}\n */\n FocusTrap.prototype._executeOnStable = function (fn) {\n if (this._ngZone.isStable) {\n fn();\n }\n else {\n first.call(this._ngZone.onStable.asObservable()).subscribe(fn);\n }\n };\n return FocusTrap;\n}());\n/**\n * Factory that allows easy instantiation of focus traps.\n */\nvar FocusTrapFactory = (function () {\n /**\n * @param {?} _checker\n * @param {?} _platform\n * @param {?} _ngZone\n */\n function FocusTrapFactory(_checker, _platform, _ngZone) {\n this._checker = _checker;\n this._platform = _platform;\n this._ngZone = _ngZone;\n }\n /**\n * @param {?} element\n * @param {?=} deferAnchors\n * @return {?}\n */\n FocusTrapFactory.proto
type.create = function (element, deferAnchors) {\n if (deferAnchors === void 0) { deferAnchors = false; }\n return new FocusTrap(element, this._platform, this._checker, this._ngZone, deferAnchors);\n };\n FocusTrapFactory.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n FocusTrapFactory.ctorParameters = function () { return [\n { type: InteractivityChecker, },\n { type: Platform, },\n { type: NgZone, },\n ]; };\n return FocusTrapFactory;\n}());\n/**\n * Directive for trapping focus within a region.\n * @deprecated\n */\nvar FocusTrapDeprecatedDirective = (function () {\n /**\n * @param {?} _elementRef\n * @param {?} _focusTrapFactory\n */\n function FocusTrapDeprecatedDirective(_elementRef, _focusTrapFactory) {\n this._elementRef = _elementRef;\n this._focusTrapFactory = _focusTrapFactory;\n this.focusTrap = this._focusTrapFactory.create(this._element
Ref.nativeElement, true);\n }\n Object.defineProperty(FocusTrapDeprecatedDirective.prototype, \"disabled\", {\n /**\n * Whether the focus trap is active.\n * @return {?}\n */\n get: function () { return !this.focusTrap.enabled; },\n /**\n * @param {?} val\n * @return {?}\n */\n set: function (val) {\n this.focusTrap.enabled = !coerceBooleanProperty(val);\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n FocusTrapDeprecatedDirective.prototype.ngOnDestroy = function () {\n this.focusTrap.destroy();\n };\n /**\n * @return {?}\n */\n FocusTrapDeprecatedDirective.prototype.ngAfterContentInit = function () {\n this.focusTrap.attachAnchors();\n };\n FocusTrapDeprecatedDirective.decorators = [\n { type: Directive, args: [{\n selector: 'cdk-focus-trap',\n
},] },\n ];\n /**\n * @nocollapse\n */\n FocusTrapDeprecatedDirective.ctorParameters = function () { return [\n { type: ElementRef, },\n { type: FocusTrapFactory, },\n ]; };\n FocusTrapDeprecatedDirective.propDecorators = {\n 'disabled': [{ type: Input },],\n };\n return FocusTrapDeprecatedDirective;\n}());\n/**\n * Directive for trapping focus within a region.\n */\nvar FocusTrapDirective = (function () {\n /**\n * @param {?} _elementRef\n * @param {?} _focusTrapFactory\n */\n function FocusTrapDirective(_elementRef, _focusTrapFactory) {\n this._elementRef = _elementRef;\n this._focusTrapFactory = _focusTrapFactory;\n this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n }\n Object.defineProperty(FocusTrapDirective.prototype, \"enabled\", {\n /**\n * Whether the focus trap is active.\n * @return {?}\n */\n get: functi
on () { return this.focusTrap.enabled; },\n /**\n * @param {?} value\n * @return {?}\n */\n set: function (value) { this.focusTrap.enabled = coerceBooleanProperty(value); },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n FocusTrapDirective.prototype.ngOnDestroy = function () {\n this.focusTrap.destroy();\n };\n /**\n * @return {?}\n */\n FocusTrapDirective.prototype.ngAfterContentInit = function () {\n this.focusTrap.attachAnchors();\n };\n FocusTrapDirective.decorators = [\n { type: Directive, args: [{\n selector: '[cdkTrapFocus]',\n exportAs: 'cdkTrapFocus',\n },] },\n ];\n /**\n * @nocollapse\n */\n FocusTrapDirective.ctorParameters = function () { return [\n { type: ElementRef, },\n { type: FocusTrapFactory, },\n ]; };\n FocusTrapDirective.propDecorat
ors = {\n 'enabled': [{ type: Input, args: ['cdkTrapFocus',] },],\n };\n return FocusTrapDirective;\n}());\n\nvar LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement');\nvar LiveAnnouncer = (function () {\n /**\n * @param {?} elementToken\n * @param {?} platform\n */\n function LiveAnnouncer(elementToken, platform) {\n // Only do anything if we're on the browser platform.\n if (platform.isBrowser) {\n // We inject the live element as `any` because the constructor signature cannot reference\n // browser globals (HTMLElement) on non-browser environments, since having a class decorator\n // causes TypeScript to preserve the constructor signature types.\n this._liveElement = elementToken || this._createLiveElement();\n }\n }\n /**\n * Announces a message to screenreaders.\n * @param {?} message Message to be announced to the screenreader\n * @param {?=} p
oliteness The politeness of the announcer element\n * @return {?}\n */\n LiveAnnouncer.prototype.announce = function (message, politeness) {\n var _this = this;\n if (politeness === void 0) { politeness = 'polite'; }\n this._liveElement.textContent = '';\n // TODO: ensure changing the politeness works on all environments we support.\n this._liveElement.setAttribute('aria-live', politeness);\n // This 100ms timeout is necessary for some browser + screen-reader combinations:\n // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.\n // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a\n // second time without clearing and then using a non-zero delay.\n // (using JAWS 17 at time of this writing).\n setTimeout(function () { return _this._liveElement.textContent = message; }, 100);\n };\n /**\n * @return {?}\n */\
n LiveAnnouncer.prototype.ngOnDestroy = function () {\n if (this._liveElement && this._liveElement.parentNode) {\n this._liveElement.parentNode.removeChild(this._liveElement);\n }\n };\n /**\n * @return {?}\n */\n LiveAnnouncer.prototype._createLiveElement = function () {\n var /** @type {?} */ liveEl = document.createElement('div');\n liveEl.classList.add('cdk-visually-hidden');\n liveEl.setAttribute('aria-atomic', 'true');\n liveEl.setAttribute('aria-live', 'polite');\n document.body.appendChild(liveEl);\n return liveEl;\n };\n LiveAnnouncer.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n LiveAnnouncer.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] },] },\n { type: Platform, },\n ]; };\n return LiveAnnouncer;\n}());\n/**\n
* \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} liveElement\n * @param {?} platform\n * @return {?}\n */\nfunction LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher, liveElement, platform) {\n return parentDispatcher || new LiveAnnouncer(liveElement, platform);\n}\n/**\n * \\@docs-private\n */\nvar LIVE_ANNOUNCER_PROVIDER = {\n // If there is already a LiveAnnouncer available, use that. Otherwise, provide a new one.\n provide: LiveAnnouncer,\n deps: [\n [new Optional(), new SkipSelf(), LiveAnnouncer],\n [new Optional(), new Inject(LIVE_ANNOUNCER_ELEMENT_TOKEN)],\n Platform,\n ],\n useFactory: LIVE_ANNOUNCER_PROVIDER_FACTORY\n};\n\n// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n// that a value of around 650ms seems appropriate.\nvar TOUCH_BUFFER_MS = 650;\n/**\n * Monitors mouse and keyboard events to determine the cause of focus events.\n */\nvar FocusMonitor = (function () {
\n /**\n * @param {?} _ngZone\n * @param {?} _platform\n */\n function FocusMonitor(_ngZone, _platform) {\n var _this = this;\n this._ngZone = _ngZone;\n this._platform = _platform;\n /**\n * The focus origin that the next focus event is a result of.\n */\n this._origin = null;\n /**\n * Whether the window has just been focused.\n */\n this._windowFocused = false;\n /**\n * Weak map of elements being monitored to their info.\n */\n this._elementInfo = new WeakMap();\n this._ngZone.runOutsideAngular(function () { return _this._registerDocumentEvents(); });\n }\n /**\n * Monitors focus on an element and applies appropriate CSS classes.\n * @param {?} element The element to monitor\n * @param {?} renderer The renderer to use to apply CSS classes to the element.\n * @param {?} checkChildren Whether to count the element as focused w
hen its children are focused.\n * @return {?} An observable that emits when the focus state of the element changes.\n * When the element is blurred, null will be emitted.\n */\n FocusMonitor.prototype.monitor = function (element, renderer, checkChildren) {\n var _this = this;\n // Do nothing if we're not on the browser platform.\n if (!this._platform.isBrowser) {\n return of(null);\n }\n // Check if we're already monitoring this element.\n if (this._elementInfo.has(element)) {\n var /** @type {?} */ cachedInfo = this._elementInfo.get(element); /** @type {?} */\n ((cachedInfo)).checkChildren = checkChildren;\n return ((cachedInfo)).subject.asObservable();\n }\n // Create monitored element info.\n var /** @type {?} */ info = {\n unlisten: function () { },\n checkChildren: checkChildren,\n renderer: renderer,\n subject
: new Subject()\n };\n this._elementInfo.set(element, info);\n // Start listening. We need to listen in capture phase since focus events don't bubble.\n var /** @type {?} */ focusListener = function (event) { return _this._onFocus(event, element); };\n var /** @type {?} */ blurListener = function (event) { return _this._onBlur(event, element); };\n this._ngZone.runOutsideAngular(function () {\n element.addEventListener('focus', focusListener, true);\n element.addEventListener('blur', blurListener, true);\n });\n // Create an unlisten function for later.\n info.unlisten = function () {\n element.removeEventListener('focus', focusListener, true);\n element.removeEventListener('blur', blurListener, true);\n };\n return info.subject.asObservable();\n };\n /**\n * Stops monitoring an element and removes all focus classes.\n * @param {?} element The elemen
t to stop monitoring.\n * @return {?}\n */\n FocusMonitor.prototype.stopMonitoring = function (element) {\n var /** @type {?} */ elementInfo = this._elementInfo.get(element);\n if (elementInfo) {\n elementInfo.unlisten();\n elementInfo.subject.complete();\n this._setClasses(element);\n this._elementInfo.delete(element);\n }\n };\n /**\n * Focuses the element via the specified focus origin.\n * @param {?} element The element to focus.\n * @param {?} origin The focus origin.\n * @return {?}\n */\n FocusMonitor.prototype.focusVia = function (element, origin) {\n this._setOriginForCurrentEventQueue(origin);\n element.focus();\n };\n /**\n * Register necessary event listeners on the document and window.\n * @return {?}\n */\n FocusMonitor.prototype._registerDocumentEvents = function () {\n var _this = this;\n // Do nothing if we're not
on the browser platform.\n if (!this._platform.isBrowser) {\n return;\n }\n // Note: we listen to events in the capture phase so we can detect them even if the user stops\n // propagation.\n // On keydown record the origin and clear any touch event that may be in progress.\n document.addEventListener('keydown', function () {\n _this._lastTouchTarget = null;\n _this._setOriginForCurrentEventQueue('keyboard');\n }, true);\n // On mousedown record the origin only if there is not touch target, since a mousedown can\n // happen as a result of a touch event.\n document.addEventListener('mousedown', function () {\n if (!_this._lastTouchTarget) {\n _this._setOriginForCurrentEventQueue('mouse');\n }\n }, true);\n // When the touchstart event fires the focus event is not yet in the event queue. This means\n // we can't rely on the tri
ck used above (setting timeout of 0ms). Instead we wait 650ms to\n // see if a focus happens.\n document.addEventListener('touchstart', function (event) {\n if (_this._touchTimeout != null) {\n clearTimeout(_this._touchTimeout);\n }\n _this._lastTouchTarget = event.target;\n _this._touchTimeout = setTimeout(function () { return _this._lastTouchTarget = null; }, TOUCH_BUFFER_MS);\n }, true);\n // Make a note of when the window regains focus, so we can restore the origin info for the\n // focused element.\n window.addEventListener('focus', function () {\n _this._windowFocused = true;\n setTimeout(function () { return _this._windowFocused = false; }, 0);\n });\n };\n /**\n * Sets the focus classes on the element based on the given focus origin.\n * @param {?} element The element to update the classes on.\n * @param {?=} origin The focus ori
gin.\n * @return {?}\n */\n FocusMonitor.prototype._setClasses = function (element, origin) {\n var /** @type {?} */ elementInfo = this._elementInfo.get(element);\n if (elementInfo) {\n var /** @type {?} */ toggleClass = function (className, shouldSet) {\n shouldSet ? elementInfo.renderer.addClass(element, className) :\n elementInfo.renderer.removeClass(element, className);\n };\n toggleClass('cdk-focused', !!origin);\n toggleClass('cdk-touch-focused', origin === 'touch');\n toggleClass('cdk-keyboard-focused', origin === 'keyboard');\n toggleClass('cdk-mouse-focused', origin === 'mouse');\n toggleClass('cdk-program-focused', origin === 'program');\n }\n };\n /**\n * Sets the origin and schedules an async function to clear it at the end of the event queue.\n * @param {?} origin The origin to set.\n * @return {?}\n */\n
FocusMonitor.prototype._setOriginForCurrentEventQueue = function (origin) {\n var _this = this;\n this._origin = origin;\n setTimeout(function () { return _this._origin = null; }, 0);\n };\n /**\n * Checks whether the given focus event was caused by a touchstart event.\n * @param {?} event The focus event to check.\n * @return {?} Whether the event was caused by a touch.\n */\n FocusMonitor.prototype._wasCausedByTouch = function (event) {\n // Note(mmalerba): This implementation is not quite perfect, there is a small edge case.\n // Consider the following dom structure:\n //\n // <div #parent tabindex=\"0\" cdkFocusClasses>\n // <div #child (click)=\"#parent.focus()\"></div>\n // </div>\n //\n // If the user touches the #child element and the #parent is programmatically focused as a\n // result, this code will still consider it to have been caused by the touch event and wi
ll\n // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a\n // relatively small edge-case that can be worked around by using\n // focusVia(parentEl, renderer, 'program') to focus the parent element.\n //\n // If we decide that we absolutely must handle this case correctly, we can do so by listening\n // for the first focus event after the touchstart, and then the first blur event after that\n // focus event. When that blur event fires we know that whatever follows is not a result of the\n // touchstart.\n var /** @type {?} */ focusTarget = event.target;\n return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&\n (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));\n };\n /**\n * Handles focus events on a registered element.\n * @param {?} event The focus event.\n * @param {?} element The mon
itored element.\n * @return {?}\n */\n FocusMonitor.prototype._onFocus = function (event, element) {\n // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n // focus event affecting the monitored element. If we want to use the origin of the first event\n // instead we should check for the cdk-focused class here and return if the element already has\n // it. (This only matters for elements that have includesChildren = true).\n // If we are not counting child-element-focus as focused, make sure that the event target is the\n // monitored element itself.\n var /** @type {?} */ elementInfo = this._elementInfo.get(element);\n if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {\n return;\n }\n // If we couldn't detect a cause for the focus event, it's due to one of three reasons:\n // 1) The window has just regained focus,
in which case we want to restore the focused state of\n // the element from before the window blurred.\n // 2) It was caused by a touch event, in which case we mark the origin as 'touch'.\n // 3) The element was programmatically focused, in which case we should mark the origin as\n // 'program'.\n if (!this._origin) {\n if (this._windowFocused && this._lastFocusOrigin) {\n this._origin = this._lastFocusOrigin;\n }\n else if (this._wasCausedByTouch(event)) {\n this._origin = 'touch';\n }\n else {\n this._origin = 'program';\n }\n }\n this._setClasses(element, this._origin);\n elementInfo.subject.next(this._origin);\n this._lastFocusOrigin = this._origin;\n this._origin = null;\n };\n /**\n * Handles blur events on a registered element.\n * @param {?} event The blur event.\n * @param
{?} element The monitored element.\n * @return {?}\n */\n FocusMonitor.prototype._onBlur = function (event, element) {\n // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n // order to focus another child of the monitored element.\n var /** @type {?} */ elementInfo = this._elementInfo.get(element);\n if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&\n element.contains(event.relatedTarget))) {\n return;\n }\n this._setClasses(element);\n elementInfo.subject.next(null);\n };\n FocusMonitor.decorators = [\n { type: Injectable },\n ];\n /**\n * @nocollapse\n */\n FocusMonitor.ctorParameters = function () { return [\n { type: NgZone, },\n { type: Platform, },\n ]; };\n return FocusMonitor;\n}());\n/**\n * Directive that determines how a particular element was focused (via k
eyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n * focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\nvar CdkMonitorFocus = (function () {\n /**\n * @param {?} _elementRef\n * @param {?} _focusMonitor\n * @param {?} renderer\n */\n function CdkMonitorFocus(_elementRef, _focusMonitor, renderer) {\n var _this = this;\n this._elementRef = _elementRef;\n this._focusMonitor = _focusMonitor;\n this.cdkFocusChange = new EventEmitter();\n this._monitorSubscription = this._focusMonitor.monitor(this._elementRef.nativeElement, renderer, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))\n .subscribe(function (origin) { return _this.cdkFocusChang
e.emit(origin); });\n }\n /**\n * @return {?}\n */\n CdkMonitorFocus.prototype.ngOnDestroy = function () {\n this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);\n this._monitorSubscription.unsubscribe();\n };\n CdkMonitorFocus.decorators = [\n { type: Directive, args: [{\n selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n },] },\n ];\n /**\n * @nocollapse\n */\n CdkMonitorFocus.ctorParameters = function () { return [\n { type: ElementRef, },\n { type: FocusMonitor, },\n { type: Renderer2, },\n ]; };\n CdkMonitorFocus.propDecorators = {\n 'cdkFocusChange': [{ type: Output },],\n };\n return CdkMonitorFocus;\n}());\n/**\n * \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} ngZone\n * @param {?} platform\n * @return {?}\n */\nfunction FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {\n re
turn parentDispatcher || new FocusMonitor(ngZone, platform);\n}\n/**\n * \\@docs-private\n */\nvar FOCUS_MONITOR_PROVIDER = {\n // If there is already a FocusMonitor available, use that. Otherwise, provide a new one.\n provide: FocusMonitor,\n deps: [[new Optional(), new SkipSelf(), FocusMonitor], NgZone, Platform],\n useFactory: FOCUS_MONITOR_PROVIDER_FACTORY\n};\n\nvar A11yModule = (function () {\n function A11yModule() {\n }\n A11yModule.decorators = [\n { type: NgModule, args: [{\n imports: [CommonModule, PlatformModule],\n declarations: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],\n exports: [FocusTrapDirective, FocusTrapDeprecatedDirective, CdkMonitorFocus],\n providers: [\n InteractivityChecker,\n FocusTrapFactory,\n AriaDescriber,\n LIVE_ANNOUNCER_PROVIDER,\n
ARIA_DESCRIBER_PROVIDER,\n FOCUS_MONITOR_PROVIDER,\n ]\n },] },\n ];\n /**\n * @nocollapse\n */\n A11yModule.ctorParameters = function () { return []; };\n return A11yModule;\n}());\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ActiveDescendantKeyManager, MESSAGES_CONTAINER_ID, CDK_DESCRIBEDBY_ID_PREFIX, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, AriaDescriber, ARIA_DESCRIBER_PROVIDER_FACTORY, ARIA_DESCRIBER_PROVIDER, isFakeMousedownFromScreenReader, FocusKeyManager, FocusTrap, FocusTrapFactory, FocusTrapDeprecatedDirective, FocusTrapDirective, InteractivityChecker, ListKeyManager, LIVE_ANNOUNCER_ELEMENT_TOKEN, LiveAnnouncer, LIVE_ANNOUNCER_PROVIDER_FACTORY, LIVE_ANNOUNCER_PROVIDER, TOUCH_BUFFER_MS, FocusMonitor, CdkMonitorFocus, FOCUS_MONITOR_PROVIDER_FACTORY, FOCUS_MONITOR_PROVIDER, A11yModule };\n//# sourceMappingURL=a11y.es5.js.map\n"],"names":["Subject","Subscription","R
xChain","doOperator","debounceTime","filter","map","DOWN_ARROW","UP_ARROW","TAB","A","Z","ZERO","NINE","Injectable","Platform","Optional","SkipSelf","first","NgZone","coerceBooleanProperty","Directive","ElementRef","Input","InjectionToken","Inject","of","EventEmitter","Renderer2","Output","NgModule","CommonModule","PlatformModule"],"mappings":"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
<TRUNCATED>