[17/51] [partial] nifi-fds git commit: update gh-pages

[sc...@apache.org]

http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/4a326208/node_modules/@angular/cdk/esm2015/a11y.js.map
----------------------------------------------------------------------
diff --git a/node_modules/@angular/cdk/esm2015/a11y.js.map b/node_modules/@angular/cdk/esm2015/a11y.js.map
new file mode 100644
index 0000000..67e7476
--- /dev/null
+++ b/node_modules/@angular/cdk/esm2015/a11y.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"a11y.js","sources":["../../packages/cdk/a11y/list-key-manager.js","../../packages/cdk/a11y/activedescendant-key-manager.js","../../packages/cdk/a11y/aria-reference.js","../../packages/cdk/a11y/aria-describer.js","../../packages/cdk/a11y/fake-mousedown.js","../../packages/cdk/a11y/focus-key-manager.js","../../packages/cdk/a11y/interactivity-checker.js","../../packages/cdk/a11y/focus-trap.js","../../packages/cdk/a11y/live-announcer.js","../../packages/cdk/a11y/focus-monitor.js","../../packages/cdk/a11y/a11y-module.js","../../packages/cdk/a11y/index.js"],"sourcesContent":["/**\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 { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { UP_ARROW, DOWN_ARROW, TAB, A, Z, ZERO, NINE } from '@angular/cdk/keycodes';\nimport { Rx
 Chain, debounceTime, filter, map, doOperator } from '@angular/cdk/rxjs';\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 */\nexport class ListKeyManager {\n    /**\n     * @param {?} _items\n     */\n    constructor(_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    withWrap() {\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    withTypeAhead(debounceInterval = 200) {\n        if (this._items.length && this._items.some(item => 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, keyCode => this._pre
 ssedLetters.push(keyCode))\n            .call(debounceTime, debounceInterval)\n            .call(filter, () => this._pressedLetters.length > 0)\n            .call(map, () => this._pressedLetters.join(''))\n            .subscribe(inputString => {\n            const /** @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 (let /** @type {?} */ i = 1; i < items.length + 1; i++) {\n                const /** @type {?} */ index = (this._activeItemIndex + i) % items.length;\n                const /** @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    setActiveItem(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    onKeydown(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                const /** @type {?} */ keyCode = event.keyCode;\n                // Attempt to use the `event.key` which also maps it to the use
 r'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    /**\n     * Index of the currently active item.\n     * @return {?}\n     */\n    get activeItemIndex() {\n        return this._activeItemIndex;\n    }\n    /**\n     * The active item.\n     * @return {?}\n     */\n    get activeItem() {\n        return this._activ
 eItem;\n    }\n    /**\n     * Sets the active item to the first enabled item in the list.\n     * @return {?}\n     */\n    setFirstItemActive() {\n        this._setActiveItemByIndex(0, 1);\n    }\n    /**\n     * Sets the active item to the last enabled item in the list.\n     * @return {?}\n     */\n    setLastItemActive() {\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    setNextItemActive() {\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    setPreviousItemActive() {\n        this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()\n            : this._setActiveItemByDelta(-1);\n    }\n    /**\n     * Allows setting of the activeItemIndex without any other effects.\n     * @p
 aram {?} index The new activeItemIndex.\n     * @return {?}\n     */\n    updateActiveItemIndex(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    _setActiveItemByDelta(delta, 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 item 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    _setAct
 iveInWrapMode(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    _setActiveInDefaultMode(delta, items) {\n        this._setActiveItemByIndex(this._activeItemIndex + delta, delta, items);\n    }\n    /**\n     * Sets th
 e 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    _setActiveItemByIndex(index, fallbackDelta, 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        this.setActiveItem(index);\n    }\n}\nfunction ListKeyManager_tsickle_Closure_declarations() {\n    /** @type {?} */\n    ListKeyManager.prototype._activeItemIndex;\n    /** @type {?} */\n    ListKeyManager.prototype._activeItem;\n    /** @type {?} */\n    ListKeyManager.prototype._wrap;\n    /** @type {?} */\n    ListKeyManager.protot
 ype._letterKeyStream;\n    /** @type {?} */\n    ListKeyManager.prototype._typeaheadSubscription;\n    /** @type {?} */\n    ListKeyManager.prototype._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     * @type {?}\n     */\n    ListKeyManager.prototype.tabOut;\n    /** @type {?} */\n    ListKeyManager.prototype._items;\n}\n//# sourceMappingURL=list-key-manager.js.map","/**\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 { ListKeyManager } from './list-key-manager';\nexport class ActiveDescendantKeyManager extends ListKeyManager {\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 t
 he previously active item.\n     * @param {?} index\n     * @return {?}\n     */\n    setActiveItem(index) {\n        if (this.activeItem) {\n            this.activeItem.setInactiveStyles();\n        }\n        super.setActiveItem(index);\n        if (this.activeItem) {\n            this.activeItem.setActiveStyles();\n        }\n    }\n}\n//# sourceMappingURL=activedescendant-key-manager.js.map","/**\n * IDs are deliminated by an empty space, as per the spec.\n */\nconst 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 */\nexport function addAriaReferencedId(el, attr, id) {\n    const /** @type {?} */ ids = getAriaReferenceIds(el, attr);\n    if (ids.some(existingId => existingId.trim() == id.trim())) {\n        return;\n    }\n    ids.push(id.trim());\n    el.setAttribute(attr, ids.join(ID_DELIMINAT
 OR));\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 */\nexport function removeAriaReferencedId(el, attr, id) {\n    const /** @type {?} */ ids = getAriaReferenceIds(el, attr);\n    const /** @type {?} */ filteredIds = ids.filter(val => val != id.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 */\nexport function 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//# sourceMappingURL=aria-reference.js.map","/**\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 { Injectable, Optional, SkipSelf } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\nimport { addAriaReferencedId, getAriaReferenceIds, removeAriaReferencedId } from './aria-reference';\n/**\n * ID used for the body container where all messages are appended.\n */\nexport const MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n/**\n * ID prefix used for each created message element.\n */\nexport const CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n/**\n * Attribute given to each host element that is described by a message element.\n */\nexport const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n/**\n * Global incremental identifier for each registered message element.\n */\nlet nextId = 0;\n/**\n * Global map of all registered message elements that ha
 ve been placed into the document.\n */\nconst messageRegistry = new Map();\n/**\n * Container for all registered messages.\n */\nlet 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 */\nexport class AriaDescriber {\n    /**\n     * @param {?} _platform\n     */\n    constructor(_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    describe(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    removeDescription(hostElement, message) {\n        if (!this._platform.isBrowser || !message.trim()) {\n            return;\n        }\n        if (isElementDescribedByMessage(hostElement, message)) {\n            removeMessageReference(hostElement, message);\n        }\n        const /** @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    ngOnDestroy() {\n        if (!this._platform.isBrowser) {\n            return;\n        }\n        const /** @type {?} */ describedElements = document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);\n        for (let /** @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}\nAriaDescriber.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nAriaDescriber.ctorParameters = () => [\n    { type: Platform, },\n];\nfunction AriaDescriber_tsickle_Closure_declarations() {\n    /** @type {?} */\
 n    AriaDescriber.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    AriaDescriber.ctorParameters;\n    /** @type {?} */\n    AriaDescriber.prototype._platform;\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    const /** @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, referenceCount: 0 });\n}\n/**\n * Deletes the message element from the global messages container.\n * @param {?} message\n *
  @return {?}\n */\nfunction deleteMessageElement(message) {\n    const /** @type {?} */ registeredMessage = messageRegistry.get(message);\n    const /** @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    messages
 Container = 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    const /** @type {?} */ originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')\n        .filter(id => 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    const /** @type {?} */ registeredMessage = ((messageRegistry.get(message)));\n    // Add the aria-describedby reference and set the describedby_host attribute to mark the element.\n    addAriaR
 eferencedId(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    const /** @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    const /** @type {?} */ referenceIds = getAriaReferenceId
 s(element, 'aria-describedby');\n    const /** @type {?} */ registeredMessage = messageRegistry.get(message);\n    const /** @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 */\nexport function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher, platform) {\n    return parentDispatcher || new AriaDescriber(platform);\n}\n/**\n * \\@docs-private\n */\nexport const 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//# sourceMappingURL=aria-describer.js.map","/**\n * Screenreaders will often fire fake mousedown events when a focusable eleme
 nt\n * is activated 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 */\nexport function isFakeMousedownFromScreenReader(event) {\n    return event.buttons === 0;\n}\n//# sourceMappingURL=fake-mousedown.js.map","/**\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 { ListKeyManager } from './list-key-manager';\nexport class FocusKeyManager extends ListKeyManager {\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    setActiveItem(index) {\n        super.setActiveItem(index);\n        if (this.activeItem) {\n            this.activeItem.focus();\n        }\n    }\n}\n//# sourceMappingURL=focus-key-manager.js.map","/**\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 { Injectable } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\n/**\n * Utility for checking the interactivity of an element, such as whether is is focusable or\n * tabbable.\n */\nexport class InteractivityChecker {\n    /**\n     * @param {?} _platform\n     */\n    constructor(_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    isDisabled(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 interactivity.\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    isVisible(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    isTabbable(element) {\n        // Nothing is tabbable on the the server 😎\n        if (!this._platform.isBrowser) {\n            return false;\n        }\n        let /** @type {?} */ frameElement = (getWindow(element).frameElement);\n        if (frameElement) {\n            let /** @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.WEB
 KIT) && !this.isVisible(frameElement)) {\n                return false;\n            }\n        }\n        let /** @type {?} */ nodeName = element.nodeName.toLowerCase();\n        let /** @type {?} */ tabIndexValue = getTabIndexValue(element);\n        if (element.hasAttribute('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            else 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    isFocusable(element) {\n        // Perform checks in order of left to most 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}\nInteractivityChecker.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nInteractivityChecker.ctorParameters = () => [\n    { type: Platform, },\n];\nfunction InteractivityChecker_tsickle_Closure_declarations() {\n    /** @type {?} */\n    InteractivityChecker.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    InteractivityChecker.ctorParameters;\n    /** @type {?} */\n    InteractivityChecker.prototype._platform;\n}\n/**\n * Checks whether the specified element has any geometry / rectangles.\n * @par
 am {?} 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 isNativeFormElement(element) {\n    let /** @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    let /** @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 * Ret
 urns 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    const /** @type {?} */ tabIndex = parseInt(element.getAttribute('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    let /** @type {?} */ nodeName = element.nodeName.toLowerCase();\n    let /** @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 elem
 ent 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.hasAttribute('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//# sourceMappingURL=interactivity-checker.js.map","/**\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 { Directive, Eleme
 ntRef, Input, NgZone, Injectable, } from '@angular/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Platform } from '@angular/cdk/platform';\nimport { first } from '@angular/cdk/rxjs';\nimport { InteractivityChecker } from './interactivity-checker';\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 */\nexport class FocusTrap {\n    /**\n     * @param {?} _element\n     * @param {?} _platform\n     * @param {?} _checker\n     * @param {?} _ngZone\n     * @param {?=} deferAnchors\n     */\n    constructor(_element, _platform, _checker, _ngZone, 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    /**\n     * Whether the focus trap is active.\n     * @return {?}\n     */\n    get enabled() { return this._enabled; }\n    /**\n     * @param {?} val\n     * @return {?}\n     */\n    set enabled(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    /**\n     * Destroys the focus trap by cleaning up the anchors.\n     * @return {?}\n     */\n    destroy() {\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    attachAnchors() {\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(() => {\n            ((this._startAnchor)).addEventListener('focus', () => {\n                this.focusLastTabbableElement();\n            }); /** @type {?} */\n            ((this._endAnchor)).addEventListener('focus', () => {\n                this.focusFi
 rstTabbableElement();\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 moved successfuly.\n     */\n    focusInitialElementWhenReady() {\n        return new Promise(resolve => {\n            this._executeOnStable(() => 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 w
 ith a boolean, depending\n     * on whether focus was moved successfuly.\n     */\n    focusFirstTabbableElementWhenReady() {\n        return new Promise(resolve => {\n            this._executeOnStable(() => 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    focusLastTabbableElementWhenReady() {\n        return new Promise(resolve => {\n            this._executeOnStable(() => 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    _getRegionBoundary(bound) {\n        // Contains the deprecated v
 ersion of selector, for temporary backwards comparability.\n        let /** @type {?} */ markers = (this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` +\n            `[cdk-focus-${bound}]`));\n        for (let /** @type {?} */ i = 0; i < markers.length; i++) {\n            if (markers[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    focusInitialElement(
 ) {\n        const /** @type {?} */ redirectToElement = (this._element.querySelector('[cdk-focus-initial]'));\n        if (redirectToElement) {\n            redirectToElement.focus();\n            return true;\n        }\n        return this.focusFirstTabbableElement();\n    }\n    /**\n     * Focuses the first tabbable element within the focus trap region.\n     * @return {?} Returns whether focus was moved successfuly.\n     */\n    focusFirstTabbableElement() {\n        const /** @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    focusLastTabbableElement() {\n        const /** @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     * @param {?} root\n     * @return {?}\n     */\n    _getFirstTabbableElement(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        let /** @type {?} */ children = root.children || root.childNodes;\n        for (let /** @type {?} */ i = 0; i < children.length; i++) {\n            let /** @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        re
 turn null;\n    }\n    /**\n     * Get the last tabbable element from a DOM subtree (inclusive).\n     * @param {?} root\n     * @return {?}\n     */\n    _getLastTabbableElement(root) {\n        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n            return root;\n        }\n        // Iterate in reverse DOM order.\n        let /** @type {?} */ children = root.children || root.childNodes;\n        for (let /** @type {?} */ i = children.length - 1; i >= 0; i--) {\n            let /** @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    _createAnchor() {\n        let /** @type {?} */ anchor = document.createElement('div');\n      
   anchor.tabIndex = this._enabled ? 0 : -1;\n        anchor.classList.add('cdk-visually-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    _executeOnStable(fn) {\n        if (this._ngZone.isStable) {\n            fn();\n        }\n        else {\n            first.call(this._ngZone.onStable.asObservable()).subscribe(fn);\n        }\n    }\n}\nfunction FocusTrap_tsickle_Closure_declarations() {\n    /** @type {?} */\n    FocusTrap.prototype._startAnchor;\n    /** @type {?} */\n    FocusTrap.prototype._endAnchor;\n    /** @type {?} */\n    FocusTrap.prototype._enabled;\n    /** @type {?} */\n    FocusTrap.prototype._element;\n    /** @type {?} */\n    FocusTrap.prototype._platform;\n    /** @type {?} */\n    FocusTrap.prototype._checker;\n    /** @type {?} */\n    FocusTrap.prototype._ngZone;\n}\n/**\n * Factory that allows
  easy instantiation of focus traps.\n */\nexport class FocusTrapFactory {\n    /**\n     * @param {?} _checker\n     * @param {?} _platform\n     * @param {?} _ngZone\n     */\n    constructor(_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    create(element, deferAnchors = false) {\n        return new FocusTrap(element, this._platform, this._checker, this._ngZone, deferAnchors);\n    }\n}\nFocusTrapFactory.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nFocusTrapFactory.ctorParameters = () => [\n    { type: InteractivityChecker, },\n    { type: Platform, },\n    { type: NgZone, },\n];\nfunction FocusTrapFactory_tsickle_Closure_declarations() {\n    /** @type {?} */\n    FocusTrapFactory.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    FocusT
 rapFactory.ctorParameters;\n    /** @type {?} */\n    FocusTrapFactory.prototype._checker;\n    /** @type {?} */\n    FocusTrapFactory.prototype._platform;\n    /** @type {?} */\n    FocusTrapFactory.prototype._ngZone;\n}\n/**\n * Directive for trapping focus within a region.\n * @deprecated\n */\nexport class FocusTrapDeprecatedDirective {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusTrapFactory\n     */\n    constructor(_elementRef, _focusTrapFactory) {\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n    }\n    /**\n     * Whether the focus trap is active.\n     * @return {?}\n     */\n    get disabled() { return !this.focusTrap.enabled; }\n    /**\n     * @param {?} val\n     * @return {?}\n     */\n    set disabled(val) {\n        this.focusTrap.enabled = !coerceBooleanProperty(val);\n    }\n    /**\n     * @return {?}\
 n     */\n    ngOnDestroy() {\n        this.focusTrap.destroy();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        this.focusTrap.attachAnchors();\n    }\n}\nFocusTrapDeprecatedDirective.decorators = [\n    { type: Directive, args: [{\n                selector: 'cdk-focus-trap',\n            },] },\n];\n/**\n * @nocollapse\n */\nFocusTrapDeprecatedDirective.ctorParameters = () => [\n    { type: ElementRef, },\n    { type: FocusTrapFactory, },\n];\nFocusTrapDeprecatedDirective.propDecorators = {\n    'disabled': [{ type: Input },],\n};\nfunction FocusTrapDeprecatedDirective_tsickle_Closure_declarations() {\n    /** @type {?} */\n    FocusTrapDeprecatedDirective.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    FocusTrapDeprecatedDirective.ctorParameters;\n    /** @type {?} */\n    FocusTrapDeprecatedDirective.propDecorators;\n    /** @type {?} */\n    FocusTrapDeprecatedDirective.prototype.focusTrap;\n    /** @type {?} */\n    Fo
 cusTrapDeprecatedDirective.prototype._elementRef;\n    /** @type {?} */\n    FocusTrapDeprecatedDirective.prototype._focusTrapFactory;\n}\n/**\n * Directive for trapping focus within a region.\n */\nexport class FocusTrapDirective {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusTrapFactory\n     */\n    constructor(_elementRef, _focusTrapFactory) {\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n    }\n    /**\n     * Whether the focus trap is active.\n     * @return {?}\n     */\n    get enabled() { return this.focusTrap.enabled; }\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    set enabled(value) { this.focusTrap.enabled = coerceBooleanProperty(value); }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this.focusTrap.destroy();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfter
 ContentInit() {\n        this.focusTrap.attachAnchors();\n    }\n}\nFocusTrapDirective.decorators = [\n    { type: Directive, args: [{\n                selector: '[cdkTrapFocus]',\n                exportAs: 'cdkTrapFocus',\n            },] },\n];\n/**\n * @nocollapse\n */\nFocusTrapDirective.ctorParameters = () => [\n    { type: ElementRef, },\n    { type: FocusTrapFactory, },\n];\nFocusTrapDirective.propDecorators = {\n    'enabled': [{ type: Input, args: ['cdkTrapFocus',] },],\n};\nfunction FocusTrapDirective_tsickle_Closure_declarations() {\n    /** @type {?} */\n    FocusTrapDirective.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    FocusTrapDirective.ctorParameters;\n    /** @type {?} */\n    FocusTrapDirective.propDecorators;\n    /** @type {?} */\n    FocusTrapDirective.prototype.focusTrap;\n    /** @type {?} */\n    FocusTrapDirective.prototype._elementRef;\n    /** @type {?} */\n    FocusTrapDirective.prototype._focusTrapFactory;\n}\n//# sourceMappin
 gURL=focus-trap.js.map","/**\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 { Injectable, InjectionToken, Optional, Inject, SkipSelf, } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\nexport const /** @type {?} */ LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement');\nexport class LiveAnnouncer {\n    /**\n     * @param {?} elementToken\n     * @param {?} platform\n     */\n    constructor(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 construc
 tor 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 {?=} politeness The politeness of the announcer element\n     * @return {?}\n     */\n    announce(message, 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 w
 riting).\n        setTimeout(() => this._liveElement.textContent = message, 100);\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        if (this._liveElement && this._liveElement.parentNode) {\n            this._liveElement.parentNode.removeChild(this._liveElement);\n        }\n    }\n    /**\n     * @return {?}\n     */\n    _createLiveElement() {\n        let /** @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}\nLiveAnnouncer.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nLiveAnnouncer.ctorParameters = () => [\n    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] },] },\n    { type: Platform, },\n];\nfunction LiveAnnouncer_tsickle_Closure_de
 clarations() {\n    /** @type {?} */\n    LiveAnnouncer.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    LiveAnnouncer.ctorParameters;\n    /** @type {?} */\n    LiveAnnouncer.prototype._liveElement;\n}\n/**\n * \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} liveElement\n * @param {?} platform\n * @return {?}\n */\nexport function LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher, liveElement, platform) {\n    return parentDispatcher || new LiveAnnouncer(liveElement, platform);\n}\n/**\n * \\@docs-private\n */\nexport const 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//# sourceMappingURL=live-announcer.js.map","/**\n * @l
 icense\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 { Platform } from '@angular/cdk/platform';\nimport { Directive, ElementRef, EventEmitter, Injectable, NgZone, Optional, Output, Renderer2, SkipSelf, } from '@angular/core';\nimport { of as observableOf } from 'rxjs/observable/of';\nimport { Subject } from 'rxjs/Subject';\n// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n// that a value of around 650ms seems appropriate.\nexport const /** @type {?} */ TOUCH_BUFFER_MS = 650;\n/**\n * Monitors mouse and keyboard events to determine the cause of focus events.\n */\nexport class FocusMonitor {\n    /**\n     * @param {?} _ngZone\n     * @param {?} _platform\n     */\n    constructor(_ngZone, _platform) {\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(() => 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 when 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    monitor(element, renderer, checkChildren) {\n        /
 / Do nothing if we're not on the browser platform.\n        if (!this._platform.isBrowser) {\n            return observableOf(null);\n        }\n        // Check if we're already monitoring this element.\n        if (this._elementInfo.has(element)) {\n            let /** @type {?} */ cachedInfo = this._elementInfo.get(element); /** @type {?} */\n            ((cachedInfo)).checkChildren = checkChildren;\n            return ((cachedInfo)).subject.asObservable();\n        }\n        // Create monitored element info.\n        let /** @type {?} */ info = {\n            unlisten: () => { },\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        let /** @type {?} */ focusListener = (event) => this._onFocus(event, element);\n        let /** @type {?} */ blurListener = (eve
 nt) => this._onBlur(event, element);\n        this._ngZone.runOutsideAngular(() => {\n            element.addEventListener('focus', focusListener, true);\n            element.addEventListener('blur', blurListener, true);\n        });\n        // Create an unlisten function for later.\n        info.unlisten = () => {\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 element to stop monitoring.\n     * @return {?}\n     */\n    stopMonitoring(element) {\n        let /** @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    focusVia(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    _registerDocumentEvents() {\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', () => {\n            this._lastTouchTarget = null;\n            this._setOriginForCurrentEventQueue('keyboard');\n        }, tru
 e);\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', () => {\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 trick used above (setting timeout of 0ms). Instead we wait 650ms to\n        // see if a focus happens.\n        document.addEventListener('touchstart', (event) => {\n            if (this._touchTimeout != null) {\n                clearTimeout(this._touchTimeout);\n            }\n            this._lastTouchTarget = event.target;\n            this._touchTimeout = setTimeout(() => this._lastTouchTarget = null, TOUCH_BUFFER_MS);\n        }, true);\n        // Make a note of when the window regains focus, so we c
 an restore the origin info for the\n        // focused element.\n        window.addEventListener('focus', () => {\n            this._windowFocused = true;\n            setTimeout(() => 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 origin.\n     * @return {?}\n     */\n    _setClasses(element, origin) {\n        const /** @type {?} */ elementInfo = this._elementInfo.get(element);\n        if (elementInfo) {\n            const /** @type {?} */ toggleClass = (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            toggleCla
 ss('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    _setOriginForCurrentEventQueue(origin) {\n        this._origin = origin;\n        setTimeout(() => 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    _wasCausedByTouch(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 will\n        // apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a\n        // relatively small edge-case that can be worked around by using\n        // focusVia(parentEl, 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        let /** @type {?} */ focusTarget = event.target;\n        return this._lastTouchTarget instanceof Node && foc
 usTarget 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 monitored element.\n     * @return {?}\n     */\n    _onFocus(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        const /** @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    _onBlur(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        const /** @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}\nFocusMonitor.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nFocusMonitor.ctorParameters = () => [\n    { type: 
 NgZone, },\n    { type: Platform, },\n];\nfunction FocusMonitor_tsickle_Closure_declarations() {\n    /** @type {?} */\n    FocusMonitor.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    FocusMonitor.ctorParameters;\n    /**\n     * The focus origin that the next focus event is a result of.\n     * @type {?}\n     */\n    FocusMonitor.prototype._origin;\n    /**\n     * The FocusOrigin of the last focus event tracked by the FocusMonitor.\n     * @type {?}\n     */\n    FocusMonitor.prototype._lastFocusOrigin;\n    /**\n     * Whether the window has just been focused.\n     * @type {?}\n     */\n    FocusMonitor.prototype._windowFocused;\n    /**\n     * The target of the last touch event.\n     * @type {?}\n     */\n    FocusMonitor.prototype._lastTouchTarget;\n    /**\n     * The timeout id of the touch timeout, used to cancel timeout later.\n     * @type {?}\n     */\n    FocusMonitor.prototype._touchTimeout;\n    /**\n     * Weak map of elements being monit
 ored to their info.\n     * @type {?}\n     */\n    FocusMonitor.prototype._elementInfo;\n    /** @type {?} */\n    FocusMonitor.prototype._ngZone;\n    /** @type {?} */\n    FocusMonitor.prototype._platform;\n}\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\nexport class CdkMonitorFocus {\n    /**\n     * @param {?} _elementRef\n     * @param {?} _focusMonitor\n     * @param {?} renderer\n     */\n    constructor(_elementRef, _focusMonitor, renderer) {\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(origin => this.cdkFocusChange.emit(origin));\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);\n        this._monitorSubscription.unsubscribe();\n    }\n}\nCdkMonitorFocus.decorators = [\n    { type: Directive, args: [{\n                selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n            },] },\n];\n/**\n * @nocollapse\n */\nCdkMonitorFocus.ctorParameters = () => [\n    { type: ElementRef, },\n    { type: FocusMonitor, },\n    { type: Renderer2, },\n];\nCdkMonitorFocus.propDecorators = {\n    'cdkFocusChange': [{ type: Output },],\n};\nfunction CdkMonitorFocus_tsickle_Closure_declarations() {\n    /** @type {?} */\n    CdkMonitorFocus.decorators;\n    /**\n     * @nocollaps
 e\n     * @type {?}\n     */\n    CdkMonitorFocus.ctorParameters;\n    /** @type {?} */\n    CdkMonitorFocus.propDecorators;\n    /** @type {?} */\n    CdkMonitorFocus.prototype._monitorSubscription;\n    /** @type {?} */\n    CdkMonitorFocus.prototype.cdkFocusChange;\n    /** @type {?} */\n    CdkMonitorFocus.prototype._elementRef;\n    /** @type {?} */\n    CdkMonitorFocus.prototype._focusMonitor;\n}\n/**\n * \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} ngZone\n * @param {?} platform\n * @return {?}\n */\nexport function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {\n    return parentDispatcher || new FocusMonitor(ngZone, platform);\n}\n/**\n * \\@docs-private\n */\nexport const 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_PROVIDE
 R_FACTORY\n};\n//# sourceMappingURL=focus-monitor.js.map","/**\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 { NgModule } from '@angular/core';\nimport { FocusTrapDeprecatedDirective, FocusTrapDirective, FocusTrapFactory } from './focus-trap';\nimport { LIVE_ANNOUNCER_PROVIDER } from './live-announcer';\nimport { InteractivityChecker } from './interactivity-checker';\nimport { CommonModule } from '@angular/common';\nimport { PlatformModule } from '@angular/cdk/platform';\nimport { AriaDescriber, ARIA_DESCRIBER_PROVIDER } from './aria-describer';\nimport { CdkMonitorFocus, FOCUS_MONITOR_PROVIDER } from './focus-monitor';\nexport class A11yModule {\n}\nA11yModule.decorators = [\n    { type: NgModule, args: [{\n                imports: [CommonModule, PlatformModule],\n                declarations: [FocusTrapDirective, Foc
 usTrapDeprecatedDirective, 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 */\nA11yModule.ctorParameters = () => [];\nfunction A11yModule_tsickle_Closure_declarations() {\n    /** @type {?} */\n    A11yModule.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    A11yModule.ctorParameters;\n}\n//# sourceMappingURL=a11y-module.js.map","/**\n * Generated bundle index. Do not edit.\n */\nexport { ActiveDescendantKeyManager, MESSAGES_CONTAINER_ID, CDK_DESCRIBEDBY_ID_PREFIX, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, AriaDescriber, ARIA_DESCRIBER_PROVIDER_FACTORY, ARIA_DES
 CRIBER_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 } from './public-api';\n//# sourceMappingURL=index.js.map"],"names":["observableOf"],"mappings":";;;;;;;;;;;;;;;;;AAWA;;;;AAIA,AAAO,MAAM,cAAc,CAAC;;;;IAIxB,WAAW,CAAC,MAAM,EAAE;QAChB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,gBAAgB,GAAG,IAAI,OAAO,EAAE,CAAC;QACtC,IAAI,CAAC,sBAAsB,GAAG,YAAY,CAAC,KAAK,CAAC;QACjD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;;;;;QAK1B,IAAI,CAAC,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;KAC/B;;;;;;IAMD,QAAQ,GAAG;QACP,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,OAAO,IAAI,CAAC;KACf;;;;;;IAMD,aAAa,CAAC,gBAAgB,GAAG,GAA
 G,EAAE;QAClC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,UAAU,CAAC,EAAE;YACrF,MAAM,KAAK,CAAC,8EAA8E,CAAC,CAAC;SAC/F;QACD,IAAI,CAAC,sBAAsB,CAAC,WAAW,EAAE,CAAC;;;;QAI1C,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC;aAC5D,IAAI,CAAC,UAAU,EAAE,OAAO,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aAC/D,IAAI,CAAC,YAAY,EAAE,gBAAgB,CAAC;aACpC,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;aACnD,IAAI,CAAC,GAAG,EAAE,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAC9C,SAAS,CAAC,WAAW,IAAI;YAC1B,uBAAuB,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;;;YAGrD,KAAK,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBACxD,uBAAuB,KAAK,GAAG,CAAC,IAAI,CAAC,gBAAgB,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC;gBAC1E,uBAAuB,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC3C,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,IAAI,CAAC,QAAQ,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE;oBA
 CvF,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;oBAC1B,MAAM;iBACT;aACJ;YACD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;SAC7B,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;KACf;;;;;;IAMD,aAAa,CAAC,KAAK,EAAE;QACjB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;KACnD;;;;;;IAMD,SAAS,CAAC,KAAK,EAAE;QACb,QAAQ,KAAK,CAAC,OAAO;YACjB,KAAK,UAAU;gBACX,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,MAAM;YACV,KAAK,QAAQ;gBACT,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAC7B,MAAM;YACV,KAAK,GAAG;gBACJ,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACnB,OAAO;YACX;gBACI,uBAAuB,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;;;gBAG/C,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;oBACrC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC,CAAC;iBAC7D;qBACI,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,MAAM,OAAO,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,CAAC,EAAE;oBAC7E,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;iBAC5D;;;gBAGD,OAAO;SACd;QACD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,KAAK,CAAC
 ,cAAc,EAAE,CAAC;KAC1B;;;;;IAKD,IAAI,eAAe,GAAG;QAClB,OAAO,IAAI,CAAC,gBAAgB,CAAC;KAChC;;;;;IAKD,IAAI,UAAU,GAAG;QACb,OAAO,IAAI,CAAC,WAAW,CAAC;KAC3B;;;;;IAKD,kBAAkB,GAAG;QACjB,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACpC;;;;;IAKD,iBAAiB,GAAG;QAChB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAC1D;;;;;IAKD,iBAAiB,GAAG;QAChB,IAAI,CAAC,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,kBAAkB,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;KACzF;;;;;IAKD,qBAAqB,GAAG;QACpB,IAAI,CAAC,gBAAgB,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,EAAE;cAC5D,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;KACxC;;;;;;IAMD,qBAAqB,CAAC,KAAK,EAAE;QACzB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;KACjC;;;;;;;;;IASD,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE;QACxD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC;cAC9C,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KACpD;;;;;;;;;IASD,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE;;QAE/B,IAAI,CAAC,gBAAgB;YACjB,CAAC,IAAI,CAAC,
 gBAAgB,GAAG,KAAK,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC;;QAElE,IAAI,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE;YACvC,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SAC3C;aACI;YACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;SAC7C;KACJ;;;;;;;;;IASD,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE;QAClC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,gBAAgB,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;KAC3E;;;;;;;;;;IAUD,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE;QACvE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YACf,OAAO;SACV;QACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE;YAC1B,KAAK,IAAI,aAAa,CAAC;YACvB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;gBACf,OAAO;aACV;SACJ;QACD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;KAC7B;CACJ,AACD,AAqBC,AACD;;ACvPO,MAAM,0BAA0B,SAAS,cAAc,CAAC;;;;;;;;IAQ3D,aAAa,CAAC,KAAK,EAAE;QACjB,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;SACvC;QACD,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC;SACrC;K
 ACJ;CACJ,AACD;;AC1BA;;;AAGA,MAAM,cAAc,GAAG,GAAG,CAAC;;;;;;;;;AAS3B,AAAO,SAAS,mBAAmB,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAC9C,uBAAuB,GAAG,GAAG,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAC3D,IAAI,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE;QACxD,OAAO;KACV;IACD,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IACpB,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;CACnD;;;;;;;;;AASD,AAAO,SAAS,sBAAsB,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IACjD,uBAAuB,GAAG,GAAG,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAC3D,uBAAuB,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IACzE,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;CAC3D;;;;;;;;AAQD,AAAO,SAAS,mBAAmB,CAAC,EAAE,EAAE,IAAI,EAAE;;IAE1C,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;CAC5D,AACD;;AClCA;;;AAGA,AAAO,MAAM,qBAAqB,GAAG,mCAAmC,CAAC;;;;AAIzE,AAAO,MAAM,yBAAyB,GAAG,yBAAyB,CAAC;;;;AAInE,AAAO,MA
 AM,8BAA8B,GAAG,sBAAsB,CAAC;;;;AAIrE,IAAI,MAAM,GAAG,CAAC,CAAC;;;;AAIf,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;;;;AAIlC,IAAI,iBAAiB,GAAG,IAAI,CAAC;;;;;;;AAO7B,AAAO,MAAM,aAAa,CAAC;;;;IAIvB,WAAW,CAAC,SAAS,EAAE;QACnB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;KAC9B;;;;;;;;;IASD,QAAQ,CAAC,WAAW,EAAE,OAAO,EAAE;QAC3B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE;YAC9C,OAAO;SACV;QACD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;YAC/B,oBAAoB,CAAC,OAAO,CAAC,CAAC;SACjC;QACD,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE;YACpD,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;SAC7C;KACJ;;;;;;;IAOD,iBAAiB,CAAC,WAAW,EAAE,OAAO,EAAE;QACpC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE;YAC9C,OAAO;SACV;QACD,IAAI,2BAA2B,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE;YACnD,sBAAsB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;SAChD;QACD,uBAAuB,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACxE,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,KAAK,CAAC,EAAE;YAC7D,oBAAoB,CAAC,OAAO,CAAC,CAAC;SACjC;QACD,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,UAAU,C
 AAC,MAAM,KAAK,CAAC,EAAE;YAChE,uBAAuB,EAAE,CAAC;SAC7B;KACJ;;;;;IAKD,WAAW,GAAG;QACV,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YAC3B,OAAO;SACV;QACD,uBAAuB,iBAAiB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5G,KAAK,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChE,gCAAgC,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;YACvD,iBAAiB,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;SACxE;QACD,IAAI,iBAAiB,EAAE;YACnB,uBAAuB,EAAE,CAAC;SAC7B;QACD,eAAe,CAAC,KAAK,EAAE,CAAC;KAC3B;CACJ;AACD,aAAa,CAAC,UAAU,GAAG;IACvB,EAAE,IAAI,EAAE,UAAU,EAAE;CACvB,CAAC;;;;AAIF,aAAa,CAAC,cAAc,GAAG,MAAM;IACjC,EAAE,IAAI,EAAE,QAAQ,GAAG;CACtB,CAAC;AACF,AAWA;;;;;;AAMA,SAAS,oBAAoB,CAAC,OAAO,EAAE;IACnC,uBAAuB,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACtE,cAAc,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,EAAE,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9E,cAAc,CAAC,WAAW,oBAAoB,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC;IAClF,IAAI,CAAC,iBAAiB,EAAE;QACpB,uBAAuB,EAAE,CAAC;KAC7B;IAC
 D,EAAE,iBAAiB,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC;IAClD,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC;CACvE;;;;;;AAMD,SAAS,oBAAoB,CAAC,OAAO,EAAE;IACnC,uBAAuB,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxE,uBAAuB,cAAc,GAAG,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC;IAC9F,IAAI,iBAAiB,IAAI,cAAc,EAAE;QACrC,iBAAiB,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;KACjD;IACD,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;CACnC;;;;;AAKD,SAAS,uBAAuB,GAAG;IAC/B,iBAAiB,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAClD,iBAAiB,CAAC,YAAY,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;IAC5D,iBAAiB,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACtD,iBAAiB,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;IACzC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;CAChD;;;;;AAKD,SAAS,uBAAuB,GAAG;IAC/B,QAAQ,CAAC,IAAI,CAAC,WAAW,oBAAoB,iBAAiB,GAAG,CAAC;IAClE,iBAAiB,GAAG,IAAI,CAAC;CAC5B;;;;;;AAMD,SAAS,gCAAgC,CAAC,OAAO,EAAE;;IAE/C,uBAAuB,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,CAAC;SACzF,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC;
 IAC9D,OAAO,CAAC,YAAY,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;CAC5E;;;;;;;;AAQD,SAAS,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE;IAC3C,uBAAuB,iBAAiB,KAAK,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;;IAE5E,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IACtF,OAAO,CAAC,YAAY,CAAC,8BAA8B,EAAE,EAAE,CAAC,CAAC;IACzD,iBAAiB,CAAC,cAAc,EAAE,CAAC;CACtC;;;;;;;;AAQD,SAAS,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE;IAC9C,uBAAuB,iBAAiB,KAAK,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;IAC5E,iBAAiB,CAAC,cAAc,EAAE,CAAC;IACnC,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IACzF,OAAO,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;CAC3D;;;;;;;AAOD,SAAS,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE;IACnD,uBAAuB,YAAY,GAAG,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;IACvF,uBAAuB,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACxE,uBAAuB,SAAS,GAAG,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC;IAC5F,OAAO,CAAC,CAAC,SAAS,IAAI,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;CAC/D;;;;;;;AAOD,AAAO,SAAS,+BAA+B,CA
 AC,gBAAgB,EAAE,QAAQ,EAAE;IACxE,OAAO,gBAAgB,IAAI,IAAI,aAAa,CAAC,QAAQ,CAAC,CAAC;CAC1D;;;;AAID,AAAO,MAAM,uBAAuB,GAAG;;IAEnC,OAAO,EAAE,aAAa;IACtB,IAAI,EAAE;QACF,CAAC,IAAI,QAAQ,EAAE,EAAE,IAAI,QAAQ,EAAE,EAAE,aAAa,CAAC;QAC/C,QAAQ;KACX;IACD,UAAU,EAAE,+BAA+B;CAC9C,CAAC,AACF;;ACrPA;;;;;;;;;AASA,AAAO,SAAS,+BAA+B,CAAC,KAAK,EAAE;IACnD,OAAO,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;CAC9B,AACD;;ACJO,MAAM,eAAe,SAAS,cAAc,CAAC;;;;;;;IAOhD,aAAa,CAAC,KAAK,EAAE;QACjB,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;SAC3B;KACJ;CACJ,AACD;;ACbA;;;;AAIA,AAAO,MAAM,oBAAoB,CAAC;;;;IAI9B,WAAW,CAAC,SAAS,EAAE;QACnB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;KAC9B;;;;;;;IAOD,UAAU,CAAC,OAAO,EAAE;;;QAGhB,OAAO,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;KAC3C;;;;;;;;;;IAUD,SAAS,CAAC,OAAO,EAAE;QACf,OAAO,WAAW,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC,UAAU,KAAK,SAAS,CAAC;KACrF;;;;;;;;IAQD,UAAU,CAAC,OAAO,EAAE;;QAEhB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YAC3B,OAAO,KAAK,CAAC;SAChB;QACD,qBAAq
 B,YAAY,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC;QACtE,IAAI,YAAY,EAAE;YACd,qBAAqB,SAAS,GAAG,YAAY,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;;YAErF,IAAI,gBAAgB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE;gBACvC,OAAO,KAAK,CAAC;aAChB;;YAED,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,KAAK,QAAQ,EAAE;gBAC3E,OAAO,KAAK,CAAC;aAChB;;YAED,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE;gBAClF,OAAO,KAAK,CAAC;aAChB;SACJ;QACD,qBAAqB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC/D,qBAAqB,aAAa,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC/D,IAAI,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,EAAE;YACzC,OAAO,aAAa,KAAK,CAAC,CAAC,CAAC;SAC/B;QACD,IAAI,QAAQ,KAAK,QAAQ,EAAE;;;YAGvB,OAAO,KAAK,CAAC;SAChB;QACD,IAAI,QAAQ,KAAK,OAAO,EAAE;YACtB,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE;;gBAEnC,OAAO,KAAK,CAAC;aAChB;iBACI,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;;gBAE3B,OAAO,IAAI,CAAC;aACf;SACJ;QACD,IAAI,QAAQ,KAAK,OAAO,EAAE;YACtB,IAAI,CAAC,OAAO,CAAC,YAAY,C
 AAC,UAAU,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;;gBAE7D,OAAO,KAAK,CAAC;aAChB;iBACI,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;;gBAErD,OAAO,IAAI,CAAC;aACf;SACJ;QACD,IAAI,QAAQ,KAAK,QAAQ,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;;YAE1E,OAAO,KAAK,CAAC;SAChB;;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE;YACnF,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC;KAChC;;;;;;;IAOD,WAAW,CAAC,OAAO,EAAE;;;QAGjB,OAAO,sBAAsB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;KAClG;CACJ;AACD,oBAAoB,CAAC,UAAU,GAAG;IAC9B,EAAE,IAAI,EAAE,UAAU,EAAE;CACvB,CAAC;;;;AAIF,oBAAoB,CAAC,cAAc,GAAG,MAAM;IACxC,EAAE,IAAI,EAAE,QAAQ,GAAG;CACtB,CAAC;AACF,AAWA;;;;;AAKA,SAAS,WAAW,CAAC,OAAO,EAAE;;;IAG1B,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,YAAY,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,CAAC;CAC7F;;;;;;AAMD,SAAS,mBAAmB,CAAC,OAAO,EAAE;IAClC,qBAAqB,QAAQ,GAAG,
 OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC/D,OAAO,QAAQ,KAAK,OAAO;QACvB,QAAQ,KAAK,QAAQ;QACrB,QAAQ,KAAK,QAAQ;QACrB,QAAQ,KAAK,UAAU,CAAC;CAC/B;;;;;;AAMD,SAAS,aAAa,CAAC,OAAO,EAAE;IAC5B,OAAO,cAAc,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC;CAC9D;;;;;;AAMD,SAAS,gBAAgB,CAAC,OAAO,EAAE;IAC/B,OAAO,eAAe,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;CACnE;;;;;;AAMD,SAAS,cAAc,CAAC,OAAO,EAAE;IAC7B,OAAO,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,OAAO,CAAC;CACpD;;;;;;AAMD,SAAS,eAAe,CAAC,OAAO,EAAE;IAC9B,OAAO,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,GAAG,CAAC;CAChD;;;;;;AAMD,SAAS,gBAAgB,CAAC,OAAO,EAAE;IAC/B,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE;QACrE,OAAO,KAAK,CAAC;KAChB;IACD,qBAAqB,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;;IAEjE,IAAI,QAAQ,IAAI,QAAQ,EAAE;QACtB,OAAO,KAAK,CAAC;KAChB;IACD,OAAO,CAAC,EAAE,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;CACzD;;;;;;;AAOD,SAAS,gBAAgB,CAAC,OAAO,EAAE;IAC/B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE;QAC5B,OAA
 O,IAAI,CAAC;KACf;;IAED,uBAAuB,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IACvF,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC;CAC1C;;;;;;AAMD,SAAS,wBAAwB,CAAC,OAAO,EAAE;IACvC,qBAAqB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC/D,qBAAqB,SAAS,GAAG,QAAQ,KAAK,OAAO,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1E,OAAO,SAAS,KAAK,MAAM;WACpB,SAAS,KAAK,UAAU;WACxB,QAAQ,KAAK,QAAQ;WACrB,QAAQ,KAAK,UAAU,CAAC;CAClC;;;;;;;AAOD,SAAS,sBAAsB,CAAC,OAAO,EAAE;;IAErC,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE;QACxB,OAAO,KAAK,CAAC;KAChB;IACD,OAAO,mBAAmB,CAAC,OAAO,CAAC;QAC/B,gBAAgB,CAAC,OAAO,CAAC;QACzB,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC;QACvC,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACjC;;;;;;AAMD,SAAS,SAAS,CAAC,IAAI,EAAE;IACrB,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,IAAI,MAAM,CAAC;CACnD,AACD;;AC5PA;;;;;;;;AAQA,AAAO,MAAM,SAAS,CAAC;;;;;;;;IAQnB,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,GAAG,KAAK,EAAE;QACtE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,Q
 AAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,YAAY,EAAE;YACf,IAAI,CAAC,aAAa,EAAE,CAAC;SACxB;KACJ;;;;;IAKD,IAAI,OAAO,GAAG,EAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE;;;;;IAKvC,IAAI,OAAO,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QACpB,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,UAAU,EAAE;YACtC,IAAI,CAAC,YAAY,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;SAClF;KACJ;;;;;IAKD,OAAO,GAAG;QACN,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE;YACnD,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC/D;QACD,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE;YAC/C,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC3D;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;KAC9C;;;;;;IAMD,aAAa,GAAG;;QAEZ,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YAC3B,OAAO;SACV;QACD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;SAC5C;QACD,IAAI,CAAC,IAAI
 ,CAAC,UAAU,EAAE;YAClB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;SAC1C;QACD,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,MAAM;YACjC,EAAE,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,OAAO,EAAE,MAAM;gBAClD,IAAI,CAAC,wBAAwB,EAAE,CAAC;aACnC,CAAC,CAAC;YACH,EAAE,IAAI,CAAC,UAAU,GAAG,gBAAgB,CAAC,OAAO,EAAE,MAAM;gBAChD,IAAI,CAAC,yBAAyB,EAAE,CAAC;aACpC,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE;gBAC1B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,YAAY,oBAAoB,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC7F,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,YAAY,oBAAoB,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;aAC1G;SACJ,CAAC,CAAC;KACN;;;;;;;IAOD,4BAA4B,GAAG;QAC3B,OAAO,IAAI,OAAO,CAAC,OAAO,IAAI;YAC1B,IAAI,CAAC,gBAAgB,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;SACpE,CAAC,CAAC;KACN;;;;;;;IAOD,kCAAkC,GAAG;QACjC,OAAO,IAAI,OAAO,CAAC,OAAO,IAAI;YAC1B,IAAI,CAAC,gBAAgB,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,yBAAyB,EAAE,CAAC,CAAC,CAAC;SAC1E,CAAC,CAAC;KACN;;;;;;;IAOD,iCAAiC,GAAG;QAChC,OAAO,IAAI,OAAO,CAAC,OAAO,IAAI;YAC1B,IAAI,CAAC,gBAAgB,C
 AAC,MAAM,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,CAAC,CAAC;SACzE,CAAC,CAAC;KACN;;;;;;IAMD,kBAAkB,CAAC,KAAK,EAAE;;QAEtB,qBAAqB,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC;YAC1F,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,KAAK,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtD,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE;gBAC/C,OAAO,CAAC,IAAI,CAAC,CAAC,6CAA6C,EAAE,KAAK,CAAC,EAAE,CAAC;oBAClE,CAAC,uBAAuB,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;aAChE;SACJ;QACD,IAAI,KAAK,IAAI,OAAO,EAAE;YAClB,OAAO,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACrF;QACD,OAAO,OAAO,CAAC,MAAM;YACjB,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACjF;;;;;IAKD,mBAAmB,GAAG;QAClB,uBAAuB,iBAAiB,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;QAChG,IAAI,iBAAiB,EAAE;YACnB,iBAAiB,CAAC,KAAK,EAAE
 ,CAAC;YAC1B,OAAO,IAAI,CAAC;SACf;QACD,OAAO,IAAI,CAAC,yBAAyB,EAAE,CAAC;KAC3C;;;;;IAKD,yBAAyB,GAAG;QACxB,uBAAuB,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,iBAAiB,EAAE;YACnB,iBAAiB,CAAC,KAAK,EAAE,CAAC;SAC7B;QACD,OAAO,CAAC,CAAC,iBAAiB,CAAC;KAC9B;;;;;IAKD,wBAAwB,GAAG;QACvB,uBAAuB,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC1E,IAAI,iBAAiB,EAAE;YACnB,iBAAiB,CAAC,KAAK,EAAE,CAAC;SAC7B;QACD,OAAO,CAAC,CAAC,iBAAiB,CAAC;KAC9B;;;;;;IAMD,wBAAwB,CAAC,IAAI,EAAE;QAC3B,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACnE,OAAO,IAAI,CAAC;SACf;;;QAGD,qBAAqB,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC;QACjE,KAAK,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACvD,qBAAqB,aAAa,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY;gBAC3E,IAAI,CAAC,wBAAwB,mBAAmB,QAAQ,CAAC,CAAC,CAAC,EAAE;gBAC7D,IAAI,CAAC;YACT,IAAI,aAAa,EAAE;gBACf,OAAO,aAAa,CAAC;aACxB;SACJ;QACD,OAAO,IAAI,CAAC;KACf;;;;;;IAMD,uBAAuB,CAAC,IAAI,
 EAAE;QAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACnE,OAAO,IAAI,CAAC;SACf;;QAED,qBAAqB,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC;QACjE,KAAK,qBAAqB,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAC5D,qBAAqB,aAAa,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,I

<TRUNCATED>