{"version":3,"file":"2373bb6e00d8e4f61d975cc2.js?3.6.14.7428b935c.1723600572441","mappings":"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","sources":["webpack://mono-repo/./node_modules/@material/checkbox/foundation.js","webpack://mono-repo/./node_modules/@material/drawer/dismissible/foundation.js","webpack://mono-repo/./node_modules/@material/drawer/modal/foundation.js","webpack://mono-repo/./node_modules/@material/form-field/foundation.js","webpack://mono-repo/./node_modules/@material/tab-bar/foundation.js","webpack://mono-repo/./node_modules/@material/tab-indicator/foundation.js","webpack://mono-repo/./node_modules/@material/tab-scroller/foundation.js","webpack://mono-repo/./node_modules/@material/tab/foundation.js"],"sourcesContent":["/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, numbers, strings } from './constants';\nvar MDCCheckboxFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCCheckboxFoundation, _super);\n    function MDCCheckboxFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCCheckboxFoundation.defaultAdapter, adapter)) || this;\n        _this.currentCheckState_ = strings.TRANSITION_STATE_INIT;\n        _this.currentAnimationClass_ = '';\n        _this.animEndLatchTimer_ = 0;\n        _this.enableAnimationEndHandler_ = false;\n        return _this;\n    }\n    Object.defineProperty(MDCCheckboxFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCCheckboxFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCCheckboxFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCCheckboxFoundation, \"defaultAdapter\", {\n        get: function () {\n            return {\n                addClass: function () { return undefined; },\n                forceLayout: function () { return undefined; },\n                hasNativeControl: function () { return false; },\n                isAttachedToDOM: function () { return false; },\n                isChecked: function () { return false; },\n                isIndeterminate: function () { return false; },\n                removeClass: function () { return undefined; },\n                removeNativeControlAttr: function () { return undefined; },\n                setNativeControlAttr: function () { return undefined; },\n                setNativeControlDisabled: function () { return undefined; },\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCCheckboxFoundation.prototype.init = function () {\n        this.currentCheckState_ = this.determineCheckState_();\n        this.updateAriaChecked_();\n        this.adapter_.addClass(cssClasses.UPGRADED);\n    };\n    MDCCheckboxFoundation.prototype.destroy = function () {\n        clearTimeout(this.animEndLatchTimer_);\n    };\n    MDCCheckboxFoundation.prototype.setDisabled = function (disabled) {\n        this.adapter_.setNativeControlDisabled(disabled);\n        if (disabled) {\n            this.adapter_.addClass(cssClasses.DISABLED);\n        }\n        else {\n            this.adapter_.removeClass(cssClasses.DISABLED);\n        }\n    };\n    /**\n     * Handles the animationend event for the checkbox\n     */\n    MDCCheckboxFoundation.prototype.handleAnimationEnd = function () {\n        var _this = this;\n        if (!this.enableAnimationEndHandler_) {\n            return;\n        }\n        clearTimeout(this.animEndLatchTimer_);\n        this.animEndLatchTimer_ = setTimeout(function () {\n            _this.adapter_.removeClass(_this.currentAnimationClass_);\n            _this.enableAnimationEndHandler_ = false;\n        }, numbers.ANIM_END_LATCH_MS);\n    };\n    /**\n     * Handles the change event for the checkbox\n     */\n    MDCCheckboxFoundation.prototype.handleChange = function () {\n        this.transitionCheckState_();\n    };\n    MDCCheckboxFoundation.prototype.transitionCheckState_ = function () {\n        if (!this.adapter_.hasNativeControl()) {\n            return;\n        }\n        var oldState = this.currentCheckState_;\n        var newState = this.determineCheckState_();\n        if (oldState === newState) {\n            return;\n        }\n        this.updateAriaChecked_();\n        var TRANSITION_STATE_UNCHECKED = strings.TRANSITION_STATE_UNCHECKED;\n        var SELECTED = cssClasses.SELECTED;\n        if (newState === TRANSITION_STATE_UNCHECKED) {\n            this.adapter_.removeClass(SELECTED);\n        }\n        else {\n            this.adapter_.addClass(SELECTED);\n        }\n        // Check to ensure that there isn't a previously existing animation class, in case for example\n        // the user interacted with the checkbox before the animation was finished.\n        if (this.currentAnimationClass_.length > 0) {\n            clearTimeout(this.animEndLatchTimer_);\n            this.adapter_.forceLayout();\n            this.adapter_.removeClass(this.currentAnimationClass_);\n        }\n        this.currentAnimationClass_ = this.getTransitionAnimationClass_(oldState, newState);\n        this.currentCheckState_ = newState;\n        // Check for parentNode so that animations are only run when the element is attached\n        // to the DOM.\n        if (this.adapter_.isAttachedToDOM() && this.currentAnimationClass_.length > 0) {\n            this.adapter_.addClass(this.currentAnimationClass_);\n            this.enableAnimationEndHandler_ = true;\n        }\n    };\n    MDCCheckboxFoundation.prototype.determineCheckState_ = function () {\n        var TRANSITION_STATE_INDETERMINATE = strings.TRANSITION_STATE_INDETERMINATE, TRANSITION_STATE_CHECKED = strings.TRANSITION_STATE_CHECKED, TRANSITION_STATE_UNCHECKED = strings.TRANSITION_STATE_UNCHECKED;\n        if (this.adapter_.isIndeterminate()) {\n            return TRANSITION_STATE_INDETERMINATE;\n        }\n        return this.adapter_.isChecked() ? TRANSITION_STATE_CHECKED : TRANSITION_STATE_UNCHECKED;\n    };\n    MDCCheckboxFoundation.prototype.getTransitionAnimationClass_ = function (oldState, newState) {\n        var TRANSITION_STATE_INIT = strings.TRANSITION_STATE_INIT, TRANSITION_STATE_CHECKED = strings.TRANSITION_STATE_CHECKED, TRANSITION_STATE_UNCHECKED = strings.TRANSITION_STATE_UNCHECKED;\n        var _a = MDCCheckboxFoundation.cssClasses, ANIM_UNCHECKED_CHECKED = _a.ANIM_UNCHECKED_CHECKED, ANIM_UNCHECKED_INDETERMINATE = _a.ANIM_UNCHECKED_INDETERMINATE, ANIM_CHECKED_UNCHECKED = _a.ANIM_CHECKED_UNCHECKED, ANIM_CHECKED_INDETERMINATE = _a.ANIM_CHECKED_INDETERMINATE, ANIM_INDETERMINATE_CHECKED = _a.ANIM_INDETERMINATE_CHECKED, ANIM_INDETERMINATE_UNCHECKED = _a.ANIM_INDETERMINATE_UNCHECKED;\n        switch (oldState) {\n            case TRANSITION_STATE_INIT:\n                if (newState === TRANSITION_STATE_UNCHECKED) {\n                    return '';\n                }\n                return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n            case TRANSITION_STATE_UNCHECKED:\n                return newState === TRANSITION_STATE_CHECKED ? ANIM_UNCHECKED_CHECKED : ANIM_UNCHECKED_INDETERMINATE;\n            case TRANSITION_STATE_CHECKED:\n                return newState === TRANSITION_STATE_UNCHECKED ? ANIM_CHECKED_UNCHECKED : ANIM_CHECKED_INDETERMINATE;\n            default: // TRANSITION_STATE_INDETERMINATE\n                return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n        }\n    };\n    MDCCheckboxFoundation.prototype.updateAriaChecked_ = function () {\n        // Ensure aria-checked is set to mixed if checkbox is in indeterminate state.\n        if (this.adapter_.isIndeterminate()) {\n            this.adapter_.setNativeControlAttr(strings.ARIA_CHECKED_ATTR, strings.ARIA_CHECKED_INDETERMINATE_VALUE);\n        }\n        else {\n            // The on/off state does not need to keep track of aria-checked, since\n            // the screenreader uses the checked property on the checkbox element.\n            this.adapter_.removeNativeControlAttr(strings.ARIA_CHECKED_ATTR);\n        }\n    };\n    return MDCCheckboxFoundation;\n}(MDCFoundation));\nexport { MDCCheckboxFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCCheckboxFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, strings } from '../constants';\nvar MDCDismissibleDrawerFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCDismissibleDrawerFoundation, _super);\n    function MDCDismissibleDrawerFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCDismissibleDrawerFoundation.defaultAdapter, adapter)) || this;\n        _this.animationFrame_ = 0;\n        _this.animationTimer_ = 0;\n        return _this;\n    }\n    Object.defineProperty(MDCDismissibleDrawerFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCDismissibleDrawerFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCDismissibleDrawerFoundation, \"defaultAdapter\", {\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                addClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                hasClass: function () { return false; },\n                elementHasClass: function () { return false; },\n                notifyClose: function () { return undefined; },\n                notifyOpen: function () { return undefined; },\n                saveFocus: function () { return undefined; },\n                restoreFocus: function () { return undefined; },\n                focusActiveNavigationItem: function () { return undefined; },\n                trapFocus: function () { return undefined; },\n                releaseFocus: function () { return undefined; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCDismissibleDrawerFoundation.prototype.destroy = function () {\n        if (this.animationFrame_) {\n            cancelAnimationFrame(this.animationFrame_);\n        }\n        if (this.animationTimer_) {\n            clearTimeout(this.animationTimer_);\n        }\n    };\n    MDCDismissibleDrawerFoundation.prototype.open = function () {\n        var _this = this;\n        if (this.isOpen() || this.isOpening() || this.isClosing()) {\n            return;\n        }\n        this.adapter_.addClass(cssClasses.OPEN);\n        this.adapter_.addClass(cssClasses.ANIMATE);\n        // Wait a frame once display is no longer \"none\", to establish basis for animation\n        this.runNextAnimationFrame_(function () {\n            _this.adapter_.addClass(cssClasses.OPENING);\n        });\n        this.adapter_.saveFocus();\n    };\n    MDCDismissibleDrawerFoundation.prototype.close = function () {\n        if (!this.isOpen() || this.isOpening() || this.isClosing()) {\n            return;\n        }\n        this.adapter_.addClass(cssClasses.CLOSING);\n    };\n    /**\n     * @return true if drawer is in open state.\n     */\n    MDCDismissibleDrawerFoundation.prototype.isOpen = function () {\n        return this.adapter_.hasClass(cssClasses.OPEN);\n    };\n    /**\n     * @return true if drawer is animating open.\n     */\n    MDCDismissibleDrawerFoundation.prototype.isOpening = function () {\n        return this.adapter_.hasClass(cssClasses.OPENING) || this.adapter_.hasClass(cssClasses.ANIMATE);\n    };\n    /**\n     * @return true if drawer is animating closed.\n     */\n    MDCDismissibleDrawerFoundation.prototype.isClosing = function () {\n        return this.adapter_.hasClass(cssClasses.CLOSING);\n    };\n    /**\n     * Keydown handler to close drawer when key is escape.\n     */\n    MDCDismissibleDrawerFoundation.prototype.handleKeydown = function (evt) {\n        var keyCode = evt.keyCode, key = evt.key;\n        var isEscape = key === 'Escape' || keyCode === 27;\n        if (isEscape) {\n            this.close();\n        }\n    };\n    /**\n     * Handles a transition end event on the root element.\n     */\n    MDCDismissibleDrawerFoundation.prototype.handleTransitionEnd = function (evt) {\n        var OPENING = cssClasses.OPENING, CLOSING = cssClasses.CLOSING, OPEN = cssClasses.OPEN, ANIMATE = cssClasses.ANIMATE, ROOT = cssClasses.ROOT;\n        // In Edge, transitionend on ripple pseudo-elements yields a target without classList, so check for Element first.\n        var isRootElement = this.isElement_(evt.target) && this.adapter_.elementHasClass(evt.target, ROOT);\n        if (!isRootElement) {\n            return;\n        }\n        if (this.isClosing()) {\n            this.adapter_.removeClass(OPEN);\n            this.closed_();\n            this.adapter_.restoreFocus();\n            this.adapter_.notifyClose();\n        }\n        else {\n            this.adapter_.focusActiveNavigationItem();\n            this.opened_();\n            this.adapter_.notifyOpen();\n        }\n        this.adapter_.removeClass(ANIMATE);\n        this.adapter_.removeClass(OPENING);\n        this.adapter_.removeClass(CLOSING);\n    };\n    /**\n     * Extension point for when drawer finishes open animation.\n     */\n    MDCDismissibleDrawerFoundation.prototype.opened_ = function () { }; // tslint:disable-line:no-empty\n    /**\n     * Extension point for when drawer finishes close animation.\n     */\n    MDCDismissibleDrawerFoundation.prototype.closed_ = function () { }; // tslint:disable-line:no-empty\n    /**\n     * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n     */\n    MDCDismissibleDrawerFoundation.prototype.runNextAnimationFrame_ = function (callback) {\n        var _this = this;\n        cancelAnimationFrame(this.animationFrame_);\n        this.animationFrame_ = requestAnimationFrame(function () {\n            _this.animationFrame_ = 0;\n            clearTimeout(_this.animationTimer_);\n            _this.animationTimer_ = setTimeout(callback, 0);\n        });\n    };\n    MDCDismissibleDrawerFoundation.prototype.isElement_ = function (element) {\n        // In Edge, transitionend on ripple pseudo-elements yields a target without classList.\n        return Boolean(element.classList);\n    };\n    return MDCDismissibleDrawerFoundation;\n}(MDCFoundation));\nexport { MDCDismissibleDrawerFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDismissibleDrawerFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCDismissibleDrawerFoundation } from '../dismissible/foundation';\n/* istanbul ignore next: subclass is not a branch statement */\nvar MDCModalDrawerFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCModalDrawerFoundation, _super);\n    function MDCModalDrawerFoundation() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Handles click event on scrim.\n     */\n    MDCModalDrawerFoundation.prototype.handleScrimClick = function () {\n        this.close();\n    };\n    /**\n     * Called when drawer finishes open animation.\n     */\n    MDCModalDrawerFoundation.prototype.opened_ = function () {\n        this.adapter_.trapFocus();\n    };\n    /**\n     * Called when drawer finishes close animation.\n     */\n    MDCModalDrawerFoundation.prototype.closed_ = function () {\n        this.adapter_.releaseFocus();\n    };\n    return MDCModalDrawerFoundation;\n}(MDCDismissibleDrawerFoundation));\nexport { MDCModalDrawerFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCModalDrawerFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, strings } from './constants';\nvar MDCFormFieldFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCFormFieldFoundation, _super);\n    function MDCFormFieldFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCFormFieldFoundation.defaultAdapter, adapter)) || this;\n        _this.clickHandler_ = function () { return _this.handleClick_(); };\n        return _this;\n    }\n    Object.defineProperty(MDCFormFieldFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCFormFieldFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCFormFieldFoundation, \"defaultAdapter\", {\n        get: function () {\n            return {\n                activateInputRipple: function () { return undefined; },\n                deactivateInputRipple: function () { return undefined; },\n                deregisterInteractionHandler: function () { return undefined; },\n                registerInteractionHandler: function () { return undefined; },\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCFormFieldFoundation.prototype.init = function () {\n        this.adapter_.registerInteractionHandler('click', this.clickHandler_);\n    };\n    MDCFormFieldFoundation.prototype.destroy = function () {\n        this.adapter_.deregisterInteractionHandler('click', this.clickHandler_);\n    };\n    MDCFormFieldFoundation.prototype.handleClick_ = function () {\n        var _this = this;\n        this.adapter_.activateInputRipple();\n        requestAnimationFrame(function () { return _this.adapter_.deactivateInputRipple(); });\n    };\n    return MDCFormFieldFoundation;\n}(MDCFoundation));\nexport { MDCFormFieldFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFormFieldFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { numbers, strings } from './constants';\nvar ACCEPTABLE_KEYS = new Set();\n// IE11 has no support for new Set with iterable so we need to initialize this by hand\nACCEPTABLE_KEYS.add(strings.ARROW_LEFT_KEY);\nACCEPTABLE_KEYS.add(strings.ARROW_RIGHT_KEY);\nACCEPTABLE_KEYS.add(strings.END_KEY);\nACCEPTABLE_KEYS.add(strings.HOME_KEY);\nACCEPTABLE_KEYS.add(strings.ENTER_KEY);\nACCEPTABLE_KEYS.add(strings.SPACE_KEY);\nvar KEYCODE_MAP = new Map();\n// IE11 has no support for new Map with iterable so we need to initialize this by hand\nKEYCODE_MAP.set(numbers.ARROW_LEFT_KEYCODE, strings.ARROW_LEFT_KEY);\nKEYCODE_MAP.set(numbers.ARROW_RIGHT_KEYCODE, strings.ARROW_RIGHT_KEY);\nKEYCODE_MAP.set(numbers.END_KEYCODE, strings.END_KEY);\nKEYCODE_MAP.set(numbers.HOME_KEYCODE, strings.HOME_KEY);\nKEYCODE_MAP.set(numbers.ENTER_KEYCODE, strings.ENTER_KEY);\nKEYCODE_MAP.set(numbers.SPACE_KEYCODE, strings.SPACE_KEY);\nvar MDCTabBarFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCTabBarFoundation, _super);\n    function MDCTabBarFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCTabBarFoundation.defaultAdapter, adapter)) || this;\n        _this.useAutomaticActivation_ = false;\n        return _this;\n    }\n    Object.defineProperty(MDCTabBarFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabBarFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabBarFoundation, \"defaultAdapter\", {\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                scrollTo: function () { return undefined; },\n                incrementScroll: function () { return undefined; },\n                getScrollPosition: function () { return 0; },\n                getScrollContentWidth: function () { return 0; },\n                getOffsetWidth: function () { return 0; },\n                isRTL: function () { return false; },\n                setActiveTab: function () { return undefined; },\n                activateTabAtIndex: function () { return undefined; },\n                deactivateTabAtIndex: function () { return undefined; },\n                focusTabAtIndex: function () { return undefined; },\n                getTabIndicatorClientRectAtIndex: function () { return ({ top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 }); },\n                getTabDimensionsAtIndex: function () { return ({ rootLeft: 0, rootRight: 0, contentLeft: 0, contentRight: 0 }); },\n                getPreviousActiveTabIndex: function () { return -1; },\n                getFocusedTabIndex: function () { return -1; },\n                getIndexOfTabById: function () { return -1; },\n                getTabListLength: function () { return 0; },\n                notifyTabActivated: function () { return undefined; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Switches between automatic and manual activation modes.\n     * See https://www.w3.org/TR/wai-aria-practices/#tabpanel for examples.\n     */\n    MDCTabBarFoundation.prototype.setUseAutomaticActivation = function (useAutomaticActivation) {\n        this.useAutomaticActivation_ = useAutomaticActivation;\n    };\n    MDCTabBarFoundation.prototype.activateTab = function (index) {\n        var previousActiveIndex = this.adapter_.getPreviousActiveTabIndex();\n        if (!this.indexIsInRange_(index) || index === previousActiveIndex) {\n            return;\n        }\n        var previousClientRect;\n        if (previousActiveIndex !== -1) {\n            this.adapter_.deactivateTabAtIndex(previousActiveIndex);\n            previousClientRect = this.adapter_.getTabIndicatorClientRectAtIndex(previousActiveIndex);\n        }\n        this.adapter_.activateTabAtIndex(index, previousClientRect);\n        this.scrollIntoView(index);\n        this.adapter_.notifyTabActivated(index);\n    };\n    MDCTabBarFoundation.prototype.handleKeyDown = function (evt) {\n        // Get the key from the event\n        var key = this.getKeyFromEvent_(evt);\n        // Early exit if the event key isn't one of the keyboard navigation keys\n        if (key === undefined) {\n            return;\n        }\n        // Prevent default behavior for movement keys, but not for activation keys, since :active is used to apply ripple\n        if (!this.isActivationKey_(key)) {\n            evt.preventDefault();\n        }\n        if (this.useAutomaticActivation_) {\n            if (this.isActivationKey_(key)) {\n                return;\n            }\n            var index = this.determineTargetFromKey_(this.adapter_.getPreviousActiveTabIndex(), key);\n            this.adapter_.setActiveTab(index);\n            this.scrollIntoView(index);\n        }\n        else {\n            var focusedTabIndex = this.adapter_.getFocusedTabIndex();\n            if (this.isActivationKey_(key)) {\n                this.adapter_.setActiveTab(focusedTabIndex);\n            }\n            else {\n                var index = this.determineTargetFromKey_(focusedTabIndex, key);\n                this.adapter_.focusTabAtIndex(index);\n                this.scrollIntoView(index);\n            }\n        }\n    };\n    /**\n     * Handles the MDCTab:interacted event\n     */\n    MDCTabBarFoundation.prototype.handleTabInteraction = function (evt) {\n        this.adapter_.setActiveTab(this.adapter_.getIndexOfTabById(evt.detail.tabId));\n    };\n    /**\n     * Scrolls the tab at the given index into view\n     * @param index The tab index to make visible\n     */\n    MDCTabBarFoundation.prototype.scrollIntoView = function (index) {\n        // Early exit if the index is out of range\n        if (!this.indexIsInRange_(index)) {\n            return;\n        }\n        // Always scroll to 0 if scrolling to the 0th index\n        if (index === 0) {\n            return this.adapter_.scrollTo(0);\n        }\n        // Always scroll to the max value if scrolling to the Nth index\n        // MDCTabScroller.scrollTo() will never scroll past the max possible value\n        if (index === this.adapter_.getTabListLength() - 1) {\n            return this.adapter_.scrollTo(this.adapter_.getScrollContentWidth());\n        }\n        if (this.isRTL_()) {\n            return this.scrollIntoViewRTL_(index);\n        }\n        this.scrollIntoView_(index);\n    };\n    /**\n     * Private method for determining the index of the destination tab based on what key was pressed\n     * @param origin The original index from which to determine the destination\n     * @param key The name of the key\n     */\n    MDCTabBarFoundation.prototype.determineTargetFromKey_ = function (origin, key) {\n        var isRTL = this.isRTL_();\n        var maxIndex = this.adapter_.getTabListLength() - 1;\n        var shouldGoToEnd = key === strings.END_KEY;\n        var shouldDecrement = key === strings.ARROW_LEFT_KEY && !isRTL || key === strings.ARROW_RIGHT_KEY && isRTL;\n        var shouldIncrement = key === strings.ARROW_RIGHT_KEY && !isRTL || key === strings.ARROW_LEFT_KEY && isRTL;\n        var index = origin;\n        if (shouldGoToEnd) {\n            index = maxIndex;\n        }\n        else if (shouldDecrement) {\n            index -= 1;\n        }\n        else if (shouldIncrement) {\n            index += 1;\n        }\n        else {\n            index = 0;\n        }\n        if (index < 0) {\n            index = maxIndex;\n        }\n        else if (index > maxIndex) {\n            index = 0;\n        }\n        return index;\n    };\n    /**\n     * Calculates the scroll increment that will make the tab at the given index visible\n     * @param index The index of the tab\n     * @param nextIndex The index of the next tab\n     * @param scrollPosition The current scroll position\n     * @param barWidth The width of the Tab Bar\n     */\n    MDCTabBarFoundation.prototype.calculateScrollIncrement_ = function (index, nextIndex, scrollPosition, barWidth) {\n        var nextTabDimensions = this.adapter_.getTabDimensionsAtIndex(nextIndex);\n        var relativeContentLeft = nextTabDimensions.contentLeft - scrollPosition - barWidth;\n        var relativeContentRight = nextTabDimensions.contentRight - scrollPosition;\n        var leftIncrement = relativeContentRight - numbers.EXTRA_SCROLL_AMOUNT;\n        var rightIncrement = relativeContentLeft + numbers.EXTRA_SCROLL_AMOUNT;\n        if (nextIndex < index) {\n            return Math.min(leftIncrement, 0);\n        }\n        return Math.max(rightIncrement, 0);\n    };\n    /**\n     * Calculates the scroll increment that will make the tab at the given index visible in RTL\n     * @param index The index of the tab\n     * @param nextIndex The index of the next tab\n     * @param scrollPosition The current scroll position\n     * @param barWidth The width of the Tab Bar\n     * @param scrollContentWidth The width of the scroll content\n     */\n    MDCTabBarFoundation.prototype.calculateScrollIncrementRTL_ = function (index, nextIndex, scrollPosition, barWidth, scrollContentWidth) {\n        var nextTabDimensions = this.adapter_.getTabDimensionsAtIndex(nextIndex);\n        var relativeContentLeft = scrollContentWidth - nextTabDimensions.contentLeft - scrollPosition;\n        var relativeContentRight = scrollContentWidth - nextTabDimensions.contentRight - scrollPosition - barWidth;\n        var leftIncrement = relativeContentRight + numbers.EXTRA_SCROLL_AMOUNT;\n        var rightIncrement = relativeContentLeft - numbers.EXTRA_SCROLL_AMOUNT;\n        if (nextIndex > index) {\n            return Math.max(leftIncrement, 0);\n        }\n        return Math.min(rightIncrement, 0);\n    };\n    /**\n     * Determines the index of the adjacent tab closest to either edge of the Tab Bar\n     * @param index The index of the tab\n     * @param tabDimensions The dimensions of the tab\n     * @param scrollPosition The current scroll position\n     * @param barWidth The width of the tab bar\n     */\n    MDCTabBarFoundation.prototype.findAdjacentTabIndexClosestToEdge_ = function (index, tabDimensions, scrollPosition, barWidth) {\n        /**\n         * Tabs are laid out in the Tab Scroller like this:\n         *\n         *    Scroll Position\n         *    +---+\n         *    |   |   Bar Width\n         *    |   +-----------------------------------+\n         *    |   |                                   |\n         *    |   V                                   V\n         *    |   +-----------------------------------+\n         *    V   |             Tab Scroller          |\n         *    +------------+--------------+-------------------+\n         *    |    Tab     |      Tab     |        Tab        |\n         *    +------------+--------------+-------------------+\n         *        |                                   |\n         *        +-----------------------------------+\n         *\n         * To determine the next adjacent index, we look at the Tab root left and\n         * Tab root right, both relative to the scroll position. If the Tab root\n         * left is less than 0, then we know it's out of view to the left. If the\n         * Tab root right minus the bar width is greater than 0, we know the Tab is\n         * out of view to the right. From there, we either increment or decrement\n         * the index.\n         */\n        var relativeRootLeft = tabDimensions.rootLeft - scrollPosition;\n        var relativeRootRight = tabDimensions.rootRight - scrollPosition - barWidth;\n        var relativeRootDelta = relativeRootLeft + relativeRootRight;\n        var leftEdgeIsCloser = relativeRootLeft < 0 || relativeRootDelta < 0;\n        var rightEdgeIsCloser = relativeRootRight > 0 || relativeRootDelta > 0;\n        if (leftEdgeIsCloser) {\n            return index - 1;\n        }\n        if (rightEdgeIsCloser) {\n            return index + 1;\n        }\n        return -1;\n    };\n    /**\n     * Determines the index of the adjacent tab closest to either edge of the Tab Bar in RTL\n     * @param index The index of the tab\n     * @param tabDimensions The dimensions of the tab\n     * @param scrollPosition The current scroll position\n     * @param barWidth The width of the tab bar\n     * @param scrollContentWidth The width of the scroller content\n     */\n    MDCTabBarFoundation.prototype.findAdjacentTabIndexClosestToEdgeRTL_ = function (index, tabDimensions, scrollPosition, barWidth, scrollContentWidth) {\n        var rootLeft = scrollContentWidth - tabDimensions.rootLeft - barWidth - scrollPosition;\n        var rootRight = scrollContentWidth - tabDimensions.rootRight - scrollPosition;\n        var rootDelta = rootLeft + rootRight;\n        var leftEdgeIsCloser = rootLeft > 0 || rootDelta > 0;\n        var rightEdgeIsCloser = rootRight < 0 || rootDelta < 0;\n        if (leftEdgeIsCloser) {\n            return index + 1;\n        }\n        if (rightEdgeIsCloser) {\n            return index - 1;\n        }\n        return -1;\n    };\n    /**\n     * Returns the key associated with a keydown event\n     * @param evt The keydown event\n     */\n    MDCTabBarFoundation.prototype.getKeyFromEvent_ = function (evt) {\n        if (ACCEPTABLE_KEYS.has(evt.key)) {\n            return evt.key;\n        }\n        return KEYCODE_MAP.get(evt.keyCode);\n    };\n    MDCTabBarFoundation.prototype.isActivationKey_ = function (key) {\n        return key === strings.SPACE_KEY || key === strings.ENTER_KEY;\n    };\n    /**\n     * Returns whether a given index is inclusively between the ends\n     * @param index The index to test\n     */\n    MDCTabBarFoundation.prototype.indexIsInRange_ = function (index) {\n        return index >= 0 && index < this.adapter_.getTabListLength();\n    };\n    /**\n     * Returns the view's RTL property\n     */\n    MDCTabBarFoundation.prototype.isRTL_ = function () {\n        return this.adapter_.isRTL();\n    };\n    /**\n     * Scrolls the tab at the given index into view for left-to-right user agents.\n     * @param index The index of the tab to scroll into view\n     */\n    MDCTabBarFoundation.prototype.scrollIntoView_ = function (index) {\n        var scrollPosition = this.adapter_.getScrollPosition();\n        var barWidth = this.adapter_.getOffsetWidth();\n        var tabDimensions = this.adapter_.getTabDimensionsAtIndex(index);\n        var nextIndex = this.findAdjacentTabIndexClosestToEdge_(index, tabDimensions, scrollPosition, barWidth);\n        if (!this.indexIsInRange_(nextIndex)) {\n            return;\n        }\n        var scrollIncrement = this.calculateScrollIncrement_(index, nextIndex, scrollPosition, barWidth);\n        this.adapter_.incrementScroll(scrollIncrement);\n    };\n    /**\n     * Scrolls the tab at the given index into view in RTL\n     * @param index The tab index to make visible\n     */\n    MDCTabBarFoundation.prototype.scrollIntoViewRTL_ = function (index) {\n        var scrollPosition = this.adapter_.getScrollPosition();\n        var barWidth = this.adapter_.getOffsetWidth();\n        var tabDimensions = this.adapter_.getTabDimensionsAtIndex(index);\n        var scrollWidth = this.adapter_.getScrollContentWidth();\n        var nextIndex = this.findAdjacentTabIndexClosestToEdgeRTL_(index, tabDimensions, scrollPosition, barWidth, scrollWidth);\n        if (!this.indexIsInRange_(nextIndex)) {\n            return;\n        }\n        var scrollIncrement = this.calculateScrollIncrementRTL_(index, nextIndex, scrollPosition, barWidth, scrollWidth);\n        this.adapter_.incrementScroll(scrollIncrement);\n    };\n    return MDCTabBarFoundation;\n}(MDCFoundation));\nexport { MDCTabBarFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabBarFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, strings } from './constants';\nvar MDCTabIndicatorFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCTabIndicatorFoundation, _super);\n    function MDCTabIndicatorFoundation(adapter) {\n        return _super.call(this, tslib_1.__assign({}, MDCTabIndicatorFoundation.defaultAdapter, adapter)) || this;\n    }\n    Object.defineProperty(MDCTabIndicatorFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabIndicatorFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabIndicatorFoundation, \"defaultAdapter\", {\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                addClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                computeContentClientRect: function () { return ({ top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 }); },\n                setContentStyleProperty: function () { return undefined; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCTabIndicatorFoundation.prototype.computeContentClientRect = function () {\n        return this.adapter_.computeContentClientRect();\n    };\n    return MDCTabIndicatorFoundation;\n}(MDCFoundation));\nexport { MDCTabIndicatorFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabIndicatorFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, strings } from './constants';\nimport { MDCTabScrollerRTLDefault } from './rtl-default-scroller';\nimport { MDCTabScrollerRTLNegative } from './rtl-negative-scroller';\nimport { MDCTabScrollerRTLReverse } from './rtl-reverse-scroller';\nvar MDCTabScrollerFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCTabScrollerFoundation, _super);\n    function MDCTabScrollerFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCTabScrollerFoundation.defaultAdapter, adapter)) || this;\n        /**\n         * Controls whether we should handle the transitionend and interaction events during the animation.\n         */\n        _this.isAnimating_ = false;\n        return _this;\n    }\n    Object.defineProperty(MDCTabScrollerFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabScrollerFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabScrollerFoundation, \"defaultAdapter\", {\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                eventTargetMatchesSelector: function () { return false; },\n                addClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                addScrollAreaClass: function () { return undefined; },\n                setScrollAreaStyleProperty: function () { return undefined; },\n                setScrollContentStyleProperty: function () { return undefined; },\n                getScrollContentStyleValue: function () { return ''; },\n                setScrollAreaScrollLeft: function () { return undefined; },\n                getScrollAreaScrollLeft: function () { return 0; },\n                getScrollContentOffsetWidth: function () { return 0; },\n                getScrollAreaOffsetWidth: function () { return 0; },\n                computeScrollAreaClientRect: function () { return ({ top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 }); },\n                computeScrollContentClientRect: function () { return ({ top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 }); },\n                computeHorizontalScrollbarHeight: function () { return 0; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCTabScrollerFoundation.prototype.init = function () {\n        // Compute horizontal scrollbar height on scroller with overflow initially hidden, then update overflow to scroll\n        // and immediately adjust bottom margin to avoid the scrollbar initially appearing before JS runs.\n        var horizontalScrollbarHeight = this.adapter_.computeHorizontalScrollbarHeight();\n        this.adapter_.setScrollAreaStyleProperty('margin-bottom', -horizontalScrollbarHeight + 'px');\n        this.adapter_.addScrollAreaClass(MDCTabScrollerFoundation.cssClasses.SCROLL_AREA_SCROLL);\n    };\n    /**\n     * Computes the current visual scroll position\n     */\n    MDCTabScrollerFoundation.prototype.getScrollPosition = function () {\n        if (this.isRTL_()) {\n            return this.computeCurrentScrollPositionRTL_();\n        }\n        var currentTranslateX = this.calculateCurrentTranslateX_();\n        var scrollLeft = this.adapter_.getScrollAreaScrollLeft();\n        return scrollLeft - currentTranslateX;\n    };\n    /**\n     * Handles interaction events that occur during transition\n     */\n    MDCTabScrollerFoundation.prototype.handleInteraction = function () {\n        // Early exit if we aren't animating\n        if (!this.isAnimating_) {\n            return;\n        }\n        // Prevent other event listeners from handling this event\n        this.stopScrollAnimation_();\n    };\n    /**\n     * Handles the transitionend event\n     */\n    MDCTabScrollerFoundation.prototype.handleTransitionEnd = function (evt) {\n        // Early exit if we aren't animating or the event was triggered by a different element.\n        var evtTarget = evt.target;\n        if (!this.isAnimating_ ||\n            !this.adapter_.eventTargetMatchesSelector(evtTarget, MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)) {\n            return;\n        }\n        this.isAnimating_ = false;\n        this.adapter_.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n    };\n    /**\n     * Increment the scroll value by the scrollXIncrement\n     * @param scrollXIncrement The value by which to increment the scroll position\n     */\n    MDCTabScrollerFoundation.prototype.incrementScroll = function (scrollXIncrement) {\n        // Early exit for non-operational increment values\n        if (scrollXIncrement === 0) {\n            return;\n        }\n        if (this.isRTL_()) {\n            return this.incrementScrollRTL_(scrollXIncrement);\n        }\n        this.incrementScroll_(scrollXIncrement);\n    };\n    /**\n     * Scrolls to the given scrollX value\n     */\n    MDCTabScrollerFoundation.prototype.scrollTo = function (scrollX) {\n        if (this.isRTL_()) {\n            return this.scrollToRTL_(scrollX);\n        }\n        this.scrollTo_(scrollX);\n    };\n    /**\n     * @return Browser-specific {@link MDCTabScrollerRTL} instance.\n     */\n    MDCTabScrollerFoundation.prototype.getRTLScroller = function () {\n        if (!this.rtlScrollerInstance_) {\n            this.rtlScrollerInstance_ = this.rtlScrollerFactory_();\n        }\n        return this.rtlScrollerInstance_;\n    };\n    /**\n     * @return translateX value from a CSS matrix transform function string.\n     */\n    MDCTabScrollerFoundation.prototype.calculateCurrentTranslateX_ = function () {\n        var transformValue = this.adapter_.getScrollContentStyleValue('transform');\n        // Early exit if no transform is present\n        if (transformValue === 'none') {\n            return 0;\n        }\n        // The transform value comes back as a matrix transformation in the form\n        // of `matrix(a, b, c, d, tx, ty)`. We only care about tx (translateX) so\n        // we're going to grab all the parenthesized values, strip out tx, and\n        // parse it.\n        var match = /\\((.+?)\\)/.exec(transformValue);\n        if (!match) {\n            return 0;\n        }\n        var matrixParams = match[1];\n        // tslint:disable-next-line:ban-ts-ignore \"Unused vars\" should be a linter warning, not a compiler error.\n        // @ts-ignore These unused variables should retain their semantic names for clarity.\n        var _a = tslib_1.__read(matrixParams.split(','), 6), a = _a[0], b = _a[1], c = _a[2], d = _a[3], tx = _a[4], ty = _a[5];\n        return parseFloat(tx); // tslint:disable-line:ban\n    };\n    /**\n     * Calculates a safe scroll value that is > 0 and < the max scroll value\n     * @param scrollX The distance to scroll\n     */\n    MDCTabScrollerFoundation.prototype.clampScrollValue_ = function (scrollX) {\n        var edges = this.calculateScrollEdges_();\n        return Math.min(Math.max(edges.left, scrollX), edges.right);\n    };\n    MDCTabScrollerFoundation.prototype.computeCurrentScrollPositionRTL_ = function () {\n        var translateX = this.calculateCurrentTranslateX_();\n        return this.getRTLScroller().getScrollPositionRTL(translateX);\n    };\n    MDCTabScrollerFoundation.prototype.calculateScrollEdges_ = function () {\n        var contentWidth = this.adapter_.getScrollContentOffsetWidth();\n        var rootWidth = this.adapter_.getScrollAreaOffsetWidth();\n        return {\n            left: 0,\n            right: contentWidth - rootWidth,\n        };\n    };\n    /**\n     * Internal scroll method\n     * @param scrollX The new scroll position\n     */\n    MDCTabScrollerFoundation.prototype.scrollTo_ = function (scrollX) {\n        var currentScrollX = this.getScrollPosition();\n        var safeScrollX = this.clampScrollValue_(scrollX);\n        var scrollDelta = safeScrollX - currentScrollX;\n        this.animate_({\n            finalScrollPosition: safeScrollX,\n            scrollDelta: scrollDelta,\n        });\n    };\n    /**\n     * Internal RTL scroll method\n     * @param scrollX The new scroll position\n     */\n    MDCTabScrollerFoundation.prototype.scrollToRTL_ = function (scrollX) {\n        var animation = this.getRTLScroller().scrollToRTL(scrollX);\n        this.animate_(animation);\n    };\n    /**\n     * Internal increment scroll method\n     * @param scrollX The new scroll position increment\n     */\n    MDCTabScrollerFoundation.prototype.incrementScroll_ = function (scrollX) {\n        var currentScrollX = this.getScrollPosition();\n        var targetScrollX = scrollX + currentScrollX;\n        var safeScrollX = this.clampScrollValue_(targetScrollX);\n        var scrollDelta = safeScrollX - currentScrollX;\n        this.animate_({\n            finalScrollPosition: safeScrollX,\n            scrollDelta: scrollDelta,\n        });\n    };\n    /**\n     * Internal increment scroll RTL method\n     * @param scrollX The new scroll position RTL increment\n     */\n    MDCTabScrollerFoundation.prototype.incrementScrollRTL_ = function (scrollX) {\n        var animation = this.getRTLScroller().incrementScrollRTL(scrollX);\n        this.animate_(animation);\n    };\n    /**\n     * Animates the tab scrolling\n     * @param animation The animation to apply\n     */\n    MDCTabScrollerFoundation.prototype.animate_ = function (animation) {\n        var _this = this;\n        // Early exit if translateX is 0, which means there's no animation to perform\n        if (animation.scrollDelta === 0) {\n            return;\n        }\n        this.stopScrollAnimation_();\n        // This animation uses the FLIP approach.\n        // Read more here: https://aerotwist.com/blog/flip-your-animations/\n        this.adapter_.setScrollAreaScrollLeft(animation.finalScrollPosition);\n        this.adapter_.setScrollContentStyleProperty('transform', \"translateX(\" + animation.scrollDelta + \"px)\");\n        // Force repaint\n        this.adapter_.computeScrollAreaClientRect();\n        requestAnimationFrame(function () {\n            _this.adapter_.addClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n            _this.adapter_.setScrollContentStyleProperty('transform', 'none');\n        });\n        this.isAnimating_ = true;\n    };\n    /**\n     * Stops scroll animation\n     */\n    MDCTabScrollerFoundation.prototype.stopScrollAnimation_ = function () {\n        this.isAnimating_ = false;\n        var currentScrollPosition = this.getAnimatingScrollPosition_();\n        this.adapter_.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n        this.adapter_.setScrollContentStyleProperty('transform', 'translateX(0px)');\n        this.adapter_.setScrollAreaScrollLeft(currentScrollPosition);\n    };\n    /**\n     * Gets the current scroll position during animation\n     */\n    MDCTabScrollerFoundation.prototype.getAnimatingScrollPosition_ = function () {\n        var currentTranslateX = this.calculateCurrentTranslateX_();\n        var scrollLeft = this.adapter_.getScrollAreaScrollLeft();\n        if (this.isRTL_()) {\n            return this.getRTLScroller().getAnimatingScrollPosition(scrollLeft, currentTranslateX);\n        }\n        return scrollLeft - currentTranslateX;\n    };\n    /**\n     * Determines the RTL Scroller to use\n     */\n    MDCTabScrollerFoundation.prototype.rtlScrollerFactory_ = function () {\n        // Browsers have three different implementations of scrollLeft in RTL mode,\n        // dependent on the browser. The behavior is based off the max LTR\n        // scrollLeft value and 0.\n        //\n        // * Default scrolling in RTL *\n        //    - Left-most value: 0\n        //    - Right-most value: Max LTR scrollLeft value\n        //\n        // * Negative scrolling in RTL *\n        //    - Left-most value: Negated max LTR scrollLeft value\n        //    - Right-most value: 0\n        //\n        // * Reverse scrolling in RTL *\n        //    - Left-most value: Max LTR scrollLeft value\n        //    - Right-most value: 0\n        //\n        // We use those principles below to determine which RTL scrollLeft\n        // behavior is implemented in the current browser.\n        var initialScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n        this.adapter_.setScrollAreaScrollLeft(initialScrollLeft - 1);\n        var newScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n        // If the newScrollLeft value is negative,then we know that the browser has\n        // implemented negative RTL scrolling, since all other implementations have\n        // only positive values.\n        if (newScrollLeft < 0) {\n            // Undo the scrollLeft test check\n            this.adapter_.setScrollAreaScrollLeft(initialScrollLeft);\n            return new MDCTabScrollerRTLNegative(this.adapter_);\n        }\n        var rootClientRect = this.adapter_.computeScrollAreaClientRect();\n        var contentClientRect = this.adapter_.computeScrollContentClientRect();\n        var rightEdgeDelta = Math.round(contentClientRect.right - rootClientRect.right);\n        // Undo the scrollLeft test check\n        this.adapter_.setScrollAreaScrollLeft(initialScrollLeft);\n        // By calculating the clientRect of the root element and the clientRect of\n        // the content element, we can determine how much the scroll value changed\n        // when we performed the scrollLeft subtraction above.\n        if (rightEdgeDelta === newScrollLeft) {\n            return new MDCTabScrollerRTLReverse(this.adapter_);\n        }\n        return new MDCTabScrollerRTLDefault(this.adapter_);\n    };\n    MDCTabScrollerFoundation.prototype.isRTL_ = function () {\n        return this.adapter_.getScrollContentStyleValue('direction') === 'rtl';\n    };\n    return MDCTabScrollerFoundation;\n}(MDCFoundation));\nexport { MDCTabScrollerFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, strings } from './constants';\nvar MDCTabFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCTabFoundation, _super);\n    function MDCTabFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCTabFoundation.defaultAdapter, adapter)) || this;\n        _this.focusOnActivate_ = true;\n        return _this;\n    }\n    Object.defineProperty(MDCTabFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCTabFoundation, \"defaultAdapter\", {\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                addClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                hasClass: function () { return false; },\n                setAttr: function () { return undefined; },\n                activateIndicator: function () { return undefined; },\n                deactivateIndicator: function () { return undefined; },\n                notifyInteracted: function () { return undefined; },\n                getOffsetLeft: function () { return 0; },\n                getOffsetWidth: function () { return 0; },\n                getContentOffsetLeft: function () { return 0; },\n                getContentOffsetWidth: function () { return 0; },\n                focus: function () { return undefined; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCTabFoundation.prototype.handleClick = function () {\n        // It's up to the parent component to keep track of the active Tab and\n        // ensure we don't activate a Tab that's already active.\n        this.adapter_.notifyInteracted();\n    };\n    MDCTabFoundation.prototype.isActive = function () {\n        return this.adapter_.hasClass(cssClasses.ACTIVE);\n    };\n    /**\n     * Sets whether the tab should focus itself when activated\n     */\n    MDCTabFoundation.prototype.setFocusOnActivate = function (focusOnActivate) {\n        this.focusOnActivate_ = focusOnActivate;\n    };\n    /**\n     * Activates the Tab\n     */\n    MDCTabFoundation.prototype.activate = function (previousIndicatorClientRect) {\n        this.adapter_.addClass(cssClasses.ACTIVE);\n        this.adapter_.setAttr(strings.ARIA_SELECTED, 'true');\n        this.adapter_.setAttr(strings.TABINDEX, '0');\n        this.adapter_.activateIndicator(previousIndicatorClientRect);\n        if (this.focusOnActivate_) {\n            this.adapter_.focus();\n        }\n    };\n    /**\n     * Deactivates the Tab\n     */\n    MDCTabFoundation.prototype.deactivate = function () {\n        // Early exit\n        if (!this.isActive()) {\n            return;\n        }\n        this.adapter_.removeClass(cssClasses.ACTIVE);\n        this.adapter_.setAttr(strings.ARIA_SELECTED, 'false');\n        this.adapter_.setAttr(strings.TABINDEX, '-1');\n        this.adapter_.deactivateIndicator();\n    };\n    /**\n     * Returns the dimensions of the Tab\n     */\n    MDCTabFoundation.prototype.computeDimensions = function () {\n        var rootWidth = this.adapter_.getOffsetWidth();\n        var rootLeft = this.adapter_.getOffsetLeft();\n        var contentWidth = this.adapter_.getContentOffsetWidth();\n        var contentLeft = this.adapter_.getContentOffsetLeft();\n        return {\n            contentLeft: rootLeft + contentLeft,\n            contentRight: rootLeft + contentLeft + contentWidth,\n            rootLeft: rootLeft,\n            rootRight: rootLeft + rootWidth,\n        };\n    };\n    return MDCTabFoundation;\n}(MDCFoundation));\nexport { MDCTabFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabFoundation;\n//# sourceMappingURL=foundation.js.map"],"names":["MDCCheckboxFoundation","_super","adapter","_this","call","this","defaultAdapter","currentCheckState_","currentAnimationClass_","animEndLatchTimer_","enableAnimationEndHandler_","Object","defineProperty","get","enumerable","configurable","addClass","forceLayout","hasNativeControl","isAttachedToDOM","isChecked","isIndeterminate","removeClass","removeNativeControlAttr","setNativeControlAttr","setNativeControlDisabled","prototype","init","determineCheckState_","updateAriaChecked_","adapter_","destroy","clearTimeout","setDisabled","disabled","handleAnimationEnd","setTimeout","handleChange","transitionCheckState_","oldState","newState","TRANSITION_STATE_UNCHECKED","SELECTED","length","getTransitionAnimationClass_","TRANSITION_STATE_INDETERMINATE","TRANSITION_STATE_CHECKED","TRANSITION_STATE_INIT","_a","cssClasses","ANIM_UNCHECKED_CHECKED","ANIM_UNCHECKED_INDETERMINATE","ANIM_CHECKED_UNCHECKED","ANIM_CHECKED_INDETERMINATE","ANIM_INDETERMINATE_CHECKED","ANIM_INDETERMINATE_UNCHECKED","MDCDismissibleDrawerFoundation","animationFrame_","animationTimer_","hasClass","elementHasClass","notifyClose","notifyOpen","saveFocus","restoreFocus","focusActiveNavigationItem","trapFocus","releaseFocus","cancelAnimationFrame","open","isOpen","isOpening","isClosing","runNextAnimationFrame_","close","handleKeydown","evt","keyCode","key","handleTransitionEnd","OPENING","CLOSING","OPEN","ANIMATE","ROOT","isElement_","target","closed_","opened_","callback","requestAnimationFrame","element","Boolean","classList","MDCModalDrawerFoundation","apply","arguments","handleScrimClick","MDCFormFieldFoundation","clickHandler_","handleClick_","activateInputRipple","deactivateInputRipple","deregisterInteractionHandler","registerInteractionHandler","ACCEPTABLE_KEYS","Set","add","KEYCODE_MAP","Map","set","MDCTabBarFoundation","useAutomaticActivation_","scrollTo","incrementScroll","getScrollPosition","getScrollContentWidth","getOffsetWidth","isRTL","setActiveTab","activateTabAtIndex","deactivateTabAtIndex","focusTabAtIndex","getTabIndicatorClientRectAtIndex","top","right","bottom","left","width","height","getTabDimensionsAtIndex","rootLeft","rootRight","contentLeft","contentRight","getPreviousActiveTabIndex","getFocusedTabIndex","getIndexOfTabById","getTabListLength","notifyTabActivated","setUseAutomaticActivation","useAutomaticActivation","activateTab","index","previousClientRect","previousActiveIndex","indexIsInRange_","scrollIntoView","handleKeyDown","getKeyFromEvent_","undefined","isActivationKey_","preventDefault","determineTargetFromKey_","focusedTabIndex","handleTabInteraction","detail","tabId","isRTL_","scrollIntoViewRTL_","scrollIntoView_","origin","maxIndex","shouldGoToEnd","shouldDecrement","shouldIncrement","calculateScrollIncrement_","nextIndex","scrollPosition","barWidth","nextTabDimensions","relativeContentLeft","leftIncrement","rightIncrement","Math","min","max","calculateScrollIncrementRTL_","scrollContentWidth","findAdjacentTabIndexClosestToEdge_","tabDimensions","relativeRootLeft","relativeRootRight","relativeRootDelta","findAdjacentTabIndexClosestToEdgeRTL_","rootDelta","has","scrollIncrement","scrollWidth","MDCTabIndicatorFoundation","computeContentClientRect","setContentStyleProperty","MDCTabScrollerFoundation","isAnimating_","eventTargetMatchesSelector","addScrollAreaClass","setScrollAreaStyleProperty","setScrollContentStyleProperty","getScrollContentStyleValue","setScrollAreaScrollLeft","getScrollAreaScrollLeft","getScrollContentOffsetWidth","getScrollAreaOffsetWidth","computeScrollAreaClientRect","computeScrollContentClientRect","computeHorizontalScrollbarHeight","horizontalScrollbarHeight","SCROLL_AREA_SCROLL","computeCurrentScrollPositionRTL_","currentTranslateX","calculateCurrentTranslateX_","handleInteraction","stopScrollAnimation_","evtTarget","strings","CONTENT_SELECTOR","ANIMATING","scrollXIncrement","incrementScrollRTL_","incrementScroll_","scrollX","scrollToRTL_","scrollTo_","getRTLScroller","rtlScrollerInstance_","rtlScrollerFactory_","transformValue","match","exec","matrixParams","split","tx","parseFloat","clampScrollValue_","edges","calculateScrollEdges_","translateX","getScrollPositionRTL","currentScrollX","safeScrollX","scrollDelta","animate_","finalScrollPosition","animation","scrollToRTL","targetScrollX","incrementScrollRTL","currentScrollPosition","getAnimatingScrollPosition_","scrollLeft","getAnimatingScrollPosition","initialScrollLeft","newScrollLeft","rootClientRect","contentClientRect","rightEdgeDelta","round","MDCTabFoundation","focusOnActivate_","setAttr","activateIndicator","deactivateIndicator","notifyInteracted","getOffsetLeft","getContentOffsetLeft","getContentOffsetWidth","focus","handleClick","isActive","setFocusOnActivate","focusOnActivate","activate","previousIndicatorClientRect","deactivate","computeDimensions","rootWidth","contentWidth"],"sourceRoot":""}