{"version":3,"file":"vortex.7858.cc3f56083b2f4002ed45.bundle.js","mappings":"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","sources":["webpack://vortex-frontend/../../node_modules/.pnpm/lit-element@2.4.0/node_modules/lit-element/lib/updating-element.js","webpack://vortex-frontend/../../node_modules/.pnpm/lit-element@2.4.0/node_modules/lit-element/lib/decorators.js","webpack://vortex-frontend/../../node_modules/.pnpm/lit-element@2.4.0/node_modules/lit-element/lib/css-tag.js","webpack://vortex-frontend/../../node_modules/.pnpm/lit-element@2.4.0/node_modules/lit-element/lit-element.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+dialog@12.0.0-canary.197f64fa2.0/node_modules/@material/dialog/foundation.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+dialog@12.0.0-canary.197f64fa2.0/node_modules/@material/dialog/constants.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+animation@12.0.0-canary.197f64fa2.0/node_modules/@material/animation/animationframe.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+base@12.0.0-canary.197f64fa2.0/node_modules/@material/base/foundation.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+dom@12.0.0-canary.197f64fa2.0/node_modules/@material/dom/events.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+dom@12.0.0-canary.197f64fa2.0/node_modules/@material/dom/ponyfill.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-base@0.21.0/node_modules/@material/mwc-base/utils.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-base@0.21.0/node_modules/@material/mwc-base/base-element.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-base@0.21.0/node_modules/@material/mwc-base/observer.js","webpack://vortex-frontend/../../node_modules/.pnpm/lit-html@1.4.1/node_modules/lit-html/directives/class-map.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-dialog@0.21.0/node_modules/@material/mwc-dialog/mwc-dialog-base.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-dialog@0.21.0/node_modules/@material/mwc-dialog/mwc-dialog-css.js","webpack://vortex-frontend/../../node_modules/.pnpm/@material+mwc-dialog@0.21.0/node_modules/@material/mwc-dialog/mwc-dialog.js","webpack://vortex-frontend/../../node_modules/.pnpm/blocking-elements@0.1.1/node_modules/blocking-elements/dist/blocking-elements.js","webpack://vortex-frontend/../../node_modules/.pnpm/wicg-inert@3.1.2/node_modules/wicg-inert/dist/inert.esm.js","webpack://vortex-frontend/../../node_modules/.pnpm/tslib@2.6.2/node_modules/tslib/tslib.es6.mjs"],"sourcesContent":["/**\n * @license\n * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\nvar _a;\n/**\n * Use this module if you want to create your own base class extending\n * [[UpdatingElement]].\n * @packageDocumentation\n */\n/*\n * When using Closure Compiler, JSCompiler_renameProperty(property, object) is\n * replaced at compile time by the munged name for object[property]. We cannot\n * alias this function, so we have to use a small shim that has the same\n * behavior when not compiling.\n */\nwindow.JSCompiler_renameProperty =\n    (prop, _obj) => prop;\nexport const defaultConverter = {\n    toAttribute(value, type) {\n        switch (type) {\n            case Boolean:\n                return value ? '' : null;\n            case Object:\n            case Array:\n                // if the value is `null` or `undefined` pass this through\n                // to allow removing/no change behavior.\n                return value == null ? value : JSON.stringify(value);\n        }\n        return value;\n    },\n    fromAttribute(value, type) {\n        switch (type) {\n            case Boolean:\n                return value !== null;\n            case Number:\n                return value === null ? null : Number(value);\n            case Object:\n            case Array:\n                return JSON.parse(value);\n        }\n        return value;\n    }\n};\n/**\n * Change function that returns true if `value` is different from `oldValue`.\n * This method is used as the default for a property's `hasChanged` function.\n */\nexport const notEqual = (value, old) => {\n    // This ensures (old==NaN, value==NaN) always returns false\n    return old !== value && (old === old || value === value);\n};\nconst defaultPropertyDeclaration = {\n    attribute: true,\n    type: String,\n    converter: defaultConverter,\n    reflect: false,\n    hasChanged: notEqual\n};\nconst STATE_HAS_UPDATED = 1;\nconst STATE_UPDATE_REQUESTED = 1 << 2;\nconst STATE_IS_REFLECTING_TO_ATTRIBUTE = 1 << 3;\nconst STATE_IS_REFLECTING_TO_PROPERTY = 1 << 4;\n/**\n * The Closure JS Compiler doesn't currently have good support for static\n * property semantics where \"this\" is dynamic (e.g.\n * https://github.com/google/closure-compiler/issues/3177 and others) so we use\n * this hack to bypass any rewriting by the compiler.\n */\nconst finalized = 'finalized';\n/**\n * Base element class which manages element properties and attributes. When\n * properties change, the `update` method is asynchronously called. This method\n * should be supplied by subclassers to render updates as desired.\n * @noInheritDoc\n */\nexport class UpdatingElement extends HTMLElement {\n    constructor() {\n        super();\n        this.initialize();\n    }\n    /**\n     * Returns a list of attributes corresponding to the registered properties.\n     * @nocollapse\n     */\n    static get observedAttributes() {\n        // note: piggy backing on this to ensure we're finalized.\n        this.finalize();\n        const attributes = [];\n        // Use forEach so this works even if for/of loops are compiled to for loops\n        // expecting arrays\n        this._classProperties.forEach((v, p) => {\n            const attr = this._attributeNameForProperty(p, v);\n            if (attr !== undefined) {\n                this._attributeToPropertyMap.set(attr, p);\n                attributes.push(attr);\n            }\n        });\n        return attributes;\n    }\n    /**\n     * Ensures the private `_classProperties` property metadata is created.\n     * In addition to `finalize` this is also called in `createProperty` to\n     * ensure the `@property` decorator can add property metadata.\n     */\n    /** @nocollapse */\n    static _ensureClassProperties() {\n        // ensure private storage for property declarations.\n        if (!this.hasOwnProperty(JSCompiler_renameProperty('_classProperties', this))) {\n            this._classProperties = new Map();\n            // NOTE: Workaround IE11 not supporting Map constructor argument.\n            const superProperties = Object.getPrototypeOf(this)._classProperties;\n            if (superProperties !== undefined) {\n                superProperties.forEach((v, k) => this._classProperties.set(k, v));\n            }\n        }\n    }\n    /**\n     * Creates a property accessor on the element prototype if one does not exist\n     * and stores a PropertyDeclaration for the property with the given options.\n     * The property setter calls the property's `hasChanged` property option\n     * or uses a strict identity check to determine whether or not to request\n     * an update.\n     *\n     * This method may be overridden to customize properties; however,\n     * when doing so, it's important to call `super.createProperty` to ensure\n     * the property is setup correctly. This method calls\n     * `getPropertyDescriptor` internally to get a descriptor to install.\n     * To customize what properties do when they are get or set, override\n     * `getPropertyDescriptor`. To customize the options for a property,\n     * implement `createProperty` like this:\n     *\n     * static createProperty(name, options) {\n     *   options = Object.assign(options, {myOption: true});\n     *   super.createProperty(name, options);\n     * }\n     *\n     * @nocollapse\n     */\n    static createProperty(name, options = defaultPropertyDeclaration) {\n        // Note, since this can be called by the `@property` decorator which\n        // is called before `finalize`, we ensure storage exists for property\n        // metadata.\n        this._ensureClassProperties();\n        this._classProperties.set(name, options);\n        // Do not generate an accessor if the prototype already has one, since\n        // it would be lost otherwise and that would never be the user's intention;\n        // Instead, we expect users to call `requestUpdate` themselves from\n        // user-defined accessors. Note that if the super has an accessor we will\n        // still overwrite it\n        if (options.noAccessor || this.prototype.hasOwnProperty(name)) {\n            return;\n        }\n        const key = typeof name === 'symbol' ? Symbol() : `__${name}`;\n        const descriptor = this.getPropertyDescriptor(name, key, options);\n        if (descriptor !== undefined) {\n            Object.defineProperty(this.prototype, name, descriptor);\n        }\n    }\n    /**\n     * Returns a property descriptor to be defined on the given named property.\n     * If no descriptor is returned, the property will not become an accessor.\n     * For example,\n     *\n     *   class MyElement extends LitElement {\n     *     static getPropertyDescriptor(name, key, options) {\n     *       const defaultDescriptor =\n     *           super.getPropertyDescriptor(name, key, options);\n     *       const setter = defaultDescriptor.set;\n     *       return {\n     *         get: defaultDescriptor.get,\n     *         set(value) {\n     *           setter.call(this, value);\n     *           // custom action.\n     *         },\n     *         configurable: true,\n     *         enumerable: true\n     *       }\n     *     }\n     *   }\n     *\n     * @nocollapse\n     */\n    static getPropertyDescriptor(name, key, options) {\n        return {\n            // tslint:disable-next-line:no-any no symbol in index\n            get() {\n                return this[key];\n            },\n            set(value) {\n                const oldValue = this[name];\n                this[key] = value;\n                this\n                    .requestUpdateInternal(name, oldValue, options);\n            },\n            configurable: true,\n            enumerable: true\n        };\n    }\n    /**\n     * Returns the property options associated with the given property.\n     * These options are defined with a PropertyDeclaration via the `properties`\n     * object or the `@property` decorator and are registered in\n     * `createProperty(...)`.\n     *\n     * Note, this method should be considered \"final\" and not overridden. To\n     * customize the options for a given property, override `createProperty`.\n     *\n     * @nocollapse\n     * @final\n     */\n    static getPropertyOptions(name) {\n        return this._classProperties && this._classProperties.get(name) ||\n            defaultPropertyDeclaration;\n    }\n    /**\n     * Creates property accessors for registered properties and ensures\n     * any superclasses are also finalized.\n     * @nocollapse\n     */\n    static finalize() {\n        // finalize any superclasses\n        const superCtor = Object.getPrototypeOf(this);\n        if (!superCtor.hasOwnProperty(finalized)) {\n            superCtor.finalize();\n        }\n        this[finalized] = true;\n        this._ensureClassProperties();\n        // initialize Map populated in observedAttributes\n        this._attributeToPropertyMap = new Map();\n        // make any properties\n        // Note, only process \"own\" properties since this element will inherit\n        // any properties defined on the superClass, and finalization ensures\n        // the entire prototype chain is finalized.\n        if (this.hasOwnProperty(JSCompiler_renameProperty('properties', this))) {\n            const props = this.properties;\n            // support symbols in properties (IE11 does not support this)\n            const propKeys = [\n                ...Object.getOwnPropertyNames(props),\n                ...(typeof Object.getOwnPropertySymbols === 'function') ?\n                    Object.getOwnPropertySymbols(props) :\n                    []\n            ];\n            // This for/of is ok because propKeys is an array\n            for (const p of propKeys) {\n                // note, use of `any` is due to TypeSript lack of support for symbol in\n                // index types\n                // tslint:disable-next-line:no-any no symbol in index\n                this.createProperty(p, props[p]);\n            }\n        }\n    }\n    /**\n     * Returns the property name for the given attribute `name`.\n     * @nocollapse\n     */\n    static _attributeNameForProperty(name, options) {\n        const attribute = options.attribute;\n        return attribute === false ?\n            undefined :\n            (typeof attribute === 'string' ?\n                attribute :\n                (typeof name === 'string' ? name.toLowerCase() : undefined));\n    }\n    /**\n     * Returns true if a property should request an update.\n     * Called when a property value is set and uses the `hasChanged`\n     * option for the property if present or a strict identity check.\n     * @nocollapse\n     */\n    static _valueHasChanged(value, old, hasChanged = notEqual) {\n        return hasChanged(value, old);\n    }\n    /**\n     * Returns the property value for the given attribute value.\n     * Called via the `attributeChangedCallback` and uses the property's\n     * `converter` or `converter.fromAttribute` property option.\n     * @nocollapse\n     */\n    static _propertyValueFromAttribute(value, options) {\n        const type = options.type;\n        const converter = options.converter || defaultConverter;\n        const fromAttribute = (typeof converter === 'function' ? converter : converter.fromAttribute);\n        return fromAttribute ? fromAttribute(value, type) : value;\n    }\n    /**\n     * Returns the attribute value for the given property value. If this\n     * returns undefined, the property will *not* be reflected to an attribute.\n     * If this returns null, the attribute will be removed, otherwise the\n     * attribute will be set to the value.\n     * This uses the property's `reflect` and `type.toAttribute` property options.\n     * @nocollapse\n     */\n    static _propertyValueToAttribute(value, options) {\n        if (options.reflect === undefined) {\n            return;\n        }\n        const type = options.type;\n        const converter = options.converter;\n        const toAttribute = converter && converter.toAttribute ||\n            defaultConverter.toAttribute;\n        return toAttribute(value, type);\n    }\n    /**\n     * Performs element initialization. By default captures any pre-set values for\n     * registered properties.\n     */\n    initialize() {\n        this._updateState = 0;\n        this._updatePromise =\n            new Promise((res) => this._enableUpdatingResolver = res);\n        this._changedProperties = new Map();\n        this._saveInstanceProperties();\n        // ensures first update will be caught by an early access of\n        // `updateComplete`\n        this.requestUpdateInternal();\n    }\n    /**\n     * Fixes any properties set on the instance before upgrade time.\n     * Otherwise these would shadow the accessor and break these properties.\n     * The properties are stored in a Map which is played back after the\n     * constructor runs. Note, on very old versions of Safari (<=9) or Chrome\n     * (<=41), properties created for native platform properties like (`id` or\n     * `name`) may not have default values set in the element constructor. On\n     * these browsers native properties appear on instances and therefore their\n     * default value will overwrite any element default (e.g. if the element sets\n     * this.id = 'id' in the constructor, the 'id' will become '' since this is\n     * the native platform default).\n     */\n    _saveInstanceProperties() {\n        // Use forEach so this works even if for/of loops are compiled to for loops\n        // expecting arrays\n        this.constructor\n            ._classProperties.forEach((_v, p) => {\n            if (this.hasOwnProperty(p)) {\n                const value = this[p];\n                delete this[p];\n                if (!this._instanceProperties) {\n                    this._instanceProperties = new Map();\n                }\n                this._instanceProperties.set(p, value);\n            }\n        });\n    }\n    /**\n     * Applies previously saved instance properties.\n     */\n    _applyInstanceProperties() {\n        // Use forEach so this works even if for/of loops are compiled to for loops\n        // expecting arrays\n        // tslint:disable-next-line:no-any\n        this._instanceProperties.forEach((v, p) => this[p] = v);\n        this._instanceProperties = undefined;\n    }\n    connectedCallback() {\n        // Ensure first connection completes an update. Updates cannot complete\n        // before connection.\n        this.enableUpdating();\n    }\n    enableUpdating() {\n        if (this._enableUpdatingResolver !== undefined) {\n            this._enableUpdatingResolver();\n            this._enableUpdatingResolver = undefined;\n        }\n    }\n    /**\n     * Allows for `super.disconnectedCallback()` in extensions while\n     * reserving the possibility of making non-breaking feature additions\n     * when disconnecting at some point in the future.\n     */\n    disconnectedCallback() {\n    }\n    /**\n     * Synchronizes property values when attributes change.\n     */\n    attributeChangedCallback(name, old, value) {\n        if (old !== value) {\n            this._attributeToProperty(name, value);\n        }\n    }\n    _propertyToAttribute(name, value, options = defaultPropertyDeclaration) {\n        const ctor = this.constructor;\n        const attr = ctor._attributeNameForProperty(name, options);\n        if (attr !== undefined) {\n            const attrValue = ctor._propertyValueToAttribute(value, options);\n            // an undefined value does not change the attribute.\n            if (attrValue === undefined) {\n                return;\n            }\n            // Track if the property is being reflected to avoid\n            // setting the property again via `attributeChangedCallback`. Note:\n            // 1. this takes advantage of the fact that the callback is synchronous.\n            // 2. will behave incorrectly if multiple attributes are in the reaction\n            // stack at time of calling. However, since we process attributes\n            // in `update` this should not be possible (or an extreme corner case\n            // that we'd like to discover).\n            // mark state reflecting\n            this._updateState = this._updateState | STATE_IS_REFLECTING_TO_ATTRIBUTE;\n            if (attrValue == null) {\n                this.removeAttribute(attr);\n            }\n            else {\n                this.setAttribute(attr, attrValue);\n            }\n            // mark state not reflecting\n            this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_ATTRIBUTE;\n        }\n    }\n    _attributeToProperty(name, value) {\n        // Use tracking info to avoid deserializing attribute value if it was\n        // just set from a property setter.\n        if (this._updateState & STATE_IS_REFLECTING_TO_ATTRIBUTE) {\n            return;\n        }\n        const ctor = this.constructor;\n        // Note, hint this as an `AttributeMap` so closure clearly understands\n        // the type; it has issues with tracking types through statics\n        // tslint:disable-next-line:no-unnecessary-type-assertion\n        const propName = ctor._attributeToPropertyMap.get(name);\n        if (propName !== undefined) {\n            const options = ctor.getPropertyOptions(propName);\n            // mark state reflecting\n            this._updateState = this._updateState | STATE_IS_REFLECTING_TO_PROPERTY;\n            this[propName] =\n                // tslint:disable-next-line:no-any\n                ctor._propertyValueFromAttribute(value, options);\n            // mark state not reflecting\n            this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_PROPERTY;\n        }\n    }\n    /**\n     * This protected version of `requestUpdate` does not access or return the\n     * `updateComplete` promise. This promise can be overridden and is therefore\n     * not free to access.\n     */\n    requestUpdateInternal(name, oldValue, options) {\n        let shouldRequestUpdate = true;\n        // If we have a property key, perform property update steps.\n        if (name !== undefined) {\n            const ctor = this.constructor;\n            options = options || ctor.getPropertyOptions(name);\n            if (ctor._valueHasChanged(this[name], oldValue, options.hasChanged)) {\n                if (!this._changedProperties.has(name)) {\n                    this._changedProperties.set(name, oldValue);\n                }\n                // Add to reflecting properties set.\n                // Note, it's important that every change has a chance to add the\n                // property to `_reflectingProperties`. This ensures setting\n                // attribute + property reflects correctly.\n                if (options.reflect === true &&\n                    !(this._updateState & STATE_IS_REFLECTING_TO_PROPERTY)) {\n                    if (this._reflectingProperties === undefined) {\n                        this._reflectingProperties = new Map();\n                    }\n                    this._reflectingProperties.set(name, options);\n                }\n            }\n            else {\n                // Abort the request if the property should not be considered changed.\n                shouldRequestUpdate = false;\n            }\n        }\n        if (!this._hasRequestedUpdate && shouldRequestUpdate) {\n            this._updatePromise = this._enqueueUpdate();\n        }\n    }\n    /**\n     * Requests an update which is processed asynchronously. This should\n     * be called when an element should update based on some state not triggered\n     * by setting a property. In this case, pass no arguments. It should also be\n     * called when manually implementing a property setter. In this case, pass the\n     * property `name` and `oldValue` to ensure that any configured property\n     * options are honored. Returns the `updateComplete` Promise which is resolved\n     * when the update completes.\n     *\n     * @param name {PropertyKey} (optional) name of requesting property\n     * @param oldValue {any} (optional) old value of requesting property\n     * @returns {Promise} A Promise that is resolved when the update completes.\n     */\n    requestUpdate(name, oldValue) {\n        this.requestUpdateInternal(name, oldValue);\n        return this.updateComplete;\n    }\n    /**\n     * Sets up the element to asynchronously update.\n     */\n    async _enqueueUpdate() {\n        this._updateState = this._updateState | STATE_UPDATE_REQUESTED;\n        try {\n            // Ensure any previous update has resolved before updating.\n            // This `await` also ensures that property changes are batched.\n            await this._updatePromise;\n        }\n        catch (e) {\n            // Ignore any previous errors. We only care that the previous cycle is\n            // done. Any error should have been handled in the previous update.\n        }\n        const result = this.performUpdate();\n        // If `performUpdate` returns a Promise, we await it. This is done to\n        // enable coordinating updates with a scheduler. Note, the result is\n        // checked to avoid delaying an additional microtask unless we need to.\n        if (result != null) {\n            await result;\n        }\n        return !this._hasRequestedUpdate;\n    }\n    get _hasRequestedUpdate() {\n        return (this._updateState & STATE_UPDATE_REQUESTED);\n    }\n    get hasUpdated() {\n        return (this._updateState & STATE_HAS_UPDATED);\n    }\n    /**\n     * Performs an element update. Note, if an exception is thrown during the\n     * update, `firstUpdated` and `updated` will not be called.\n     *\n     * You can override this method to change the timing of updates. If this\n     * method is overridden, `super.performUpdate()` must be called.\n     *\n     * For instance, to schedule updates to occur just before the next frame:\n     *\n     * ```\n     * protected async performUpdate(): Promise<unknown> {\n     *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));\n     *   super.performUpdate();\n     * }\n     * ```\n     */\n    performUpdate() {\n        // Abort any update if one is not pending when this is called.\n        // This can happen if `performUpdate` is called early to \"flush\"\n        // the update.\n        if (!this._hasRequestedUpdate) {\n            return;\n        }\n        // Mixin instance properties once, if they exist.\n        if (this._instanceProperties) {\n            this._applyInstanceProperties();\n        }\n        let shouldUpdate = false;\n        const changedProperties = this._changedProperties;\n        try {\n            shouldUpdate = this.shouldUpdate(changedProperties);\n            if (shouldUpdate) {\n                this.update(changedProperties);\n            }\n            else {\n                this._markUpdated();\n            }\n        }\n        catch (e) {\n            // Prevent `firstUpdated` and `updated` from running when there's an\n            // update exception.\n            shouldUpdate = false;\n            // Ensure element can accept additional updates after an exception.\n            this._markUpdated();\n            throw e;\n        }\n        if (shouldUpdate) {\n            if (!(this._updateState & STATE_HAS_UPDATED)) {\n                this._updateState = this._updateState | STATE_HAS_UPDATED;\n                this.firstUpdated(changedProperties);\n            }\n            this.updated(changedProperties);\n        }\n    }\n    _markUpdated() {\n        this._changedProperties = new Map();\n        this._updateState = this._updateState & ~STATE_UPDATE_REQUESTED;\n    }\n    /**\n     * Returns a Promise that resolves when the element has completed updating.\n     * The Promise value is a boolean that is `true` if the element completed the\n     * update without triggering another update. The Promise result is `false` if\n     * a property was set inside `updated()`. If the Promise is rejected, an\n     * exception was thrown during the update.\n     *\n     * To await additional asynchronous work, override the `_getUpdateComplete`\n     * method. For example, it is sometimes useful to await a rendered element\n     * before fulfilling this Promise. To do this, first await\n     * `super._getUpdateComplete()`, then any subsequent state.\n     *\n     * @returns {Promise} The Promise returns a boolean that indicates if the\n     * update resolved without triggering another update.\n     */\n    get updateComplete() {\n        return this._getUpdateComplete();\n    }\n    /**\n     * Override point for the `updateComplete` promise.\n     *\n     * It is not safe to override the `updateComplete` getter directly due to a\n     * limitation in TypeScript which means it is not possible to call a\n     * superclass getter (e.g. `super.updateComplete.then(...)`) when the target\n     * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).\n     * This method should be overridden instead. For example:\n     *\n     *   class MyElement extends LitElement {\n     *     async _getUpdateComplete() {\n     *       await super._getUpdateComplete();\n     *       await this._myChild.updateComplete;\n     *     }\n     *   }\n     */\n    _getUpdateComplete() {\n        return this._updatePromise;\n    }\n    /**\n     * Controls whether or not `update` should be called when the element requests\n     * an update. By default, this method always returns `true`, but this can be\n     * customized to control when to update.\n     *\n     * @param _changedProperties Map of changed properties with old values\n     */\n    shouldUpdate(_changedProperties) {\n        return true;\n    }\n    /**\n     * Updates the element. This method reflects property values to attributes.\n     * It can be overridden to render and keep updated element DOM.\n     * Setting properties inside this method will *not* trigger\n     * another update.\n     *\n     * @param _changedProperties Map of changed properties with old values\n     */\n    update(_changedProperties) {\n        if (this._reflectingProperties !== undefined &&\n            this._reflectingProperties.size > 0) {\n            // Use forEach so this works even if for/of loops are compiled to for\n            // loops expecting arrays\n            this._reflectingProperties.forEach((v, k) => this._propertyToAttribute(k, this[k], v));\n            this._reflectingProperties = undefined;\n        }\n        this._markUpdated();\n    }\n    /**\n     * Invoked whenever the element is updated. Implement to perform\n     * post-updating tasks via DOM APIs, for example, focusing an element.\n     *\n     * Setting properties inside this method will trigger the element to update\n     * again after this update cycle completes.\n     *\n     * @param _changedProperties Map of changed properties with old values\n     */\n    updated(_changedProperties) {\n    }\n    /**\n     * Invoked when the element is first updated. Implement to perform one time\n     * work on the element after update.\n     *\n     * Setting properties inside this method will trigger the element to update\n     * again after this update cycle completes.\n     *\n     * @param _changedProperties Map of changed properties with old values\n     */\n    firstUpdated(_changedProperties) {\n    }\n}\n_a = finalized;\n/**\n * Marks class as having finished creating properties.\n */\nUpdatingElement[_a] = true;\n//# sourceMappingURL=updating-element.js.map","/**\n * @license\n * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\nconst legacyCustomElement = (tagName, clazz) => {\n    window.customElements.define(tagName, clazz);\n    // Cast as any because TS doesn't recognize the return type as being a\n    // subtype of the decorated class when clazz is typed as\n    // `Constructor<HTMLElement>` for some reason.\n    // `Constructor<HTMLElement>` is helpful to make sure the decorator is\n    // applied to elements however.\n    // tslint:disable-next-line:no-any\n    return clazz;\n};\nconst standardCustomElement = (tagName, descriptor) => {\n    const { kind, elements } = descriptor;\n    return {\n        kind,\n        elements,\n        // This callback is called once the class is otherwise fully defined\n        finisher(clazz) {\n            window.customElements.define(tagName, clazz);\n        }\n    };\n};\n/**\n * Class decorator factory that defines the decorated class as a custom element.\n *\n * ```\n * @customElement('my-element')\n * class MyElement {\n *   render() {\n *     return html``;\n *   }\n * }\n * ```\n * @category Decorator\n * @param tagName The name of the custom element to define.\n */\nexport const customElement = (tagName) => (classOrDescriptor) => (typeof classOrDescriptor === 'function') ?\n    legacyCustomElement(tagName, classOrDescriptor) :\n    standardCustomElement(tagName, classOrDescriptor);\nconst standardProperty = (options, element) => {\n    // When decorating an accessor, pass it through and add property metadata.\n    // Note, the `hasOwnProperty` check in `createProperty` ensures we don't\n    // stomp over the user's accessor.\n    if (element.kind === 'method' && element.descriptor &&\n        !('value' in element.descriptor)) {\n        return Object.assign(Object.assign({}, element), { finisher(clazz) {\n                clazz.createProperty(element.key, options);\n            } });\n    }\n    else {\n        // createProperty() takes care of defining the property, but we still\n        // must return some kind of descriptor, so return a descriptor for an\n        // unused prototype field. The finisher calls createProperty().\n        return {\n            kind: 'field',\n            key: Symbol(),\n            placement: 'own',\n            descriptor: {},\n            // When @babel/plugin-proposal-decorators implements initializers,\n            // do this instead of the initializer below. See:\n            // https://github.com/babel/babel/issues/9260 extras: [\n            //   {\n            //     kind: 'initializer',\n            //     placement: 'own',\n            //     initializer: descriptor.initializer,\n            //   }\n            // ],\n            initializer() {\n                if (typeof element.initializer === 'function') {\n                    this[element.key] = element.initializer.call(this);\n                }\n            },\n            finisher(clazz) {\n                clazz.createProperty(element.key, options);\n            }\n        };\n    }\n};\nconst legacyProperty = (options, proto, name) => {\n    proto.constructor\n        .createProperty(name, options);\n};\n/**\n * A property decorator which creates a LitElement property which reflects a\n * corresponding attribute value. A [[`PropertyDeclaration`]] may optionally be\n * supplied to configure property features.\n *\n * This decorator should only be used for public fields. Private or protected\n * fields should use the [[`internalProperty`]] decorator.\n *\n * @example\n * ```ts\n * class MyElement {\n *   @property({ type: Boolean })\n *   clicked = false;\n * }\n * ```\n * @category Decorator\n * @ExportDecoratedItems\n */\nexport function property(options) {\n    // tslint:disable-next-line:no-any decorator\n    return (protoOrDescriptor, name) => (name !== undefined) ?\n        legacyProperty(options, protoOrDescriptor, name) :\n        standardProperty(options, protoOrDescriptor);\n}\n/**\n * Declares a private or protected property that still triggers updates to the\n * element when it changes.\n *\n * Properties declared this way must not be used from HTML or HTML templating\n * systems, they're solely for properties internal to the element. These\n * properties may be renamed by optimization tools like closure compiler.\n * @category Decorator\n */\nexport function internalProperty(options) {\n    return property({ attribute: false, hasChanged: options === null || options === void 0 ? void 0 : options.hasChanged });\n}\n/**\n * A property decorator that converts a class property into a getter that\n * executes a querySelector on the element's renderRoot.\n *\n * @param selector A DOMString containing one or more selectors to match.\n * @param cache An optional boolean which when true performs the DOM query only\n * once and caches the result.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\n *\n * @example\n *\n * ```ts\n * class MyElement {\n *   @query('#first')\n *   first;\n *\n *   render() {\n *     return html`\n *       <div id=\"first\"></div>\n *       <div id=\"second\"></div>\n *     `;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function query(selector, cache) {\n    return (protoOrDescriptor, \n    // tslint:disable-next-line:no-any decorator\n    name) => {\n        const descriptor = {\n            get() {\n                return this.renderRoot.querySelector(selector);\n            },\n            enumerable: true,\n            configurable: true,\n        };\n        if (cache) {\n            const key = typeof name === 'symbol' ? Symbol() : `__${name}`;\n            descriptor.get = function () {\n                if (this[key] === undefined) {\n                    (this[key] =\n                        this.renderRoot.querySelector(selector));\n                }\n                return this[key];\n            };\n        }\n        return (name !== undefined) ?\n            legacyQuery(descriptor, protoOrDescriptor, name) :\n            standardQuery(descriptor, protoOrDescriptor);\n    };\n}\n// Note, in the future, we may extend this decorator to support the use case\n// where the queried element may need to do work to become ready to interact\n// with (e.g. load some implementation code). If so, we might elect to\n// add a second argument defining a function that can be run to make the\n// queried element loaded/updated/ready.\n/**\n * A property decorator that converts a class property into a getter that\n * returns a promise that resolves to the result of a querySelector on the\n * element's renderRoot done after the element's `updateComplete` promise\n * resolves. When the queried property may change with element state, this\n * decorator can be used instead of requiring users to await the\n * `updateComplete` before accessing the property.\n *\n * @param selector A DOMString containing one or more selectors to match.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\n *\n * @example\n * ```ts\n * class MyElement {\n *   @queryAsync('#first')\n *   first;\n *\n *   render() {\n *     return html`\n *       <div id=\"first\"></div>\n *       <div id=\"second\"></div>\n *     `;\n *   }\n * }\n *\n * // external usage\n * async doSomethingWithFirst() {\n *  (await aMyElement.first).doSomething();\n * }\n * ```\n * @category Decorator\n */\nexport function queryAsync(selector) {\n    return (protoOrDescriptor, \n    // tslint:disable-next-line:no-any decorator\n    name) => {\n        const descriptor = {\n            async get() {\n                await this.updateComplete;\n                return this.renderRoot.querySelector(selector);\n            },\n            enumerable: true,\n            configurable: true,\n        };\n        return (name !== undefined) ?\n            legacyQuery(descriptor, protoOrDescriptor, name) :\n            standardQuery(descriptor, protoOrDescriptor);\n    };\n}\n/**\n * A property decorator that converts a class property into a getter\n * that executes a querySelectorAll on the element's renderRoot.\n *\n * @param selector A DOMString containing one or more selectors to match.\n *\n * See:\n * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll\n *\n * @example\n * ```ts\n * class MyElement {\n *   @queryAll('div')\n *   divs;\n *\n *   render() {\n *     return html`\n *       <div id=\"first\"></div>\n *       <div id=\"second\"></div>\n *     `;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function queryAll(selector) {\n    return (protoOrDescriptor, \n    // tslint:disable-next-line:no-any decorator\n    name) => {\n        const descriptor = {\n            get() {\n                return this.renderRoot.querySelectorAll(selector);\n            },\n            enumerable: true,\n            configurable: true,\n        };\n        return (name !== undefined) ?\n            legacyQuery(descriptor, protoOrDescriptor, name) :\n            standardQuery(descriptor, protoOrDescriptor);\n    };\n}\nconst legacyQuery = (descriptor, proto, name) => {\n    Object.defineProperty(proto, name, descriptor);\n};\nconst standardQuery = (descriptor, element) => ({\n    kind: 'method',\n    placement: 'prototype',\n    key: element.key,\n    descriptor,\n});\nconst standardEventOptions = (options, element) => {\n    return Object.assign(Object.assign({}, element), { finisher(clazz) {\n            Object.assign(clazz.prototype[element.key], options);\n        } });\n};\nconst legacyEventOptions = \n// tslint:disable-next-line:no-any legacy decorator\n(options, proto, name) => {\n    Object.assign(proto[name], options);\n};\n/**\n * Adds event listener options to a method used as an event listener in a\n * lit-html template.\n *\n * @param options An object that specifies event listener options as accepted by\n * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.\n *\n * Current browsers support the `capture`, `passive`, and `once` options. See:\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters\n *\n * @example\n * ```ts\n * class MyElement {\n *   clicked = false;\n *\n *   render() {\n *     return html`\n *       <div @click=${this._onClick}`>\n *         <button></button>\n *       </div>\n *     `;\n *   }\n *\n *   @eventOptions({capture: true})\n *   _onClick(e) {\n *     this.clicked = true;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function eventOptions(options) {\n    // Return value typed as any to prevent TypeScript from complaining that\n    // standard decorator function signature does not match TypeScript decorator\n    // signature\n    // TODO(kschaaf): unclear why it was only failing on this decorator and not\n    // the others\n    return ((protoOrDescriptor, name) => (name !== undefined) ?\n        legacyEventOptions(options, protoOrDescriptor, name) :\n        standardEventOptions(options, protoOrDescriptor));\n}\n// x-browser support for matches\n// tslint:disable-next-line:no-any\nconst ElementProto = Element.prototype;\nconst legacyMatches = ElementProto.msMatchesSelector || ElementProto.webkitMatchesSelector;\n/**\n * A property decorator that converts a class property into a getter that\n * returns the `assignedNodes` of the given named `slot`. Note, the type of\n * this property should be annotated as `NodeListOf<HTMLElement>`.\n *\n * @param slotName A string name of the slot.\n * @param flatten A boolean which when true flattens the assigned nodes,\n * meaning any assigned nodes that are slot elements are replaced with their\n * assigned nodes.\n * @param selector A string which filters the results to elements that match\n * the given css selector.\n *\n * * @example\n * ```ts\n * class MyElement {\n *   @queryAssignedNodes('list', true, '.item')\n *   listItems;\n *\n *   render() {\n *     return html`\n *       <slot name=\"list\"></slot>\n *     `;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function queryAssignedNodes(slotName = '', flatten = false, selector = '') {\n    return (protoOrDescriptor, \n    // tslint:disable-next-line:no-any decorator\n    name) => {\n        const descriptor = {\n            get() {\n                const slotSelector = `slot${slotName ? `[name=${slotName}]` : ':not([name])'}`;\n                const slot = this.renderRoot.querySelector(slotSelector);\n                let nodes = slot && slot.assignedNodes({ flatten });\n                if (nodes && selector) {\n                    nodes = nodes.filter((node) => node.nodeType === Node.ELEMENT_NODE &&\n                        node.matches ?\n                        node.matches(selector) :\n                        legacyMatches.call(node, selector));\n                }\n                return nodes;\n            },\n            enumerable: true,\n            configurable: true,\n        };\n        return (name !== undefined) ?\n            legacyQuery(descriptor, protoOrDescriptor, name) :\n            standardQuery(descriptor, protoOrDescriptor);\n    };\n}\n//# sourceMappingURL=decorators.js.map","/**\n@license\nCopyright (c) 2019 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at\nhttp://polymer.github.io/LICENSE.txt The complete set of authors may be found at\nhttp://polymer.github.io/AUTHORS.txt The complete set of contributors may be\nfound at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as\npart of the polymer project is also subject to an additional IP rights grant\nfound at http://polymer.github.io/PATENTS.txt\n*/\n/**\n * Whether the current browser supports `adoptedStyleSheets`.\n */\nexport const supportsAdoptingStyleSheets = (window.ShadowRoot) &&\n    (window.ShadyCSS === undefined || window.ShadyCSS.nativeShadow) &&\n    ('adoptedStyleSheets' in Document.prototype) &&\n    ('replace' in CSSStyleSheet.prototype);\nconst constructionToken = Symbol();\nexport class CSSResult {\n    constructor(cssText, safeToken) {\n        if (safeToken !== constructionToken) {\n            throw new Error('CSSResult is not constructable. Use `unsafeCSS` or `css` instead.');\n        }\n        this.cssText = cssText;\n    }\n    // Note, this is a getter so that it's lazy. In practice, this means\n    // stylesheets are not created until the first element instance is made.\n    get styleSheet() {\n        if (this._styleSheet === undefined) {\n            // Note, if `supportsAdoptingStyleSheets` is true then we assume\n            // CSSStyleSheet is constructable.\n            if (supportsAdoptingStyleSheets) {\n                this._styleSheet = new CSSStyleSheet();\n                this._styleSheet.replaceSync(this.cssText);\n            }\n            else {\n                this._styleSheet = null;\n            }\n        }\n        return this._styleSheet;\n    }\n    toString() {\n        return this.cssText;\n    }\n}\n/**\n * Wrap a value for interpolation in a [[`css`]] tagged template literal.\n *\n * This is unsafe because untrusted CSS text can be used to phone home\n * or exfiltrate data to an attacker controlled site. Take care to only use\n * this with trusted input.\n */\nexport const unsafeCSS = (value) => {\n    return new CSSResult(String(value), constructionToken);\n};\nconst textFromCSSResult = (value) => {\n    if (value instanceof CSSResult) {\n        return value.cssText;\n    }\n    else if (typeof value === 'number') {\n        return value;\n    }\n    else {\n        throw new Error(`Value passed to 'css' function must be a 'css' function result: ${value}. Use 'unsafeCSS' to pass non-literal values, but\n            take care to ensure page security.`);\n    }\n};\n/**\n * Template tag which which can be used with LitElement's [[LitElement.styles |\n * `styles`]] property to set element styles. For security reasons, only literal\n * string values may be used. To incorporate non-literal values [[`unsafeCSS`]]\n * may be used inside a template string part.\n */\nexport const css = (strings, ...values) => {\n    const cssText = values.reduce((acc, v, idx) => acc + textFromCSSResult(v) + strings[idx + 1], strings[0]);\n    return new CSSResult(cssText, constructionToken);\n};\n//# sourceMappingURL=css-tag.js.map","/**\n * @license\n * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\n/**\n * The main LitElement module, which defines the [[`LitElement`]] base class and\n * related APIs.\n *\n *  LitElement components can define a template and a set of observed\n * properties. Changing an observed property triggers a re-render of the\n * element.\n *\n *  Import [[`LitElement`]] and [[`html`]] from this module to create a\n * component:\n *\n *  ```js\n * import {LitElement, html} from 'lit-element';\n *\n * class MyElement extends LitElement {\n *\n *   // Declare observed properties\n *   static get properties() {\n *     return {\n *       adjective: {}\n *     }\n *   }\n *\n *   constructor() {\n *     this.adjective = 'awesome';\n *   }\n *\n *   // Define the element's template\n *   render() {\n *     return html`<p>your ${adjective} template here</p>`;\n *   }\n * }\n *\n * customElements.define('my-element', MyElement);\n * ```\n *\n * `LitElement` extends [[`UpdatingElement`]] and adds lit-html templating.\n * The `UpdatingElement` class is provided for users that want to build\n * their own custom element base classes that don't use lit-html.\n *\n * @packageDocumentation\n */\nimport { render } from 'lit-html/lib/shady-render.js';\nimport { UpdatingElement } from './lib/updating-element.js';\nexport * from './lib/updating-element.js';\nexport * from './lib/decorators.js';\nexport { html, svg, TemplateResult, SVGTemplateResult } from 'lit-html/lit-html.js';\nimport { supportsAdoptingStyleSheets, unsafeCSS } from './lib/css-tag.js';\nexport * from './lib/css-tag.js';\n// IMPORTANT: do not change the property name or the assignment expression.\n// This line will be used in regexes to search for LitElement usage.\n// TODO(justinfagnani): inject version number at build time\n(window['litElementVersions'] || (window['litElementVersions'] = []))\n    .push('2.4.0');\n/**\n * Sentinal value used to avoid calling lit-html's render function when\n * subclasses do not implement `render`\n */\nconst renderNotImplemented = {};\n/**\n * Base element class that manages element properties and attributes, and\n * renders a lit-html template.\n *\n * To define a component, subclass `LitElement` and implement a\n * `render` method to provide the component's template. Define properties\n * using the [[`properties`]] property or the [[`property`]] decorator.\n */\nexport class LitElement extends UpdatingElement {\n    /**\n     * Return the array of styles to apply to the element.\n     * Override this method to integrate into a style management system.\n     *\n     * @nocollapse\n     */\n    static getStyles() {\n        return this.styles;\n    }\n    /** @nocollapse */\n    static _getUniqueStyles() {\n        // Only gather styles once per class\n        if (this.hasOwnProperty(JSCompiler_renameProperty('_styles', this))) {\n            return;\n        }\n        // Take care not to call `this.getStyles()` multiple times since this\n        // generates new CSSResults each time.\n        // TODO(sorvell): Since we do not cache CSSResults by input, any\n        // shared styles will generate new stylesheet objects, which is wasteful.\n        // This should be addressed when a browser ships constructable\n        // stylesheets.\n        const userStyles = this.getStyles();\n        if (Array.isArray(userStyles)) {\n            // De-duplicate styles preserving the _last_ instance in the set.\n            // This is a performance optimization to avoid duplicated styles that can\n            // occur especially when composing via subclassing.\n            // The last item is kept to try to preserve the cascade order with the\n            // assumption that it's most important that last added styles override\n            // previous styles.\n            const addStyles = (styles, set) => styles.reduceRight((set, s) => \n            // Note: On IE set.add() does not return the set\n            Array.isArray(s) ? addStyles(s, set) : (set.add(s), set), set);\n            // Array.from does not work on Set in IE, otherwise return\n            // Array.from(addStyles(userStyles, new Set<CSSResult>())).reverse()\n            const set = addStyles(userStyles, new Set());\n            const styles = [];\n            set.forEach((v) => styles.unshift(v));\n            this._styles = styles;\n        }\n        else {\n            this._styles = userStyles === undefined ? [] : [userStyles];\n        }\n        // Ensure that there are no invalid CSSStyleSheet instances here. They are\n        // invalid in two conditions.\n        // (1) the sheet is non-constructible (`sheet` of a HTMLStyleElement), but\n        //     this is impossible to check except via .replaceSync or use\n        // (2) the ShadyCSS polyfill is enabled (:. supportsAdoptingStyleSheets is\n        //     false)\n        this._styles = this._styles.map((s) => {\n            if (s instanceof CSSStyleSheet && !supportsAdoptingStyleSheets) {\n                // Flatten the cssText from the passed constructible stylesheet (or\n                // undetectable non-constructible stylesheet). The user might have\n                // expected to update their stylesheets over time, but the alternative\n                // is a crash.\n                const cssText = Array.prototype.slice.call(s.cssRules)\n                    .reduce((css, rule) => css + rule.cssText, '');\n                return unsafeCSS(cssText);\n            }\n            return s;\n        });\n    }\n    /**\n     * Performs element initialization. By default this calls\n     * [[`createRenderRoot`]] to create the element [[`renderRoot`]] node and\n     * captures any pre-set values for registered properties.\n     */\n    initialize() {\n        super.initialize();\n        this.constructor._getUniqueStyles();\n        this.renderRoot = this.createRenderRoot();\n        // Note, if renderRoot is not a shadowRoot, styles would/could apply to the\n        // element's getRootNode(). While this could be done, we're choosing not to\n        // support this now since it would require different logic around de-duping.\n        if (window.ShadowRoot && this.renderRoot instanceof window.ShadowRoot) {\n            this.adoptStyles();\n        }\n    }\n    /**\n     * Returns the node into which the element should render and by default\n     * creates and returns an open shadowRoot. Implement to customize where the\n     * element's DOM is rendered. For example, to render into the element's\n     * childNodes, return `this`.\n     * @returns {Element|DocumentFragment} Returns a node into which to render.\n     */\n    createRenderRoot() {\n        return this.attachShadow({ mode: 'open' });\n    }\n    /**\n     * Applies styling to the element shadowRoot using the [[`styles`]]\n     * property. Styling will apply using `shadowRoot.adoptedStyleSheets` where\n     * available and will fallback otherwise. When Shadow DOM is polyfilled,\n     * ShadyCSS scopes styles and adds them to the document. When Shadow DOM\n     * is available but `adoptedStyleSheets` is not, styles are appended to the\n     * end of the `shadowRoot` to [mimic spec\n     * behavior](https://wicg.github.io/construct-stylesheets/#using-constructed-stylesheets).\n     */\n    adoptStyles() {\n        const styles = this.constructor._styles;\n        if (styles.length === 0) {\n            return;\n        }\n        // There are three separate cases here based on Shadow DOM support.\n        // (1) shadowRoot polyfilled: use ShadyCSS\n        // (2) shadowRoot.adoptedStyleSheets available: use it\n        // (3) shadowRoot.adoptedStyleSheets polyfilled: append styles after\n        // rendering\n        if (window.ShadyCSS !== undefined && !window.ShadyCSS.nativeShadow) {\n            window.ShadyCSS.ScopingShim.prepareAdoptedCssText(styles.map((s) => s.cssText), this.localName);\n        }\n        else if (supportsAdoptingStyleSheets) {\n            this.renderRoot.adoptedStyleSheets =\n                styles.map((s) => s instanceof CSSStyleSheet ? s : s.styleSheet);\n        }\n        else {\n            // This must be done after rendering so the actual style insertion is done\n            // in `update`.\n            this._needsShimAdoptedStyleSheets = true;\n        }\n    }\n    connectedCallback() {\n        super.connectedCallback();\n        // Note, first update/render handles styleElement so we only call this if\n        // connected after first update.\n        if (this.hasUpdated && window.ShadyCSS !== undefined) {\n            window.ShadyCSS.styleElement(this);\n        }\n    }\n    /**\n     * Updates the element. This method reflects property values to attributes\n     * and calls `render` to render DOM via lit-html. Setting properties inside\n     * this method will *not* trigger another update.\n     * @param _changedProperties Map of changed properties with old values\n     */\n    update(changedProperties) {\n        // Setting properties in `render` should not trigger an update. Since\n        // updates are allowed after super.update, it's important to call `render`\n        // before that.\n        const templateResult = this.render();\n        super.update(changedProperties);\n        // If render is not implemented by the component, don't call lit-html render\n        if (templateResult !== renderNotImplemented) {\n            this.constructor\n                .render(templateResult, this.renderRoot, { scopeName: this.localName, eventContext: this });\n        }\n        // When native Shadow DOM is used but adoptedStyles are not supported,\n        // insert styling after rendering to ensure adoptedStyles have highest\n        // priority.\n        if (this._needsShimAdoptedStyleSheets) {\n            this._needsShimAdoptedStyleSheets = false;\n            this.constructor._styles.forEach((s) => {\n                const style = document.createElement('style');\n                style.textContent = s.cssText;\n                this.renderRoot.appendChild(style);\n            });\n        }\n    }\n    /**\n     * Invoked on each update to perform rendering tasks. This method may return\n     * any value renderable by lit-html's `NodePart` - typically a\n     * `TemplateResult`. Setting properties inside this method will *not* trigger\n     * the element to update.\n     */\n    render() {\n        return renderNotImplemented;\n    }\n}\n/**\n * Ensure this class is marked as `finalized` as an optimization ensuring\n * it will not needlessly try to `finalize`.\n *\n * Note this property name is a string to prevent breaking Closure JS Compiler\n * optimizations. See updating-element.ts for more information.\n */\nLitElement['finalized'] = true;\n/**\n * Reference to the underlying library method used to render the element's\n * DOM. By default, points to the `render` method from lit-html's shady-render\n * module.\n *\n * **Most users will never need to touch this property.**\n *\n * This  property should not be confused with the `render` instance method,\n * which should be overridden to define a template for the element.\n *\n * Advanced users creating a new base class based on LitElement can override\n * this property to point to a custom render method with a signature that\n * matches [shady-render's `render`\n * method](https://lit-html.polymer-project.org/api/modules/shady_render.html#render).\n *\n * @nocollapse\n */\nLitElement.render = render;\n//# sourceMappingURL=lit-element.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 { __assign, __extends } from \"tslib\";\nimport { AnimationFrame } from '@material/animation/animationframe';\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, numbers, strings } from './constants';\nvar AnimationKeys;\n(function (AnimationKeys) {\n    AnimationKeys[\"POLL_SCROLL_POS\"] = \"poll_scroll_position\";\n    AnimationKeys[\"POLL_LAYOUT_CHANGE\"] = \"poll_layout_change\";\n})(AnimationKeys || (AnimationKeys = {}));\nvar MDCDialogFoundation = /** @class */ (function (_super) {\n    __extends(MDCDialogFoundation, _super);\n    function MDCDialogFoundation(adapter) {\n        var _this = _super.call(this, __assign(__assign({}, MDCDialogFoundation.defaultAdapter), adapter)) || this;\n        _this.dialogOpen = false;\n        _this.isFullscreen = false;\n        _this.animationFrame = 0;\n        _this.animationTimer = 0;\n        _this.escapeKeyAction = strings.CLOSE_ACTION;\n        _this.scrimClickAction = strings.CLOSE_ACTION;\n        _this.autoStackButtons = true;\n        _this.areButtonsStacked = false;\n        _this.suppressDefaultPressSelector = strings.SUPPRESS_DEFAULT_PRESS_SELECTOR;\n        _this.animFrame = new AnimationFrame();\n        _this.contentScrollHandler = function () {\n            _this.handleScrollEvent();\n        };\n        _this.windowResizeHandler = function () {\n            _this.layout();\n        };\n        _this.windowOrientationChangeHandler = function () {\n            _this.layout();\n        };\n        return _this;\n    }\n    Object.defineProperty(MDCDialogFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCDialogFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCDialogFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCDialogFoundation, \"defaultAdapter\", {\n        get: function () {\n            return {\n                addBodyClass: function () { return undefined; },\n                addClass: function () { return undefined; },\n                areButtonsStacked: function () { return false; },\n                clickDefaultButton: function () { return undefined; },\n                eventTargetMatches: function () { return false; },\n                getActionFromEvent: function () { return ''; },\n                getInitialFocusEl: function () { return null; },\n                hasClass: function () { return false; },\n                isContentScrollable: function () { return false; },\n                notifyClosed: function () { return undefined; },\n                notifyClosing: function () { return undefined; },\n                notifyOpened: function () { return undefined; },\n                notifyOpening: function () { return undefined; },\n                releaseFocus: function () { return undefined; },\n                removeBodyClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                reverseButtons: function () { return undefined; },\n                trapFocus: function () { return undefined; },\n                registerContentEventHandler: function () { return undefined; },\n                deregisterContentEventHandler: function () { return undefined; },\n                isScrollableContentAtTop: function () { return false; },\n                isScrollableContentAtBottom: function () { return false; },\n                registerWindowEventHandler: function () { return undefined; },\n                deregisterWindowEventHandler: function () { return undefined; },\n            };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    MDCDialogFoundation.prototype.init = function () {\n        if (this.adapter.hasClass(cssClasses.STACKED)) {\n            this.setAutoStackButtons(false);\n        }\n        this.isFullscreen = this.adapter.hasClass(cssClasses.FULLSCREEN);\n    };\n    MDCDialogFoundation.prototype.destroy = function () {\n        if (this.animationTimer) {\n            clearTimeout(this.animationTimer);\n            this.handleAnimationTimerEnd();\n        }\n        if (this.isFullscreen) {\n            this.adapter.deregisterContentEventHandler('scroll', this.contentScrollHandler);\n        }\n        this.animFrame.cancelAll();\n        this.adapter.deregisterWindowEventHandler('resize', this.windowResizeHandler);\n        this.adapter.deregisterWindowEventHandler('orientationchange', this.windowOrientationChangeHandler);\n    };\n    MDCDialogFoundation.prototype.open = function (dialogOptions) {\n        var _this = this;\n        this.dialogOpen = true;\n        this.adapter.notifyOpening();\n        this.adapter.addClass(cssClasses.OPENING);\n        if (this.isFullscreen) {\n            // A scroll event listener is registered even if the dialog is not\n            // scrollable on open, since the window resize event, or orientation\n            // change may make the dialog scrollable after it is opened.\n            this.adapter.registerContentEventHandler('scroll', this.contentScrollHandler);\n        }\n        if (dialogOptions && dialogOptions.isAboveFullscreenDialog) {\n            this.adapter.addClass(cssClasses.SCRIM_HIDDEN);\n        }\n        this.adapter.registerWindowEventHandler('resize', this.windowResizeHandler);\n        this.adapter.registerWindowEventHandler('orientationchange', this.windowOrientationChangeHandler);\n        // Wait a frame once display is no longer \"none\", to establish basis for\n        // animation\n        this.runNextAnimationFrame(function () {\n            _this.adapter.addClass(cssClasses.OPEN);\n            _this.adapter.addBodyClass(cssClasses.SCROLL_LOCK);\n            _this.layout();\n            _this.animationTimer = setTimeout(function () {\n                _this.handleAnimationTimerEnd();\n                _this.adapter.trapFocus(_this.adapter.getInitialFocusEl());\n                _this.adapter.notifyOpened();\n            }, numbers.DIALOG_ANIMATION_OPEN_TIME_MS);\n        });\n    };\n    MDCDialogFoundation.prototype.close = function (action) {\n        var _this = this;\n        if (action === void 0) { action = ''; }\n        if (!this.dialogOpen) {\n            // Avoid redundant close calls (and events), e.g. from keydown on elements\n            // that inherently emit click\n            return;\n        }\n        this.dialogOpen = false;\n        this.adapter.notifyClosing(action);\n        this.adapter.addClass(cssClasses.CLOSING);\n        this.adapter.removeClass(cssClasses.OPEN);\n        this.adapter.removeBodyClass(cssClasses.SCROLL_LOCK);\n        if (this.isFullscreen) {\n            this.adapter.deregisterContentEventHandler('scroll', this.contentScrollHandler);\n        }\n        this.adapter.deregisterWindowEventHandler('resize', this.windowResizeHandler);\n        this.adapter.deregisterWindowEventHandler('orientationchange', this.windowOrientationChangeHandler);\n        cancelAnimationFrame(this.animationFrame);\n        this.animationFrame = 0;\n        clearTimeout(this.animationTimer);\n        this.animationTimer = setTimeout(function () {\n            _this.adapter.releaseFocus();\n            _this.handleAnimationTimerEnd();\n            _this.adapter.notifyClosed(action);\n        }, numbers.DIALOG_ANIMATION_CLOSE_TIME_MS);\n    };\n    /**\n     * Used only in instances of showing a secondary dialog over a full-screen\n     * dialog. Shows the \"surface scrim\" displayed over the full-screen dialog.\n     */\n    MDCDialogFoundation.prototype.showSurfaceScrim = function () {\n        var _this = this;\n        this.adapter.addClass(cssClasses.SURFACE_SCRIM_SHOWING);\n        this.runNextAnimationFrame(function () {\n            _this.adapter.addClass(cssClasses.SURFACE_SCRIM_SHOWN);\n        });\n    };\n    /**\n     * Used only in instances of showing a secondary dialog over a full-screen\n     * dialog. Hides the \"surface scrim\" displayed over the full-screen dialog.\n     */\n    MDCDialogFoundation.prototype.hideSurfaceScrim = function () {\n        this.adapter.removeClass(cssClasses.SURFACE_SCRIM_SHOWN);\n        this.adapter.addClass(cssClasses.SURFACE_SCRIM_HIDING);\n    };\n    /**\n     * Handles `transitionend` event triggered when surface scrim animation is\n     * finished.\n     */\n    MDCDialogFoundation.prototype.handleSurfaceScrimTransitionEnd = function () {\n        this.adapter.removeClass(cssClasses.SURFACE_SCRIM_HIDING);\n        this.adapter.removeClass(cssClasses.SURFACE_SCRIM_SHOWING);\n    };\n    MDCDialogFoundation.prototype.isOpen = function () {\n        return this.dialogOpen;\n    };\n    MDCDialogFoundation.prototype.getEscapeKeyAction = function () {\n        return this.escapeKeyAction;\n    };\n    MDCDialogFoundation.prototype.setEscapeKeyAction = function (action) {\n        this.escapeKeyAction = action;\n    };\n    MDCDialogFoundation.prototype.getScrimClickAction = function () {\n        return this.scrimClickAction;\n    };\n    MDCDialogFoundation.prototype.setScrimClickAction = function (action) {\n        this.scrimClickAction = action;\n    };\n    MDCDialogFoundation.prototype.getAutoStackButtons = function () {\n        return this.autoStackButtons;\n    };\n    MDCDialogFoundation.prototype.setAutoStackButtons = function (autoStack) {\n        this.autoStackButtons = autoStack;\n    };\n    MDCDialogFoundation.prototype.getSuppressDefaultPressSelector = function () {\n        return this.suppressDefaultPressSelector;\n    };\n    MDCDialogFoundation.prototype.setSuppressDefaultPressSelector = function (selector) {\n        this.suppressDefaultPressSelector = selector;\n    };\n    MDCDialogFoundation.prototype.layout = function () {\n        var _this = this;\n        this.animFrame.request(AnimationKeys.POLL_LAYOUT_CHANGE, function () {\n            _this.layoutInternal();\n        });\n    };\n    /** Handles click on the dialog root element. */\n    MDCDialogFoundation.prototype.handleClick = function (evt) {\n        var isScrim = this.adapter.eventTargetMatches(evt.target, strings.SCRIM_SELECTOR);\n        // Check for scrim click first since it doesn't require querying ancestors.\n        if (isScrim && this.scrimClickAction !== '') {\n            this.close(this.scrimClickAction);\n        }\n        else {\n            var action = this.adapter.getActionFromEvent(evt);\n            if (action) {\n                this.close(action);\n            }\n        }\n    };\n    /** Handles keydown on the dialog root element. */\n    MDCDialogFoundation.prototype.handleKeydown = function (evt) {\n        var isEnter = evt.key === 'Enter' || evt.keyCode === 13;\n        if (!isEnter) {\n            return;\n        }\n        var action = this.adapter.getActionFromEvent(evt);\n        if (action) {\n            // Action button callback is handled in `handleClick`,\n            // since space/enter keydowns on buttons trigger click events.\n            return;\n        }\n        // `composedPath` is used here, when available, to account for use cases\n        // where a target meant to suppress the default press behaviour\n        // may exist in a shadow root.\n        // For example, a textarea inside a web component:\n        // <mwc-dialog>\n        //   <horizontal-layout>\n        //     #shadow-root (open)\n        //       <mwc-textarea>\n        //         #shadow-root (open)\n        //           <textarea></textarea>\n        //       </mwc-textarea>\n        //   </horizontal-layout>\n        // </mwc-dialog>\n        var target = evt.composedPath ? evt.composedPath()[0] : evt.target;\n        var isDefault = this.suppressDefaultPressSelector ?\n            !this.adapter.eventTargetMatches(target, this.suppressDefaultPressSelector) :\n            true;\n        if (isEnter && isDefault) {\n            this.adapter.clickDefaultButton();\n        }\n    };\n    /** Handles keydown on the document. */\n    MDCDialogFoundation.prototype.handleDocumentKeydown = function (evt) {\n        var isEscape = evt.key === 'Escape' || evt.keyCode === 27;\n        if (isEscape && this.escapeKeyAction !== '') {\n            this.close(this.escapeKeyAction);\n        }\n    };\n    /**\n     * Handles scroll event on the dialog's content element -- showing a scroll\n     * divider on the header or footer based on the scroll position. This handler\n     * should only be registered on full-screen dialogs with scrollable content.\n     */\n    MDCDialogFoundation.prototype.handleScrollEvent = function () {\n        var _this = this;\n        // Since scroll events can fire at a high rate, we throttle these events by\n        // using requestAnimationFrame.\n        this.animFrame.request(AnimationKeys.POLL_SCROLL_POS, function () {\n            _this.toggleScrollDividerHeader();\n            _this.toggleScrollDividerFooter();\n        });\n    };\n    MDCDialogFoundation.prototype.layoutInternal = function () {\n        if (this.autoStackButtons) {\n            this.detectStackedButtons();\n        }\n        this.toggleScrollableClasses();\n    };\n    MDCDialogFoundation.prototype.handleAnimationTimerEnd = function () {\n        this.animationTimer = 0;\n        this.adapter.removeClass(cssClasses.OPENING);\n        this.adapter.removeClass(cssClasses.CLOSING);\n    };\n    /**\n     * Runs the given logic on the next animation frame, using setTimeout to\n     * factor in Firefox reflow behavior.\n     */\n    MDCDialogFoundation.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    MDCDialogFoundation.prototype.detectStackedButtons = function () {\n        // Remove the class first to let us measure the buttons' natural positions.\n        this.adapter.removeClass(cssClasses.STACKED);\n        var areButtonsStacked = this.adapter.areButtonsStacked();\n        if (areButtonsStacked) {\n            this.adapter.addClass(cssClasses.STACKED);\n        }\n        if (areButtonsStacked !== this.areButtonsStacked) {\n            this.adapter.reverseButtons();\n            this.areButtonsStacked = areButtonsStacked;\n        }\n    };\n    MDCDialogFoundation.prototype.toggleScrollableClasses = function () {\n        // Remove the class first to let us measure the natural height of the\n        // content.\n        this.adapter.removeClass(cssClasses.SCROLLABLE);\n        if (this.adapter.isContentScrollable()) {\n            this.adapter.addClass(cssClasses.SCROLLABLE);\n            if (this.isFullscreen) {\n                // If dialog is full-screen and scrollable, check if a scroll divider\n                // should be shown.\n                this.toggleScrollDividerHeader();\n                this.toggleScrollDividerFooter();\n            }\n        }\n    };\n    MDCDialogFoundation.prototype.toggleScrollDividerHeader = function () {\n        if (!this.adapter.isScrollableContentAtTop()) {\n            this.adapter.addClass(cssClasses.SCROLL_DIVIDER_HEADER);\n        }\n        else if (this.adapter.hasClass(cssClasses.SCROLL_DIVIDER_HEADER)) {\n            this.adapter.removeClass(cssClasses.SCROLL_DIVIDER_HEADER);\n        }\n    };\n    MDCDialogFoundation.prototype.toggleScrollDividerFooter = function () {\n        if (!this.adapter.isScrollableContentAtBottom()) {\n            this.adapter.addClass(cssClasses.SCROLL_DIVIDER_FOOTER);\n        }\n        else if (this.adapter.hasClass(cssClasses.SCROLL_DIVIDER_FOOTER)) {\n            this.adapter.removeClass(cssClasses.SCROLL_DIVIDER_FOOTER);\n        }\n    };\n    return MDCDialogFoundation;\n}(MDCFoundation));\nexport { MDCDialogFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDialogFoundation;\n//# sourceMappingURL=foundation.js.map","/**\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 */\nexport var cssClasses = {\n    CLOSING: 'mdc-dialog--closing',\n    OPEN: 'mdc-dialog--open',\n    OPENING: 'mdc-dialog--opening',\n    SCROLLABLE: 'mdc-dialog--scrollable',\n    SCROLL_LOCK: 'mdc-dialog-scroll-lock',\n    STACKED: 'mdc-dialog--stacked',\n    FULLSCREEN: 'mdc-dialog--fullscreen',\n    // Class for showing a scroll divider on full-screen dialog header element.\n    // Should only be displayed on scrollable content, when the dialog content is\n    // scrolled \"underneath\" the header.\n    SCROLL_DIVIDER_HEADER: 'mdc-dialog-scroll-divider-header',\n    // Class for showing a scroll divider on a full-screen dialog footer element.\n    // Should only be displayed on scrolalble content, when the dialog content is\n    // obscured \"underneath\" the footer.\n    SCROLL_DIVIDER_FOOTER: 'mdc-dialog-scroll-divider-footer',\n    // The \"surface scrim\" is a scrim covering only the surface of a dialog. This\n    // is used in situations where a confirmation dialog is shown over an already\n    // opened full-screen dialog. On larger screen-sizes, the full-screen dialog\n    // is sized as a modal and so in these situations we display a \"surface scrim\"\n    // to prevent a \"double scrim\" (where the scrim from the secondary\n    // confirmation dialog would overlap with the scrim from the full-screen\n    // dialog).\n    SURFACE_SCRIM_SHOWN: 'mdc-dialog__surface-scrim--shown',\n    // \"Showing\" animating class for the surface-scrim.\n    SURFACE_SCRIM_SHOWING: 'mdc-dialog__surface-scrim--showing',\n    // \"Hiding\" animating class for the surface-scrim.\n    SURFACE_SCRIM_HIDING: 'mdc-dialog__surface-scrim--hiding',\n    // Class to hide a dialog's scrim (used in conjunction with a surface-scrim).\n    // Note that we only hide the original scrim rather than removing it entirely\n    // to prevent interactions with the content behind this scrim, and to capture\n    // scrim clicks.\n    SCRIM_HIDDEN: 'mdc-dialog__scrim--hidden',\n};\nexport var strings = {\n    ACTION_ATTRIBUTE: 'data-mdc-dialog-action',\n    BUTTON_DEFAULT_ATTRIBUTE: 'data-mdc-dialog-button-default',\n    BUTTON_SELECTOR: '.mdc-dialog__button',\n    CLOSED_EVENT: 'MDCDialog:closed',\n    CLOSE_ACTION: 'close',\n    CLOSING_EVENT: 'MDCDialog:closing',\n    CONTAINER_SELECTOR: '.mdc-dialog__container',\n    CONTENT_SELECTOR: '.mdc-dialog__content',\n    DESTROY_ACTION: 'destroy',\n    INITIAL_FOCUS_ATTRIBUTE: 'data-mdc-dialog-initial-focus',\n    OPENED_EVENT: 'MDCDialog:opened',\n    OPENING_EVENT: 'MDCDialog:opening',\n    SCRIM_SELECTOR: '.mdc-dialog__scrim',\n    SUPPRESS_DEFAULT_PRESS_SELECTOR: [\n        'textarea',\n        '.mdc-menu .mdc-list-item',\n        '.mdc-menu .mdc-deprecated-list-item',\n    ].join(', '),\n    SURFACE_SELECTOR: '.mdc-dialog__surface',\n};\nexport var numbers = {\n    DIALOG_ANIMATION_CLOSE_TIME_MS: 75,\n    DIALOG_ANIMATION_OPEN_TIME_MS: 150,\n};\n//# sourceMappingURL=constants.js.map","/**\n * @license\n * Copyright 2020 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 */\n/**\n * AnimationFrame provides a user-friendly abstraction around requesting\n * and canceling animation frames.\n */\nvar AnimationFrame = /** @class */ (function () {\n    function AnimationFrame() {\n        this.rafIDs = new Map();\n    }\n    /**\n     * Requests an animation frame. Cancels any existing frame with the same key.\n     * @param {string} key The key for this callback.\n     * @param {FrameRequestCallback} callback The callback to be executed.\n     */\n    AnimationFrame.prototype.request = function (key, callback) {\n        var _this = this;\n        this.cancel(key);\n        var frameID = requestAnimationFrame(function (frame) {\n            _this.rafIDs.delete(key);\n            // Callback must come *after* the key is deleted so that nested calls to\n            // request with the same key are not deleted.\n            callback(frame);\n        });\n        this.rafIDs.set(key, frameID);\n    };\n    /**\n     * Cancels a queued callback with the given key.\n     * @param {string} key The key for this callback.\n     */\n    AnimationFrame.prototype.cancel = function (key) {\n        var rafID = this.rafIDs.get(key);\n        if (rafID) {\n            cancelAnimationFrame(rafID);\n            this.rafIDs.delete(key);\n        }\n    };\n    /**\n     * Cancels all queued callback.\n     */\n    AnimationFrame.prototype.cancelAll = function () {\n        var _this = this;\n        // Need to use forEach because it's the only iteration method supported\n        // by IE11. Suppress the underscore because we don't need it.\n        // tslint:disable-next-line:enforce-name-casing\n        this.rafIDs.forEach(function (_, key) {\n            _this.cancel(key);\n        });\n    };\n    /**\n     * Returns the queue of unexecuted callback keys.\n     */\n    AnimationFrame.prototype.getQueue = function () {\n        var queue = [];\n        // Need to use forEach because it's the only iteration method supported\n        // by IE11. Suppress the underscore because we don't need it.\n        // tslint:disable-next-line:enforce-name-casing\n        this.rafIDs.forEach(function (_, key) {\n            queue.push(key);\n        });\n        return queue;\n    };\n    return AnimationFrame;\n}());\nexport { AnimationFrame };\n//# sourceMappingURL=animationframe.js.map","/**\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 */\nvar MDCFoundation = /** @class */ (function () {\n    function MDCFoundation(adapter) {\n        if (adapter === void 0) { adapter = {}; }\n        this.adapter = adapter;\n    }\n    Object.defineProperty(MDCFoundation, \"cssClasses\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports every\n            // CSS class the foundation class needs as a property. e.g. {ACTIVE: 'mdc-component--active'}\n            return {};\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"strings\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports all\n            // semantic strings as constants. e.g. {ARIA_ROLE: 'tablist'}\n            return {};\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"numbers\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports all\n            // of its semantic numbers as constants. e.g. {ANIMATION_DELAY_MS: 350}\n            return {};\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"defaultAdapter\", {\n        get: function () {\n            // Classes extending MDCFoundation may choose to implement this getter in order to provide a convenient\n            // way of viewing the necessary methods of an adapter. In the future, this could also be used for adapter\n            // validation.\n            return {};\n        },\n        enumerable: false,\n        configurable: true\n    });\n    MDCFoundation.prototype.init = function () {\n        // Subclasses should override this method to perform initialization routines (registering events, etc.)\n    };\n    MDCFoundation.prototype.destroy = function () {\n        // Subclasses should override this method to perform de-initialization routines (de-registering events, etc.)\n    };\n    return MDCFoundation;\n}());\nexport { MDCFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2019 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 */\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj) {\n    if (globalObj === void 0) { globalObj = window; }\n    return supportsPassiveOption(globalObj) ?\n        { passive: true } :\n        false;\n}\nfunction supportsPassiveOption(globalObj) {\n    if (globalObj === void 0) { globalObj = window; }\n    // See\n    // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n    var passiveSupported = false;\n    try {\n        var options = {\n            // This function will be called when the browser\n            // attempts to access the passive property.\n            get passive() {\n                passiveSupported = true;\n                return false;\n            }\n        };\n        var handler = function () { };\n        globalObj.document.addEventListener('test', handler, options);\n        globalObj.document.removeEventListener('test', handler, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n    return passiveSupported;\n}\n//# sourceMappingURL=events.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 */\n/**\n * @fileoverview A \"ponyfill\" is a polyfill that doesn't modify the global prototype chain.\n * This makes ponyfills safer than traditional polyfills, especially for libraries like MDC.\n */\nexport function closest(element, selector) {\n    if (element.closest) {\n        return element.closest(selector);\n    }\n    var el = element;\n    while (el) {\n        if (matches(el, selector)) {\n            return el;\n        }\n        el = el.parentElement;\n    }\n    return null;\n}\nexport function matches(element, selector) {\n    var nativeMatches = element.matches\n        || element.webkitMatchesSelector\n        || element.msMatchesSelector;\n    return nativeMatches.call(element, selector);\n}\n/**\n * Used to compute the estimated scroll width of elements. When an element is\n * hidden due to display: none; being applied to a parent element, the width is\n * returned as 0. However, the element will have a true width once no longer\n * inside a display: none context. This method computes an estimated width when\n * the element is hidden or returns the true width when the element is visble.\n * @param {Element} element the element whose width to estimate\n */\nexport function estimateScrollWidth(element) {\n    // Check the offsetParent. If the element inherits display: none from any\n    // parent, the offsetParent property will be null (see\n    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent).\n    // This check ensures we only clone the node when necessary.\n    var htmlEl = element;\n    if (htmlEl.offsetParent !== null) {\n        return htmlEl.scrollWidth;\n    }\n    var clone = htmlEl.cloneNode(true);\n    clone.style.setProperty('position', 'absolute');\n    clone.style.setProperty('transform', 'translate(-9999px, -9999px)');\n    document.documentElement.appendChild(clone);\n    var scrollWidth = clone.scrollWidth;\n    document.documentElement.removeChild(clone);\n    return scrollWidth;\n}\n//# sourceMappingURL=ponyfill.js.map","/**\n@license\nCopyright 2018 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n/**\n * Return an element assigned to a given slot that matches the given selector\n */\nimport { matches } from '@material/dom/ponyfill';\n/**\n * Determines whether a node is an element.\n *\n * @param node Node to check\n */\nexport const isNodeElement = (node) => {\n    return node.nodeType === Node.ELEMENT_NODE;\n};\nexport function findAssignedElement(slot, selector) {\n    for (const node of slot.assignedNodes({ flatten: true })) {\n        if (isNodeElement(node)) {\n            const el = node;\n            if (matches(el, selector)) {\n                return el;\n            }\n        }\n    }\n    return null;\n}\nexport function addHasRemoveClass(element) {\n    return {\n        addClass: (className) => {\n            element.classList.add(className);\n        },\n        removeClass: (className) => {\n            element.classList.remove(className);\n        },\n        hasClass: (className) => element.classList.contains(className),\n    };\n}\nlet supportsPassive = false;\nconst fn = () => { };\nconst optionsBlock = {\n    get passive() {\n        supportsPassive = true;\n        return false;\n    }\n};\ndocument.addEventListener('x', fn, optionsBlock);\ndocument.removeEventListener('x', fn);\n/**\n * Do event listeners suport the `passive` option?\n */\nexport const supportsPassiveEventListener = supportsPassive;\nexport const deepActiveElementPath = (doc = window.document) => {\n    let activeElement = doc.activeElement;\n    const path = [];\n    if (!activeElement) {\n        return path;\n    }\n    while (activeElement) {\n        path.push(activeElement);\n        if (activeElement.shadowRoot) {\n            activeElement = activeElement.shadowRoot.activeElement;\n        }\n        else {\n            break;\n        }\n    }\n    return path;\n};\nexport const doesElementContainFocus = (element) => {\n    const activePath = deepActiveElementPath();\n    if (!activePath.length) {\n        return false;\n    }\n    const deepActiveElement = activePath[activePath.length - 1];\n    const focusEv = new Event('check-if-focused', { bubbles: true, composed: true });\n    let composedPath = [];\n    const listener = (ev) => {\n        composedPath = ev.composedPath();\n    };\n    document.body.addEventListener('check-if-focused', listener);\n    deepActiveElement.dispatchEvent(focusEv);\n    document.body.removeEventListener('check-if-focused', listener);\n    return composedPath.indexOf(element) !== -1;\n};\n//# sourceMappingURL=utils.js.map","/**\n@license\nCopyright 2018 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { LitElement } from 'lit-element';\nexport { addHasRemoveClass } from './utils';\n/** @soyCompatible */\nexport class BaseElement extends LitElement {\n    click() {\n        if (this.mdcRoot) {\n            this.mdcRoot.focus();\n            this.mdcRoot.click();\n            return;\n        }\n        super.click();\n    }\n    /**\n     * Create and attach the MDC Foundation to the instance\n     */\n    createFoundation() {\n        if (this.mdcFoundation !== undefined) {\n            this.mdcFoundation.destroy();\n        }\n        if (this.mdcFoundationClass) {\n            this.mdcFoundation = new this.mdcFoundationClass(this.createAdapter());\n            this.mdcFoundation.init();\n        }\n    }\n    firstUpdated() {\n        this.createFoundation();\n    }\n}\n//# sourceMappingURL=base-element.js.map","/**\n@license\nCopyright 2018 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/ // tslint:disable:no-any\n/**\n * Specifies an observer callback that is run when the decorated property\n * changes. The observer receives the current and old value as arguments.\n */\nexport const observer = (observer) => \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n(proto, propName) => {\n    // if we haven't wrapped `updated` in this class, do so\n    if (!proto.constructor\n        ._observers) {\n        proto.constructor._observers = new Map();\n        const userUpdated = proto.updated;\n        proto.updated = function (changedProperties) {\n            userUpdated.call(this, changedProperties);\n            changedProperties.forEach((v, k) => {\n                const observers = this.constructor\n                    ._observers;\n                const observer = observers.get(k);\n                if (observer !== undefined) {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    observer.call(this, this[k], v);\n                }\n            });\n        };\n        // clone any existing observers (superclasses)\n        // eslint-disable-next-line no-prototype-builtins\n    }\n    else if (!proto.constructor.hasOwnProperty('_observers')) {\n        const observers = proto.constructor._observers;\n        proto.constructor._observers = new Map();\n        observers.forEach(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (v, k) => proto.constructor._observers.set(k, v));\n    }\n    // set this method\n    proto.constructor._observers.set(propName, observer);\n};\n//# sourceMappingURL=observer.js.map","/**\n * @license\n * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\nimport { AttributePart, directive, PropertyPart } from '../lit-html.js';\n// IE11 doesn't support classList on SVG elements, so we emulate it with a Set\nclass ClassList {\n    constructor(element) {\n        this.classes = new Set();\n        this.changed = false;\n        this.element = element;\n        const classList = (element.getAttribute('class') || '').split(/\\s+/);\n        for (const cls of classList) {\n            this.classes.add(cls);\n        }\n    }\n    add(cls) {\n        this.classes.add(cls);\n        this.changed = true;\n    }\n    remove(cls) {\n        this.classes.delete(cls);\n        this.changed = true;\n    }\n    commit() {\n        if (this.changed) {\n            let classString = '';\n            this.classes.forEach((cls) => classString += cls + ' ');\n            this.element.setAttribute('class', classString);\n        }\n    }\n}\n/**\n * Stores the ClassInfo object applied to a given AttributePart.\n * Used to unset existing values when a new ClassInfo object is applied.\n */\nconst previousClassesCache = new WeakMap();\n/**\n * A directive that applies CSS classes. This must be used in the `class`\n * attribute and must be the only part used in the attribute. It takes each\n * property in the `classInfo` argument and adds the property name to the\n * element's `class` if the property value is truthy; if the property value is\n * falsey, the property name is removed from the element's `class`. For example\n * `{foo: bar}` applies the class `foo` if the value of `bar` is truthy.\n * @param classInfo {ClassInfo}\n */\nexport const classMap = directive((classInfo) => (part) => {\n    if (!(part instanceof AttributePart) || (part instanceof PropertyPart) ||\n        part.committer.name !== 'class' || part.committer.parts.length > 1) {\n        throw new Error('The `classMap` directive must be used in the `class` attribute ' +\n            'and must be the only part in the attribute.');\n    }\n    const { committer } = part;\n    const { element } = committer;\n    let previousClasses = previousClassesCache.get(part);\n    if (previousClasses === undefined) {\n        // Write static classes once\n        // Use setAttribute() because className isn't a string on SVG elements\n        element.setAttribute('class', committer.strings.join(' '));\n        previousClassesCache.set(part, previousClasses = new Set());\n    }\n    const classList = (element.classList || new ClassList(element));\n    // Remove old classes that no longer apply\n    // We use forEach() instead of for-of so that re don't require down-level\n    // iteration.\n    previousClasses.forEach((name) => {\n        if (!(name in classInfo)) {\n            classList.remove(name);\n            previousClasses.delete(name);\n        }\n    });\n    // Add or remove classes based on their classMap value\n    for (const name in classInfo) {\n        const value = classInfo[name];\n        if (value != previousClasses.has(name)) {\n            // We explicitly want a loose truthy check of `value` because it seems\n            // more convenient that '' and 0 are skipped.\n            if (value) {\n                classList.add(name);\n                previousClasses.add(name);\n            }\n            else {\n                classList.remove(name);\n                previousClasses.delete(name);\n            }\n        }\n    }\n    if (typeof classList.commit === 'function') {\n        classList.commit();\n    }\n});\n//# sourceMappingURL=class-map.js.map","import { __decorate } from \"tslib\";\n/**\n@license\nCopyright 2019 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport 'blocking-elements';\nimport 'wicg-inert';\nimport { cssClasses } from '@material/dialog/constants';\nimport MDCDialogFoundation from '@material/dialog/foundation';\nimport { applyPassive } from '@material/dom/events';\nimport { closest, matches } from '@material/dom/ponyfill';\nimport { addHasRemoveClass, BaseElement } from '@material/mwc-base/base-element';\nimport { observer } from '@material/mwc-base/observer';\nimport { html, property, query } from 'lit-element';\nimport { classMap } from 'lit-html/directives/class-map';\nconst blockingElements = document.$blockingElements;\nexport class DialogBase extends BaseElement {\n    constructor() {\n        super(...arguments);\n        this.hideActions = false;\n        this.stacked = false;\n        this.heading = '';\n        this.scrimClickAction = 'close';\n        this.escapeKeyAction = 'close';\n        this.open = false;\n        this.defaultAction = 'close';\n        this.actionAttribute = 'dialogAction';\n        this.initialFocusAttribute = 'dialogInitialFocus';\n        this.initialSupressDefaultPressSelector = '';\n        this.mdcFoundationClass = MDCDialogFoundation;\n        this.boundHandleClick = null;\n        this.boundHandleKeydown = null;\n        this.boundHandleDocumentKeydown = null;\n    }\n    set suppressDefaultPressSelector(selector) {\n        if (this.mdcFoundation) {\n            this.mdcFoundation.setSuppressDefaultPressSelector(selector);\n        }\n        else {\n            this.initialSupressDefaultPressSelector = selector;\n        }\n    }\n    get suppressDefaultPressSelector() {\n        return this.mdcFoundation ?\n            this.mdcFoundation.getSuppressDefaultPressSelector() :\n            this.initialSupressDefaultPressSelector;\n    }\n    get primaryButton() {\n        let assignedNodes = this.primarySlot.assignedNodes();\n        assignedNodes = assignedNodes.filter((node) => node instanceof HTMLElement);\n        const button = assignedNodes[0];\n        return button ? button : null;\n    }\n    emitNotification(name, action) {\n        const init = { detail: action ? { action } : {} };\n        const ev = new CustomEvent(name, init);\n        this.dispatchEvent(ev);\n    }\n    getInitialFocusEl() {\n        const initFocusSelector = `[${this.initialFocusAttribute}]`;\n        // only search light DOM. This typically handles all the cases\n        const lightDomQs = this.querySelector(initFocusSelector);\n        if (lightDomQs) {\n            return lightDomQs;\n        }\n        // if not in light dom, search each flattened distributed node.\n        const primarySlot = this.primarySlot;\n        const primaryNodes = primarySlot.assignedNodes({ flatten: true });\n        const primaryFocusElement = this.searchNodeTreesForAttribute(primaryNodes, this.initialFocusAttribute);\n        if (primaryFocusElement) {\n            return primaryFocusElement;\n        }\n        const secondarySlot = this.secondarySlot;\n        const secondaryNodes = secondarySlot.assignedNodes({ flatten: true });\n        const secondaryFocusElement = this.searchNodeTreesForAttribute(secondaryNodes, this.initialFocusAttribute);\n        if (secondaryFocusElement) {\n            return secondaryFocusElement;\n        }\n        const contentSlot = this.contentSlot;\n        const contentNodes = contentSlot.assignedNodes({ flatten: true });\n        const initFocusElement = this.searchNodeTreesForAttribute(contentNodes, this.initialFocusAttribute);\n        return initFocusElement;\n    }\n    searchNodeTreesForAttribute(nodes, attribute) {\n        for (const node of nodes) {\n            if (!(node instanceof HTMLElement)) {\n                continue;\n            }\n            if (node.hasAttribute(attribute)) {\n                return node;\n            }\n            else {\n                const selection = node.querySelector(`[${attribute}]`);\n                if (selection) {\n                    return selection;\n                }\n            }\n        }\n        return null;\n    }\n    createAdapter() {\n        return Object.assign(Object.assign({}, addHasRemoveClass(this.mdcRoot)), { addBodyClass: () => document.body.style.overflow = 'hidden', removeBodyClass: () => document.body.style.overflow = '', areButtonsStacked: () => this.stacked, clickDefaultButton: () => {\n                const primary = this.primaryButton;\n                if (primary) {\n                    primary.click();\n                }\n            }, eventTargetMatches: (target, selector) => target ? matches(target, selector) : false, getActionFromEvent: (e) => {\n                if (!e.target) {\n                    return '';\n                }\n                const element = closest(e.target, `[${this.actionAttribute}]`);\n                const action = element && element.getAttribute(this.actionAttribute);\n                return action;\n            }, getInitialFocusEl: () => {\n                return this.getInitialFocusEl();\n            }, isContentScrollable: () => {\n                const el = this.contentElement;\n                return el ? el.scrollHeight > el.offsetHeight : false;\n            }, notifyClosed: (action) => this.emitNotification('closed', action), notifyClosing: (action) => {\n                if (!this.closingDueToDisconnect) {\n                    // Don't set our open state to closed just because we were\n                    // disconnected. That way if we get reconnected, we'll know to\n                    // re-open.\n                    this.open = false;\n                }\n                this.emitNotification('closing', action);\n            }, notifyOpened: () => this.emitNotification('opened'), notifyOpening: () => {\n                this.open = true;\n                this.emitNotification('opening');\n            }, reverseButtons: () => { }, releaseFocus: () => {\n                blockingElements.remove(this);\n            }, trapFocus: (el) => {\n                if (!this.isConnected) {\n                    // this is the case where it is opened and closed and then removed\n                    // from DOM before the animation has completed. Blocking Elements will\n                    // throw if this is the case\n                    return;\n                }\n                blockingElements.push(this);\n                if (el) {\n                    el.focus();\n                }\n            }, registerContentEventHandler: (evtType, handler) => {\n                const el = this.contentElement;\n                el.addEventListener(evtType, handler);\n            }, deregisterContentEventHandler: (evtType, handler) => {\n                const el = this.contentElement;\n                el.removeEventListener(evtType, handler);\n            }, isScrollableContentAtTop: () => {\n                const el = this.contentElement;\n                return el ? el.scrollTop === 0 : false;\n            }, isScrollableContentAtBottom: () => {\n                const el = this.contentElement;\n                return el ?\n                    Math.ceil(el.scrollHeight - el.scrollTop) === el.clientHeight :\n                    false;\n            }, registerWindowEventHandler: (evtType, handler) => {\n                window.addEventListener(evtType, handler, applyPassive());\n            }, deregisterWindowEventHandler: (evtType, handler) => {\n                window.removeEventListener(evtType, handler, applyPassive());\n            } });\n    }\n    render() {\n        const classes = {\n            [cssClasses.STACKED]: this.stacked,\n        };\n        let heading = html ``;\n        if (this.heading) {\n            heading = this.renderHeading();\n        }\n        const actionsClasses = {\n            'mdc-dialog__actions': !this.hideActions,\n        };\n        return html `\n    <div class=\"mdc-dialog ${classMap(classes)}\"\n        role=\"alertdialog\"\n        aria-modal=\"true\"\n        aria-labelledby=\"title\"\n        aria-describedby=\"content\">\n      <div class=\"mdc-dialog__container\">\n        <div class=\"mdc-dialog__surface\">\n          ${heading}\n          <div id=\"content\" class=\"mdc-dialog__content\">\n            <slot id=\"contentSlot\"></slot>\n          </div>\n          <footer\n              id=\"actions\"\n              class=\"${classMap(actionsClasses)}\">\n            <span>\n              <slot name=\"secondaryAction\"></slot>\n            </span>\n            <span>\n             <slot name=\"primaryAction\"></slot>\n            </span>\n          </footer>\n        </div>\n      </div>\n      <div class=\"mdc-dialog__scrim\"></div>\n    </div>`;\n    }\n    renderHeading() {\n        return html `\n      <h2 id=\"title\" class=\"mdc-dialog__title\">${this.heading}</h2>`;\n    }\n    firstUpdated() {\n        super.firstUpdated();\n        this.mdcFoundation.setAutoStackButtons(true);\n        if (this.initialSupressDefaultPressSelector) {\n            this.suppressDefaultPressSelector =\n                this.initialSupressDefaultPressSelector;\n        }\n        else {\n            this.suppressDefaultPressSelector = [\n                this.suppressDefaultPressSelector, 'mwc-textarea',\n                'mwc-menu mwc-list-item', 'mwc-select mwc-list-item'\n            ].join(', ');\n        }\n        this.boundHandleClick = this.mdcFoundation.handleClick.bind(this.mdcFoundation);\n        this.boundHandleKeydown = this.mdcFoundation.handleKeydown.bind(this.mdcFoundation);\n        this.boundHandleDocumentKeydown =\n            this.mdcFoundation.handleDocumentKeydown.bind(this.mdcFoundation);\n    }\n    connectedCallback() {\n        super.connectedCallback();\n        if (this.open && this.mdcFoundation && !this.mdcFoundation.isOpen()) {\n            // We probably got disconnected while we were still open. Re-open,\n            // matching the behavior of native <dialog>.\n            this.setEventListeners();\n            this.mdcFoundation.open();\n        }\n    }\n    disconnectedCallback() {\n        super.disconnectedCallback();\n        if (this.open && this.mdcFoundation) {\n            // If this dialog is opened and then disconnected, we want to close\n            // the foundation, so that 1) any pending timers are cancelled\n            // (in particular for trapFocus), and 2) if we reconnect, we can open\n            // the foundation again to retrigger animations and focus.\n            this.removeEventListeners();\n            this.closingDueToDisconnect = true;\n            this.mdcFoundation.close(this.currentAction || this.defaultAction);\n            this.closingDueToDisconnect = false;\n            this.currentAction = undefined;\n            // When we close normally, the releaseFocus callback handles removing\n            // ourselves from the blocking elements stack. However, that callback\n            // happens on a delay, and when we are closing due to a disconnect we\n            // need to remove ourselves before the blocking element polyfill's\n            // mutation observer notices and logs a warning, since it's not valid to\n            // be in the blocking elements stack while disconnected.\n            blockingElements.remove(this);\n        }\n    }\n    forceLayout() {\n        this.mdcFoundation.layout();\n    }\n    focus() {\n        const initialFocusEl = this.getInitialFocusEl();\n        initialFocusEl && initialFocusEl.focus();\n    }\n    blur() {\n        if (!this.shadowRoot) {\n            return;\n        }\n        const activeEl = this.shadowRoot.activeElement;\n        if (activeEl) {\n            if (activeEl instanceof HTMLElement) {\n                activeEl.blur();\n            }\n        }\n        else {\n            const root = this.getRootNode();\n            const activeEl = root instanceof Document ? root.activeElement : null;\n            if (activeEl instanceof HTMLElement) {\n                activeEl.blur();\n            }\n        }\n    }\n    setEventListeners() {\n        if (this.boundHandleClick) {\n            this.mdcRoot.addEventListener('click', this.boundHandleClick);\n        }\n        if (this.boundHandleKeydown) {\n            this.mdcRoot.addEventListener('keydown', this.boundHandleKeydown, applyPassive());\n        }\n        if (this.boundHandleDocumentKeydown) {\n            document.addEventListener('keydown', this.boundHandleDocumentKeydown, applyPassive());\n        }\n    }\n    removeEventListeners() {\n        if (this.boundHandleClick) {\n            this.mdcRoot.removeEventListener('click', this.boundHandleClick);\n        }\n        if (this.boundHandleKeydown) {\n            this.mdcRoot.removeEventListener('keydown', this.boundHandleKeydown);\n        }\n        if (this.boundHandleDocumentKeydown) {\n            document.removeEventListener('keydown', this.boundHandleDocumentKeydown);\n        }\n    }\n    close() {\n        this.open = false;\n    }\n    show() {\n        this.open = true;\n    }\n}\n__decorate([\n    query('.mdc-dialog')\n], DialogBase.prototype, \"mdcRoot\", void 0);\n__decorate([\n    query('slot[name=\"primaryAction\"]')\n], DialogBase.prototype, \"primarySlot\", void 0);\n__decorate([\n    query('slot[name=\"secondaryAction\"]')\n], DialogBase.prototype, \"secondarySlot\", void 0);\n__decorate([\n    query('#contentSlot')\n], DialogBase.prototype, \"contentSlot\", void 0);\n__decorate([\n    query('.mdc-dialog__content')\n], DialogBase.prototype, \"contentElement\", void 0);\n__decorate([\n    query('.mdc-container')\n], DialogBase.prototype, \"conatinerElement\", void 0);\n__decorate([\n    property({ type: Boolean })\n], DialogBase.prototype, \"hideActions\", void 0);\n__decorate([\n    property({ type: Boolean }),\n    observer(function () {\n        this.forceLayout();\n    })\n], DialogBase.prototype, \"stacked\", void 0);\n__decorate([\n    property({ type: String })\n], DialogBase.prototype, \"heading\", void 0);\n__decorate([\n    property({ type: String }),\n    observer(function (newAction) {\n        this.mdcFoundation.setScrimClickAction(newAction);\n    })\n], DialogBase.prototype, \"scrimClickAction\", void 0);\n__decorate([\n    property({ type: String }),\n    observer(function (newAction) {\n        this.mdcFoundation.setEscapeKeyAction(newAction);\n    })\n], DialogBase.prototype, \"escapeKeyAction\", void 0);\n__decorate([\n    property({ type: Boolean, reflect: true }),\n    observer(function (isOpen) {\n        // Check isConnected because we could have been disconnected before first\n        // update. If we're now closed, then we shouldn't start the MDC foundation\n        // opening animation. If we're now closed, then we've already closed the\n        // foundation in disconnectedCallback.\n        if (this.mdcFoundation && this.isConnected) {\n            if (isOpen) {\n                this.setEventListeners();\n                this.mdcFoundation.open();\n            }\n            else {\n                this.removeEventListeners();\n                this.mdcFoundation.close(this.currentAction || this.defaultAction);\n                this.currentAction = undefined;\n            }\n        }\n    })\n], DialogBase.prototype, \"open\", void 0);\n__decorate([\n    property()\n], DialogBase.prototype, \"defaultAction\", void 0);\n__decorate([\n    property()\n], DialogBase.prototype, \"actionAttribute\", void 0);\n__decorate([\n    property()\n], DialogBase.prototype, \"initialFocusAttribute\", void 0);\n//# sourceMappingURL=mwc-dialog-base.js.map","/**\n@license\nCopyright 2018 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { css } from 'lit-element';\nexport const style = css `.mdc-elevation-overlay{position:absolute;border-radius:inherit;pointer-events:none;opacity:0;opacity:var(--mdc-elevation-overlay-opacity, 0);transition:opacity 280ms cubic-bezier(0.4, 0, 0.2, 1);background-color:#fff;background-color:var(--mdc-elevation-overlay-color, #fff)}.mdc-dialog,.mdc-dialog__scrim{position:fixed;top:0;left:0;align-items:center;justify-content:center;box-sizing:border-box;width:100%;height:100%}.mdc-dialog{display:none;z-index:7;z-index:var(--mdc-dialog-z-index, 7)}.mdc-dialog .mdc-dialog__surface{background-color:#fff;background-color:var(--mdc-theme-surface, #fff)}.mdc-dialog .mdc-dialog__scrim{background-color:rgba(0,0,0,.32)}.mdc-dialog .mdc-dialog__surface-scrim{background-color:rgba(0,0,0,.32)}.mdc-dialog .mdc-dialog__title{color:rgba(0,0,0,.87)}.mdc-dialog .mdc-dialog__content{color:rgba(0,0,0,.6)}.mdc-dialog .mdc-dialog__close{color:#000;color:var(--mdc-theme-on-surface, #000)}.mdc-dialog .mdc-dialog__close::before,.mdc-dialog .mdc-dialog__close::after{background-color:#000;background-color:var(--mdc-ripple-color, var(--mdc-theme-on-surface, #000))}.mdc-dialog .mdc-dialog__close:hover::before,.mdc-dialog .mdc-dialog__close.mdc-ripple-surface--hover::before{opacity:0.04;opacity:var(--mdc-ripple-hover-opacity, 0.04)}.mdc-dialog .mdc-dialog__close.mdc-ripple-upgraded--background-focused::before,.mdc-dialog .mdc-dialog__close:not(.mdc-ripple-upgraded):focus::before{transition-duration:75ms;opacity:0.12;opacity:var(--mdc-ripple-focus-opacity, 0.12)}.mdc-dialog .mdc-dialog__close:not(.mdc-ripple-upgraded)::after{transition:opacity 150ms linear}.mdc-dialog .mdc-dialog__close:not(.mdc-ripple-upgraded):active::after{transition-duration:75ms;opacity:0.12;opacity:var(--mdc-ripple-press-opacity, 0.12)}.mdc-dialog .mdc-dialog__close.mdc-ripple-upgraded{--mdc-ripple-fg-opacity: var(--mdc-ripple-press-opacity, 0.12)}.mdc-dialog.mdc-dialog--scrollable .mdc-dialog__title,.mdc-dialog.mdc-dialog--scrollable .mdc-dialog__actions,.mdc-dialog.mdc-dialog--scrollable.mdc-dialog-scroll-divider-footer .mdc-dialog__actions{border-color:rgba(0,0,0,.12)}.mdc-dialog.mdc-dialog--scrollable .mdc-dialog__title{border-bottom:1px solid rgba(0,0,0,.12);margin-bottom:0}.mdc-dialog.mdc-dialog-scroll-divider-header.mdc-dialog--fullscreen .mdc-dialog__header{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0,0,0,.12)}.mdc-dialog .mdc-dialog__content{padding:20px 24px 20px 24px}.mdc-dialog .mdc-dialog__surface{min-width:280px}@media(max-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:calc(100vw - 32px)}}@media(min-width: 592px){.mdc-dialog .mdc-dialog__surface{max-width:560px}}.mdc-dialog .mdc-dialog__surface{max-height:calc(100% - 32px)}.mdc-dialog .mdc-dialog__surface{border-radius:4px;border-radius:var(--mdc-shape-medium, 4px)}@media(max-width: 960px)and (max-height: 1440px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px;max-width:560px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-height: 1023px)and (max-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-width:calc(100vw - 112px)}}@media(max-width: 720px)and (max-height: 1023px)and (min-width: 672px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-width:560px}}@media(max-width: 720px)and (max-height: 1023px)and (max-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:calc(100vh - 160px)}}@media(max-width: 720px)and (max-height: 1023px)and (min-height: 720px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-height:560px}}@media(max-width: 720px)and (max-height: 1023px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}@media(max-width: 720px)and (max-height: 400px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{height:100%;max-height:100vh;max-width:100vw;width:100%;border-radius:0}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{order:-1;left:-12px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__header{padding:0 16px 9px;justify-content:flex-start}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__title{margin-left:calc(16px - 2 * 12px)}}@media(max-width: 600px)and (max-height: 960px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{height:100%;max-height:100vh;max-width:100vw;width:100%;border-radius:0}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{order:-1;left:-12px}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__header{padding:0 16px 9px;justify-content:flex-start}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__title{margin-left:calc(16px - 2 * 12px)}}@media(min-width: 960px)and (min-height: 1440px){.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface{max-width:calc(100vw - 400px)}.mdc-dialog.mdc-dialog--fullscreen .mdc-dialog__surface .mdc-dialog__close{right:-12px}}.mdc-dialog.mdc-dialog__scrim--hidden .mdc-dialog__scrim{opacity:0}.mdc-dialog__scrim{opacity:0;z-index:-1}.mdc-dialog__container{display:flex;flex-direction:row;align-items:center;justify-content:space-around;box-sizing:border-box;height:100%;transform:scale(0.8);opacity:0;pointer-events:none}.mdc-dialog__surface{position:relative;box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0,0,0,.12);display:flex;flex-direction:column;flex-grow:0;flex-shrink:0;box-sizing:border-box;max-width:100%;max-height:100%;pointer-events:auto;overflow-y:auto}.mdc-dialog__surface .mdc-elevation-overlay{width:100%;height:100%;top:0;left:0}[dir=rtl] .mdc-dialog__surface,.mdc-dialog__surface[dir=rtl]{text-align:right}@media screen and (-ms-high-contrast: active){.mdc-dialog__surface{outline:2px solid windowText}}.mdc-dialog__surface::before{position:absolute;box-sizing:border-box;width:100%;height:100%;top:0;left:0;border:2px solid transparent;border-radius:inherit;content:\"\";pointer-events:none}@media screen and (-ms-high-contrast: active),screen and (-ms-high-contrast: none){.mdc-dialog__surface::before{content:none}}.mdc-dialog__title{display:block;margin-top:0;line-height:normal;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:Roboto, sans-serif;font-family:var(--mdc-typography-headline6-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:1.25rem;font-size:var(--mdc-typography-headline6-font-size, 1.25rem);line-height:2rem;line-height:var(--mdc-typography-headline6-line-height, 2rem);font-weight:500;font-weight:var(--mdc-typography-headline6-font-weight, 500);letter-spacing:0.0125em;letter-spacing:var(--mdc-typography-headline6-letter-spacing, 0.0125em);text-decoration:inherit;text-decoration:var(--mdc-typography-headline6-text-decoration, inherit);text-transform:inherit;text-transform:var(--mdc-typography-headline6-text-transform, inherit);position:relative;flex-shrink:0;box-sizing:border-box;margin:0 0 1px;padding:0 24px 9px}.mdc-dialog__title::before{display:inline-block;width:0;height:40px;content:\"\";vertical-align:0}[dir=rtl] .mdc-dialog__title,.mdc-dialog__title[dir=rtl]{text-align:right}.mdc-dialog--scrollable .mdc-dialog__title{margin-bottom:1px;padding-bottom:15px}.mdc-dialog--fullscreen .mdc-dialog__header{display:inline-flex;padding:0 24px 9px;border-bottom:1px solid transparent;justify-content:space-between;align-items:baseline}.mdc-dialog--fullscreen .mdc-dialog__header .mdc-dialog__close{right:-12px}.mdc-dialog--fullscreen .mdc-dialog__title{margin-bottom:0;padding:0;border-bottom:0}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__title{border-bottom:0;margin-bottom:0}.mdc-dialog--fullscreen .mdc-dialog__close{top:5px}.mdc-dialog--fullscreen.mdc-dialog--scrollable .mdc-dialog__actions{border-top:1px solid transparent}.mdc-dialog__content{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;font-family:Roboto, sans-serif;font-family:var(--mdc-typography-body1-font-family, var(--mdc-typography-font-family, Roboto, sans-serif));font-size:1rem;font-size:var(--mdc-typography-body1-font-size, 1rem);line-height:1.5rem;line-height:var(--mdc-typography-body1-line-height, 1.5rem);font-weight:400;font-weight:var(--mdc-typography-body1-font-weight, 400);letter-spacing:0.03125em;letter-spacing:var(--mdc-typography-body1-letter-spacing, 0.03125em);text-decoration:inherit;text-decoration:var(--mdc-typography-body1-text-decoration, inherit);text-transform:inherit;text-transform:var(--mdc-typography-body1-text-transform, inherit);flex-grow:1;box-sizing:border-box;margin:0;overflow:auto;-webkit-overflow-scrolling:touch}.mdc-dialog__content>:first-child{margin-top:0}.mdc-dialog__content>:last-child{margin-bottom:0}.mdc-dialog__title+.mdc-dialog__content,.mdc-dialog__header+.mdc-dialog__content{padding-top:0}.mdc-dialog--scrollable .mdc-dialog__title+.mdc-dialog__content{padding-top:8px;padding-bottom:8px}.mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:6px 0 0}.mdc-dialog--scrollable .mdc-dialog__content .mdc-deprecated-list:first-child:last-child{padding:0}.mdc-dialog__actions{display:flex;position:relative;flex-shrink:0;flex-wrap:wrap;align-items:center;justify-content:flex-end;box-sizing:border-box;min-height:52px;margin:0;padding:8px;border-top:1px solid transparent}.mdc-dialog--stacked .mdc-dialog__actions{flex-direction:column;align-items:flex-end}.mdc-dialog__button{margin-left:8px;margin-right:0;max-width:100%;text-align:right}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{margin-left:0;margin-right:8px}.mdc-dialog__button:first-child{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button:first-child,.mdc-dialog__button:first-child[dir=rtl]{margin-left:0;margin-right:0}[dir=rtl] .mdc-dialog__button,.mdc-dialog__button[dir=rtl]{text-align:left}.mdc-dialog--stacked .mdc-dialog__button:not(:first-child){margin-top:12px}.mdc-dialog--open,.mdc-dialog--opening,.mdc-dialog--closing{display:flex}.mdc-dialog--opening .mdc-dialog__scrim{transition:opacity 150ms linear}.mdc-dialog--opening .mdc-dialog__container{transition:opacity 75ms linear,transform 150ms 0ms cubic-bezier(0, 0, 0.2, 1)}.mdc-dialog--closing .mdc-dialog__scrim,.mdc-dialog--closing .mdc-dialog__container{transition:opacity 75ms linear}.mdc-dialog--closing .mdc-dialog__container{transform:none}.mdc-dialog--open .mdc-dialog__scrim{opacity:1}.mdc-dialog--open .mdc-dialog__container{transform:none;opacity:1}.mdc-dialog--open.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim{opacity:1;z-index:1}.mdc-dialog--open.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{transition:opacity 75ms linear}.mdc-dialog--open.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim{transition:opacity 150ms linear}.mdc-dialog__surface-scrim{display:none;opacity:0;position:absolute;width:100%;height:100%}.mdc-dialog__surface-scrim--shown .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--showing .mdc-dialog__surface-scrim,.mdc-dialog__surface-scrim--hiding .mdc-dialog__surface-scrim{display:block}.mdc-dialog-scroll-lock{overflow:hidden}#actions:not(.mdc-dialog__actions){display:none}.mdc-dialog__surface{box-shadow:var(--mdc-dialog-box-shadow, 0px 11px 15px -7px rgba(0, 0, 0, 0.2), 0px 24px 38px 3px rgba(0, 0, 0, 0.14), 0px 9px 46px 8px rgba(0, 0, 0, 0.12))}@media(min-width: 560px){.mdc-dialog .mdc-dialog__surface{max-width:560px;max-width:var(--mdc-dialog-max-width, 560px)}}.mdc-dialog .mdc-dialog__scrim{background-color:rgba(0, 0, 0, 0.32);background-color:var(--mdc-dialog-scrim-color, rgba(0, 0, 0, 0.32))}.mdc-dialog .mdc-dialog__title{color:rgba(0, 0, 0, 0.87);color:var(--mdc-dialog-heading-ink-color, rgba(0, 0, 0, 0.87))}.mdc-dialog .mdc-dialog__content{color:rgba(0, 0, 0, 0.6);color:var(--mdc-dialog-content-ink-color, rgba(0, 0, 0, 0.6))}.mdc-dialog.mdc-dialog--scrollable .mdc-dialog__title,.mdc-dialog.mdc-dialog--scrollable .mdc-dialog__actions{border-color:rgba(0, 0, 0, 0.12);border-color:var(--mdc-dialog-scroll-divider-color, rgba(0, 0, 0, 0.12))}.mdc-dialog .mdc-dialog__surface{min-width:280px;min-width:var(--mdc-dialog-min-width, 280px)}.mdc-dialog .mdc-dialog__surface{max-height:var(--mdc-dialog-max-height, calc(100% - 32px))}#actions ::slotted(*){margin-left:8px;margin-right:0;max-width:100%;text-align:right}[dir=rtl] #actions ::slotted(*),#actions ::slotted(*)[dir=rtl]{margin-left:0;margin-right:8px}[dir=rtl] #actions ::slotted(*),#actions ::slotted(*)[dir=rtl]{text-align:left}.mdc-dialog--stacked #actions{flex-direction:column-reverse}.mdc-dialog--stacked #actions *:not(:last-child) ::slotted(*){flex-basis:1e-9px;margin-top:12px}`;\n//# sourceMappingURL=mwc-dialog-css.js.map","import { __decorate } from \"tslib\";\n/**\n@license\nCopyright 2019 Google Inc. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { customElement } from 'lit-element';\nimport { DialogBase } from './mwc-dialog-base';\nimport { style } from './mwc-dialog-css';\nlet Dialog = class Dialog extends DialogBase {\n};\nDialog.styles = style;\nDialog = __decorate([\n    customElement('mwc-dialog')\n], Dialog);\nexport { Dialog };\n//# sourceMappingURL=mwc-dialog.js.map","/**\n * @license\n * Copyright 2016 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n(() => {\n    var _a, _b, _c;\n    /* Symbols for private properties */\n    const _blockingElements = Symbol();\n    const _alreadyInertElements = Symbol();\n    const _topElParents = Symbol();\n    const _siblingsToRestore = Symbol();\n    const _parentMO = Symbol();\n    /* Symbols for private static methods */\n    const _topChanged = Symbol();\n    const _swapInertedSibling = Symbol();\n    const _inertSiblings = Symbol();\n    const _restoreInertedSiblings = Symbol();\n    const _getParents = Symbol();\n    const _getDistributedChildren = Symbol();\n    const _isInertable = Symbol();\n    const _handleMutations = Symbol();\n    class BlockingElementsImpl {\n        constructor() {\n            /**\n             * The blocking elements.\n             */\n            this[_a] = [];\n            /**\n             * Used to keep track of the parents of the top element, from the element\n             * itself up to body. When top changes, the old top might have been removed\n             * from the document, so we need to memoize the inerted parents' siblings\n             * in order to restore their inerteness when top changes.\n             */\n            this[_b] = [];\n            /**\n             * Elements that are already inert before the first blocking element is\n             * pushed.\n             */\n            this[_c] = new Set();\n        }\n        destructor() {\n            // Restore original inertness.\n            this[_restoreInertedSiblings](this[_topElParents]);\n            // Note we don't want to make these properties nullable on the class,\n            // since then we'd need non-null casts in many places. Calling a method on\n            // a BlockingElements instance after calling destructor will result in an\n            // exception.\n            const nullable = this;\n            nullable[_blockingElements] = null;\n            nullable[_topElParents] = null;\n            nullable[_alreadyInertElements] = null;\n        }\n        get top() {\n            const elems = this[_blockingElements];\n            return elems[elems.length - 1] || null;\n        }\n        push(element) {\n            if (!element || element === this.top) {\n                return;\n            }\n            // Remove it from the stack, we'll bring it to the top.\n            this.remove(element);\n            this[_topChanged](element);\n            this[_blockingElements].push(element);\n        }\n        remove(element) {\n            const i = this[_blockingElements].indexOf(element);\n            if (i === -1) {\n                return false;\n            }\n            this[_blockingElements].splice(i, 1);\n            // Top changed only if the removed element was the top element.\n            if (i === this[_blockingElements].length) {\n                this[_topChanged](this.top);\n            }\n            return true;\n        }\n        pop() {\n            const top = this.top;\n            top && this.remove(top);\n            return top;\n        }\n        has(element) {\n            return this[_blockingElements].indexOf(element) !== -1;\n        }\n        /**\n         * Sets `inert` to all document elements except the new top element, its\n         * parents, and its distributed content.\n         */\n        [(_a = _blockingElements, _b = _topElParents, _c = _alreadyInertElements, _topChanged)](newTop) {\n            const toKeepInert = this[_alreadyInertElements];\n            const oldParents = this[_topElParents];\n            // No new top, reset old top if any.\n            if (!newTop) {\n                this[_restoreInertedSiblings](oldParents);\n                toKeepInert.clear();\n                this[_topElParents] = [];\n                return;\n            }\n            const newParents = this[_getParents](newTop);\n            // New top is not contained in the main document!\n            if (newParents[newParents.length - 1].parentNode !== document.body) {\n                throw Error('Non-connected element cannot be a blocking element');\n            }\n            // Cast here because we know we'll call _inertSiblings on newParents\n            // below.\n            this[_topElParents] = newParents;\n            const toSkip = this[_getDistributedChildren](newTop);\n            // No previous top element.\n            if (!oldParents.length) {\n                this[_inertSiblings](newParents, toSkip, toKeepInert);\n                return;\n            }\n            let i = oldParents.length - 1;\n            let j = newParents.length - 1;\n            // Find common parent. Index 0 is the element itself (so stop before it).\n            while (i > 0 && j > 0 && oldParents[i] === newParents[j]) {\n                i--;\n                j--;\n            }\n            // If up the parents tree there are 2 elements that are siblings, swap\n            // the inerted sibling.\n            if (oldParents[i] !== newParents[j]) {\n                this[_swapInertedSibling](oldParents[i], newParents[j]);\n            }\n            // Restore old parents siblings inertness.\n            i > 0 && this[_restoreInertedSiblings](oldParents.slice(0, i));\n            // Make new parents siblings inert.\n            j > 0 && this[_inertSiblings](newParents.slice(0, j), toSkip, null);\n        }\n        /**\n         * Swaps inertness between two sibling elements.\n         * Sets the property `inert` over the attribute since the inert spec\n         * doesn't specify if it should be reflected.\n         * https://html.spec.whatwg.org/multipage/interaction.html#inert\n         */\n        [_swapInertedSibling](oldInert, newInert) {\n            const siblingsToRestore = oldInert[_siblingsToRestore];\n            // oldInert is not contained in siblings to restore, so we have to check\n            // if it's inertable and if already inert.\n            if (this[_isInertable](oldInert) && !oldInert.inert) {\n                oldInert.inert = true;\n                siblingsToRestore.add(oldInert);\n            }\n            // If newInert was already between the siblings to restore, it means it is\n            // inertable and must be restored.\n            if (siblingsToRestore.has(newInert)) {\n                newInert.inert = false;\n                siblingsToRestore.delete(newInert);\n            }\n            newInert[_parentMO] = oldInert[_parentMO];\n            newInert[_siblingsToRestore] = siblingsToRestore;\n            oldInert[_parentMO] = undefined;\n            oldInert[_siblingsToRestore] = undefined;\n        }\n        /**\n         * Restores original inertness to the siblings of the elements.\n         * Sets the property `inert` over the attribute since the inert spec\n         * doesn't specify if it should be reflected.\n         * https://html.spec.whatwg.org/multipage/interaction.html#inert\n         */\n        [_restoreInertedSiblings](elements) {\n            for (const element of elements) {\n                const mo = element[_parentMO];\n                mo.disconnect();\n                element[_parentMO] = undefined;\n                const siblings = element[_siblingsToRestore];\n                for (const sibling of siblings) {\n                    sibling.inert = false;\n                }\n                element[_siblingsToRestore] = undefined;\n            }\n        }\n        /**\n         * Inerts the siblings of the elements except the elements to skip. Stores\n         * the inerted siblings into the element's symbol `_siblingsToRestore`.\n         * Pass `toKeepInert` to collect the already inert elements.\n         * Sets the property `inert` over the attribute since the inert spec\n         * doesn't specify if it should be reflected.\n         * https://html.spec.whatwg.org/multipage/interaction.html#inert\n         */\n        [_inertSiblings](elements, toSkip, toKeepInert) {\n            for (const element of elements) {\n                // Assume element is not a Document, so it must have a parentNode.\n                const parent = element.parentNode;\n                const children = parent.children;\n                const inertedSiblings = new Set();\n                for (let j = 0; j < children.length; j++) {\n                    const sibling = children[j];\n                    // Skip the input element, if not inertable or to be skipped.\n                    if (sibling === element || !this[_isInertable](sibling) ||\n                        (toSkip && toSkip.has(sibling))) {\n                        continue;\n                    }\n                    // Should be collected since already inerted.\n                    if (toKeepInert && sibling.inert) {\n                        toKeepInert.add(sibling);\n                    }\n                    else {\n                        sibling.inert = true;\n                        inertedSiblings.add(sibling);\n                    }\n                }\n                // Store the siblings that were inerted.\n                element[_siblingsToRestore] = inertedSiblings;\n                // Observe only immediate children mutations on the parent.\n                const mo = new MutationObserver(this[_handleMutations].bind(this));\n                element[_parentMO] = mo;\n                let parentToObserve = parent;\n                // If we're using the ShadyDOM polyfill, then our parent could be a\n                // shady root, which is an object that acts like a ShadowRoot, but isn't\n                // actually a node in the real DOM. Observe the real DOM parent instead.\n                const maybeShadyRoot = parentToObserve;\n                if (maybeShadyRoot.__shady && maybeShadyRoot.host) {\n                    parentToObserve = maybeShadyRoot.host;\n                }\n                mo.observe(parentToObserve, {\n                    childList: true,\n                });\n            }\n        }\n        /**\n         * Handles newly added/removed nodes by toggling their inertness.\n         * It also checks if the current top Blocking Element has been removed,\n         * notifying and removing it.\n         */\n        [_handleMutations](mutations) {\n            const parents = this[_topElParents];\n            const toKeepInert = this[_alreadyInertElements];\n            for (const mutation of mutations) {\n                // If the target is a shadowRoot, get its host as we skip shadowRoots when\n                // computing _topElParents.\n                const target = mutation.target.host || mutation.target;\n                const idx = target === document.body ?\n                    parents.length :\n                    parents.indexOf(target);\n                const inertedChild = parents[idx - 1];\n                const inertedSiblings = inertedChild[_siblingsToRestore];\n                // To restore.\n                for (let i = 0; i < mutation.removedNodes.length; i++) {\n                    const sibling = mutation.removedNodes[i];\n                    if (sibling === inertedChild) {\n                        console.info('Detected removal of the top Blocking Element.');\n                        this.pop();\n                        return;\n                    }\n                    if (inertedSiblings.has(sibling)) {\n                        sibling.inert = false;\n                        inertedSiblings.delete(sibling);\n                    }\n                }\n                // To inert.\n                for (let i = 0; i < mutation.addedNodes.length; i++) {\n                    const sibling = mutation.addedNodes[i];\n                    if (!this[_isInertable](sibling)) {\n                        continue;\n                    }\n                    if (toKeepInert && sibling.inert) {\n                        toKeepInert.add(sibling);\n                    }\n                    else {\n                        sibling.inert = true;\n                        inertedSiblings.add(sibling);\n                    }\n                }\n            }\n        }\n        /**\n         * Returns if the element is inertable.\n         */\n        [_isInertable](element) {\n            return false === /^(style|template|script)$/.test(element.localName);\n        }\n        /**\n         * Returns the list of newParents of an element, starting from element\n         * (included) up to `document.body` (excluded).\n         */\n        [_getParents](element) {\n            const parents = [];\n            let current = element;\n            // Stop to body.\n            while (current && current !== document.body) {\n                // Skip shadow roots.\n                if (current.nodeType === Node.ELEMENT_NODE) {\n                    parents.push(current);\n                }\n                // ShadowDom v1\n                if (current.assignedSlot) {\n                    // Collect slots from deepest slot to top.\n                    while (current = current.assignedSlot) {\n                        parents.push(current);\n                    }\n                    // Continue the search on the top slot.\n                    current = parents.pop();\n                    continue;\n                }\n                current = current.parentNode ||\n                    current.host;\n            }\n            return parents;\n        }\n        /**\n         * Returns the distributed children of the element's shadow root.\n         * Returns null if the element doesn't have a shadow root.\n         */\n        [_getDistributedChildren](element) {\n            const shadowRoot = element.shadowRoot;\n            if (!shadowRoot) {\n                return null;\n            }\n            const result = new Set();\n            let i;\n            let j;\n            let nodes;\n            const slots = shadowRoot.querySelectorAll('slot');\n            if (slots.length && slots[0].assignedNodes) {\n                for (i = 0; i < slots.length; i++) {\n                    nodes = slots[i].assignedNodes({\n                        flatten: true,\n                    });\n                    for (j = 0; j < nodes.length; j++) {\n                        if (nodes[j].nodeType === Node.ELEMENT_NODE) {\n                            result.add(nodes[j]);\n                        }\n                    }\n                }\n                // No need to search for <content>.\n            }\n            return result;\n        }\n    }\n    document.$blockingElements =\n        new BlockingElementsImpl();\n})();\n//# sourceMappingURL=blocking-elements.js.map","var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * This work is licensed under the W3C Software and Document License\n * (http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document).\n */\n\n(function () {\n  // Return early if we're not running inside of the browser.\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  // Convenience function for converting NodeLists.\n  /** @type {typeof Array.prototype.slice} */\n  var slice = Array.prototype.slice;\n\n  /**\n   * IE has a non-standard name for \"matches\".\n   * @type {typeof Element.prototype.matches}\n   */\n  var matches = Element.prototype.matches || Element.prototype.msMatchesSelector;\n\n  /** @type {string} */\n  var _focusableElementsString = ['a[href]', 'area[href]', 'input:not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'button:not([disabled])', 'details', 'summary', 'iframe', 'object', 'embed', '[contenteditable]'].join(',');\n\n  /**\n   * `InertRoot` manages a single inert subtree, i.e. a DOM subtree whose root element has an `inert`\n   * attribute.\n   *\n   * Its main functions are:\n   *\n   * - to create and maintain a set of managed `InertNode`s, including when mutations occur in the\n   *   subtree. The `makeSubtreeUnfocusable()` method handles collecting `InertNode`s via registering\n   *   each focusable node in the subtree with the singleton `InertManager` which manages all known\n   *   focusable nodes within inert subtrees. `InertManager` ensures that a single `InertNode`\n   *   instance exists for each focusable node which has at least one inert root as an ancestor.\n   *\n   * - to notify all managed `InertNode`s when this subtree stops being inert (i.e. when the `inert`\n   *   attribute is removed from the root node). This is handled in the destructor, which calls the\n   *   `deregister` method on `InertManager` for each managed inert node.\n   */\n\n  var InertRoot = function () {\n    /**\n     * @param {!HTMLElement} rootElement The HTMLElement at the root of the inert subtree.\n     * @param {!InertManager} inertManager The global singleton InertManager object.\n     */\n    function InertRoot(rootElement, inertManager) {\n      _classCallCheck(this, InertRoot);\n\n      /** @type {!InertManager} */\n      this._inertManager = inertManager;\n\n      /** @type {!HTMLElement} */\n      this._rootElement = rootElement;\n\n      /**\n       * @type {!Set<!InertNode>}\n       * All managed focusable nodes in this InertRoot's subtree.\n       */\n      this._managedNodes = new Set();\n\n      // Make the subtree hidden from assistive technology\n      if (this._rootElement.hasAttribute('aria-hidden')) {\n        /** @type {?string} */\n        this._savedAriaHidden = this._rootElement.getAttribute('aria-hidden');\n      } else {\n        this._savedAriaHidden = null;\n      }\n      this._rootElement.setAttribute('aria-hidden', 'true');\n\n      // Make all focusable elements in the subtree unfocusable and add them to _managedNodes\n      this._makeSubtreeUnfocusable(this._rootElement);\n\n      // Watch for:\n      // - any additions in the subtree: make them unfocusable too\n      // - any removals from the subtree: remove them from this inert root's managed nodes\n      // - attribute changes: if `tabindex` is added, or removed from an intrinsically focusable\n      //   element, make that node a managed node.\n      this._observer = new MutationObserver(this._onMutation.bind(this));\n      this._observer.observe(this._rootElement, { attributes: true, childList: true, subtree: true });\n    }\n\n    /**\n     * Call this whenever this object is about to become obsolete.  This unwinds all of the state\n     * stored in this object and updates the state of all of the managed nodes.\n     */\n\n\n    _createClass(InertRoot, [{\n      key: 'destructor',\n      value: function destructor() {\n        this._observer.disconnect();\n\n        if (this._rootElement) {\n          if (this._savedAriaHidden !== null) {\n            this._rootElement.setAttribute('aria-hidden', this._savedAriaHidden);\n          } else {\n            this._rootElement.removeAttribute('aria-hidden');\n          }\n        }\n\n        this._managedNodes.forEach(function (inertNode) {\n          this._unmanageNode(inertNode.node);\n        }, this);\n\n        // Note we cast the nulls to the ANY type here because:\n        // 1) We want the class properties to be declared as non-null, or else we\n        //    need even more casts throughout this code. All bets are off if an\n        //    instance has been destroyed and a method is called.\n        // 2) We don't want to cast \"this\", because we want type-aware optimizations\n        //    to know which properties we're setting.\n        this._observer = /** @type {?} */null;\n        this._rootElement = /** @type {?} */null;\n        this._managedNodes = /** @type {?} */null;\n        this._inertManager = /** @type {?} */null;\n      }\n\n      /**\n       * @return {!Set<!InertNode>} A copy of this InertRoot's managed nodes set.\n       */\n\n    }, {\n      key: '_makeSubtreeUnfocusable',\n\n\n      /**\n       * @param {!Node} startNode\n       */\n      value: function _makeSubtreeUnfocusable(startNode) {\n        var _this2 = this;\n\n        composedTreeWalk(startNode, function (node) {\n          return _this2._visitNode(node);\n        });\n\n        var activeElement = document.activeElement;\n\n        if (!document.body.contains(startNode)) {\n          // startNode may be in shadow DOM, so find its nearest shadowRoot to get the activeElement.\n          var node = startNode;\n          /** @type {!ShadowRoot|undefined} */\n          var root = undefined;\n          while (node) {\n            if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n              root = /** @type {!ShadowRoot} */node;\n              break;\n            }\n            node = node.parentNode;\n          }\n          if (root) {\n            activeElement = root.activeElement;\n          }\n        }\n        if (startNode.contains(activeElement)) {\n          activeElement.blur();\n          // In IE11, if an element is already focused, and then set to tabindex=-1\n          // calling blur() will not actually move the focus.\n          // To work around this we call focus() on the body instead.\n          if (activeElement === document.activeElement) {\n            document.body.focus();\n          }\n        }\n      }\n\n      /**\n       * @param {!Node} node\n       */\n\n    }, {\n      key: '_visitNode',\n      value: function _visitNode(node) {\n        if (node.nodeType !== Node.ELEMENT_NODE) {\n          return;\n        }\n        var element = /** @type {!HTMLElement} */node;\n\n        // If a descendant inert root becomes un-inert, its descendants will still be inert because of\n        // this inert root, so all of its managed nodes need to be adopted by this InertRoot.\n        if (element !== this._rootElement && element.hasAttribute('inert')) {\n          this._adoptInertRoot(element);\n        }\n\n        if (matches.call(element, _focusableElementsString) || element.hasAttribute('tabindex')) {\n          this._manageNode(element);\n        }\n      }\n\n      /**\n       * Register the given node with this InertRoot and with InertManager.\n       * @param {!Node} node\n       */\n\n    }, {\n      key: '_manageNode',\n      value: function _manageNode(node) {\n        var inertNode = this._inertManager.register(node, this);\n        this._managedNodes.add(inertNode);\n      }\n\n      /**\n       * Unregister the given node with this InertRoot and with InertManager.\n       * @param {!Node} node\n       */\n\n    }, {\n      key: '_unmanageNode',\n      value: function _unmanageNode(node) {\n        var inertNode = this._inertManager.deregister(node, this);\n        if (inertNode) {\n          this._managedNodes['delete'](inertNode);\n        }\n      }\n\n      /**\n       * Unregister the entire subtree starting at `startNode`.\n       * @param {!Node} startNode\n       */\n\n    }, {\n      key: '_unmanageSubtree',\n      value: function _unmanageSubtree(startNode) {\n        var _this3 = this;\n\n        composedTreeWalk(startNode, function (node) {\n          return _this3._unmanageNode(node);\n        });\n      }\n\n      /**\n       * If a descendant node is found with an `inert` attribute, adopt its managed nodes.\n       * @param {!HTMLElement} node\n       */\n\n    }, {\n      key: '_adoptInertRoot',\n      value: function _adoptInertRoot(node) {\n        var inertSubroot = this._inertManager.getInertRoot(node);\n\n        // During initialisation this inert root may not have been registered yet,\n        // so register it now if need be.\n        if (!inertSubroot) {\n          this._inertManager.setInert(node, true);\n          inertSubroot = this._inertManager.getInertRoot(node);\n        }\n\n        inertSubroot.managedNodes.forEach(function (savedInertNode) {\n          this._manageNode(savedInertNode.node);\n        }, this);\n      }\n\n      /**\n       * Callback used when mutation observer detects subtree additions, removals, or attribute changes.\n       * @param {!Array<!MutationRecord>} records\n       * @param {!MutationObserver} self\n       */\n\n    }, {\n      key: '_onMutation',\n      value: function _onMutation(records, self) {\n        records.forEach(function (record) {\n          var target = /** @type {!HTMLElement} */record.target;\n          if (record.type === 'childList') {\n            // Manage added nodes\n            slice.call(record.addedNodes).forEach(function (node) {\n              this._makeSubtreeUnfocusable(node);\n            }, this);\n\n            // Un-manage removed nodes\n            slice.call(record.removedNodes).forEach(function (node) {\n              this._unmanageSubtree(node);\n            }, this);\n          } else if (record.type === 'attributes') {\n            if (record.attributeName === 'tabindex') {\n              // Re-initialise inert node if tabindex changes\n              this._manageNode(target);\n            } else if (target !== this._rootElement && record.attributeName === 'inert' && target.hasAttribute('inert')) {\n              // If a new inert root is added, adopt its managed nodes and make sure it knows about the\n              // already managed nodes from this inert subroot.\n              this._adoptInertRoot(target);\n              var inertSubroot = this._inertManager.getInertRoot(target);\n              this._managedNodes.forEach(function (managedNode) {\n                if (target.contains(managedNode.node)) {\n                  inertSubroot._manageNode(managedNode.node);\n                }\n              });\n            }\n          }\n        }, this);\n      }\n    }, {\n      key: 'managedNodes',\n      get: function get() {\n        return new Set(this._managedNodes);\n      }\n\n      /** @return {boolean} */\n\n    }, {\n      key: 'hasSavedAriaHidden',\n      get: function get() {\n        return this._savedAriaHidden !== null;\n      }\n\n      /** @param {?string} ariaHidden */\n\n    }, {\n      key: 'savedAriaHidden',\n      set: function set(ariaHidden) {\n        this._savedAriaHidden = ariaHidden;\n      }\n\n      /** @return {?string} */\n      ,\n      get: function get() {\n        return this._savedAriaHidden;\n      }\n    }]);\n\n    return InertRoot;\n  }();\n\n  /**\n   * `InertNode` initialises and manages a single inert node.\n   * A node is inert if it is a descendant of one or more inert root elements.\n   *\n   * On construction, `InertNode` saves the existing `tabindex` value for the node, if any, and\n   * either removes the `tabindex` attribute or sets it to `-1`, depending on whether the element\n   * is intrinsically focusable or not.\n   *\n   * `InertNode` maintains a set of `InertRoot`s which are descendants of this `InertNode`. When an\n   * `InertRoot` is destroyed, and calls `InertManager.deregister()`, the `InertManager` notifies the\n   * `InertNode` via `removeInertRoot()`, which in turn destroys the `InertNode` if no `InertRoot`s\n   * remain in the set. On destruction, `InertNode` reinstates the stored `tabindex` if one exists,\n   * or removes the `tabindex` attribute if the element is intrinsically focusable.\n   */\n\n\n  var InertNode = function () {\n    /**\n     * @param {!Node} node A focusable element to be made inert.\n     * @param {!InertRoot} inertRoot The inert root element associated with this inert node.\n     */\n    function InertNode(node, inertRoot) {\n      _classCallCheck(this, InertNode);\n\n      /** @type {!Node} */\n      this._node = node;\n\n      /** @type {boolean} */\n      this._overrodeFocusMethod = false;\n\n      /**\n       * @type {!Set<!InertRoot>} The set of descendant inert roots.\n       *    If and only if this set becomes empty, this node is no longer inert.\n       */\n      this._inertRoots = new Set([inertRoot]);\n\n      /** @type {?number} */\n      this._savedTabIndex = null;\n\n      /** @type {boolean} */\n      this._destroyed = false;\n\n      // Save any prior tabindex info and make this node untabbable\n      this.ensureUntabbable();\n    }\n\n    /**\n     * Call this whenever this object is about to become obsolete.\n     * This makes the managed node focusable again and deletes all of the previously stored state.\n     */\n\n\n    _createClass(InertNode, [{\n      key: 'destructor',\n      value: function destructor() {\n        this._throwIfDestroyed();\n\n        if (this._node && this._node.nodeType === Node.ELEMENT_NODE) {\n          var element = /** @type {!HTMLElement} */this._node;\n          if (this._savedTabIndex !== null) {\n            element.setAttribute('tabindex', this._savedTabIndex);\n          } else {\n            element.removeAttribute('tabindex');\n          }\n\n          // Use `delete` to restore native focus method.\n          if (this._overrodeFocusMethod) {\n            delete element.focus;\n          }\n        }\n\n        // See note in InertRoot.destructor for why we cast these nulls to ANY.\n        this._node = /** @type {?} */null;\n        this._inertRoots = /** @type {?} */null;\n        this._destroyed = true;\n      }\n\n      /**\n       * @type {boolean} Whether this object is obsolete because the managed node is no longer inert.\n       * If the object has been destroyed, any attempt to access it will cause an exception.\n       */\n\n    }, {\n      key: '_throwIfDestroyed',\n\n\n      /**\n       * Throw if user tries to access destroyed InertNode.\n       */\n      value: function _throwIfDestroyed() {\n        if (this.destroyed) {\n          throw new Error('Trying to access destroyed InertNode');\n        }\n      }\n\n      /** @return {boolean} */\n\n    }, {\n      key: 'ensureUntabbable',\n\n\n      /** Save the existing tabindex value and make the node untabbable and unfocusable */\n      value: function ensureUntabbable() {\n        if (this.node.nodeType !== Node.ELEMENT_NODE) {\n          return;\n        }\n        var element = /** @type {!HTMLElement} */this.node;\n        if (matches.call(element, _focusableElementsString)) {\n          if ( /** @type {!HTMLElement} */element.tabIndex === -1 && this.hasSavedTabIndex) {\n            return;\n          }\n\n          if (element.hasAttribute('tabindex')) {\n            this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex;\n          }\n          element.setAttribute('tabindex', '-1');\n          if (element.nodeType === Node.ELEMENT_NODE) {\n            element.focus = function () {};\n            this._overrodeFocusMethod = true;\n          }\n        } else if (element.hasAttribute('tabindex')) {\n          this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex;\n          element.removeAttribute('tabindex');\n        }\n      }\n\n      /**\n       * Add another inert root to this inert node's set of managing inert roots.\n       * @param {!InertRoot} inertRoot\n       */\n\n    }, {\n      key: 'addInertRoot',\n      value: function addInertRoot(inertRoot) {\n        this._throwIfDestroyed();\n        this._inertRoots.add(inertRoot);\n      }\n\n      /**\n       * Remove the given inert root from this inert node's set of managing inert roots.\n       * If the set of managing inert roots becomes empty, this node is no longer inert,\n       * so the object should be destroyed.\n       * @param {!InertRoot} inertRoot\n       */\n\n    }, {\n      key: 'removeInertRoot',\n      value: function removeInertRoot(inertRoot) {\n        this._throwIfDestroyed();\n        this._inertRoots['delete'](inertRoot);\n        if (this._inertRoots.size === 0) {\n          this.destructor();\n        }\n      }\n    }, {\n      key: 'destroyed',\n      get: function get() {\n        return (/** @type {!InertNode} */this._destroyed\n        );\n      }\n    }, {\n      key: 'hasSavedTabIndex',\n      get: function get() {\n        return this._savedTabIndex !== null;\n      }\n\n      /** @return {!Node} */\n\n    }, {\n      key: 'node',\n      get: function get() {\n        this._throwIfDestroyed();\n        return this._node;\n      }\n\n      /** @param {?number} tabIndex */\n\n    }, {\n      key: 'savedTabIndex',\n      set: function set(tabIndex) {\n        this._throwIfDestroyed();\n        this._savedTabIndex = tabIndex;\n      }\n\n      /** @return {?number} */\n      ,\n      get: function get() {\n        this._throwIfDestroyed();\n        return this._savedTabIndex;\n      }\n    }]);\n\n    return InertNode;\n  }();\n\n  /**\n   * InertManager is a per-document singleton object which manages all inert roots and nodes.\n   *\n   * When an element becomes an inert root by having an `inert` attribute set and/or its `inert`\n   * property set to `true`, the `setInert` method creates an `InertRoot` object for the element.\n   * The `InertRoot` in turn registers itself as managing all of the element's focusable descendant\n   * nodes via the `register()` method. The `InertManager` ensures that a single `InertNode` instance\n   * is created for each such node, via the `_managedNodes` map.\n   */\n\n\n  var InertManager = function () {\n    /**\n     * @param {!Document} document\n     */\n    function InertManager(document) {\n      _classCallCheck(this, InertManager);\n\n      if (!document) {\n        throw new Error('Missing required argument; InertManager needs to wrap a document.');\n      }\n\n      /** @type {!Document} */\n      this._document = document;\n\n      /**\n       * All managed nodes known to this InertManager. In a map to allow looking up by Node.\n       * @type {!Map<!Node, !InertNode>}\n       */\n      this._managedNodes = new Map();\n\n      /**\n       * All inert roots known to this InertManager. In a map to allow looking up by Node.\n       * @type {!Map<!Node, !InertRoot>}\n       */\n      this._inertRoots = new Map();\n\n      /**\n       * Observer for mutations on `document.body`.\n       * @type {!MutationObserver}\n       */\n      this._observer = new MutationObserver(this._watchForInert.bind(this));\n\n      // Add inert style.\n      addInertStyle(document.head || document.body || document.documentElement);\n\n      // Wait for document to be loaded.\n      if (document.readyState === 'loading') {\n        document.addEventListener('DOMContentLoaded', this._onDocumentLoaded.bind(this));\n      } else {\n        this._onDocumentLoaded();\n      }\n    }\n\n    /**\n     * Set whether the given element should be an inert root or not.\n     * @param {!HTMLElement} root\n     * @param {boolean} inert\n     */\n\n\n    _createClass(InertManager, [{\n      key: 'setInert',\n      value: function setInert(root, inert) {\n        if (inert) {\n          if (this._inertRoots.has(root)) {\n            // element is already inert\n            return;\n          }\n\n          var inertRoot = new InertRoot(root, this);\n          root.setAttribute('inert', '');\n          this._inertRoots.set(root, inertRoot);\n          // If not contained in the document, it must be in a shadowRoot.\n          // Ensure inert styles are added there.\n          if (!this._document.body.contains(root)) {\n            var parent = root.parentNode;\n            while (parent) {\n              if (parent.nodeType === 11) {\n                addInertStyle(parent);\n              }\n              parent = parent.parentNode;\n            }\n          }\n        } else {\n          if (!this._inertRoots.has(root)) {\n            // element is already non-inert\n            return;\n          }\n\n          var _inertRoot = this._inertRoots.get(root);\n          _inertRoot.destructor();\n          this._inertRoots['delete'](root);\n          root.removeAttribute('inert');\n        }\n      }\n\n      /**\n       * Get the InertRoot object corresponding to the given inert root element, if any.\n       * @param {!Node} element\n       * @return {!InertRoot|undefined}\n       */\n\n    }, {\n      key: 'getInertRoot',\n      value: function getInertRoot(element) {\n        return this._inertRoots.get(element);\n      }\n\n      /**\n       * Register the given InertRoot as managing the given node.\n       * In the case where the node has a previously existing inert root, this inert root will\n       * be added to its set of inert roots.\n       * @param {!Node} node\n       * @param {!InertRoot} inertRoot\n       * @return {!InertNode} inertNode\n       */\n\n    }, {\n      key: 'register',\n      value: function register(node, inertRoot) {\n        var inertNode = this._managedNodes.get(node);\n        if (inertNode !== undefined) {\n          // node was already in an inert subtree\n          inertNode.addInertRoot(inertRoot);\n        } else {\n          inertNode = new InertNode(node, inertRoot);\n        }\n\n        this._managedNodes.set(node, inertNode);\n\n        return inertNode;\n      }\n\n      /**\n       * De-register the given InertRoot as managing the given inert node.\n       * Removes the inert root from the InertNode's set of managing inert roots, and remove the inert\n       * node from the InertManager's set of managed nodes if it is destroyed.\n       * If the node is not currently managed, this is essentially a no-op.\n       * @param {!Node} node\n       * @param {!InertRoot} inertRoot\n       * @return {?InertNode} The potentially destroyed InertNode associated with this node, if any.\n       */\n\n    }, {\n      key: 'deregister',\n      value: function deregister(node, inertRoot) {\n        var inertNode = this._managedNodes.get(node);\n        if (!inertNode) {\n          return null;\n        }\n\n        inertNode.removeInertRoot(inertRoot);\n        if (inertNode.destroyed) {\n          this._managedNodes['delete'](node);\n        }\n\n        return inertNode;\n      }\n\n      /**\n       * Callback used when document has finished loading.\n       */\n\n    }, {\n      key: '_onDocumentLoaded',\n      value: function _onDocumentLoaded() {\n        // Find all inert roots in document and make them actually inert.\n        var inertElements = slice.call(this._document.querySelectorAll('[inert]'));\n        inertElements.forEach(function (inertElement) {\n          this.setInert(inertElement, true);\n        }, this);\n\n        // Comment this out to use programmatic API only.\n        this._observer.observe(this._document.body || this._document.documentElement, { attributes: true, subtree: true, childList: true });\n      }\n\n      /**\n       * Callback used when mutation observer detects attribute changes.\n       * @param {!Array<!MutationRecord>} records\n       * @param {!MutationObserver} self\n       */\n\n    }, {\n      key: '_watchForInert',\n      value: function _watchForInert(records, self) {\n        var _this = this;\n        records.forEach(function (record) {\n          switch (record.type) {\n            case 'childList':\n              slice.call(record.addedNodes).forEach(function (node) {\n                if (node.nodeType !== Node.ELEMENT_NODE) {\n                  return;\n                }\n                var inertElements = slice.call(node.querySelectorAll('[inert]'));\n                if (matches.call(node, '[inert]')) {\n                  inertElements.unshift(node);\n                }\n                inertElements.forEach(function (inertElement) {\n                  this.setInert(inertElement, true);\n                }, _this);\n              }, _this);\n              break;\n            case 'attributes':\n              if (record.attributeName !== 'inert') {\n                return;\n              }\n              var target = /** @type {!HTMLElement} */record.target;\n              var inert = target.hasAttribute('inert');\n              _this.setInert(target, inert);\n              break;\n          }\n        }, this);\n      }\n    }]);\n\n    return InertManager;\n  }();\n\n  /**\n   * Recursively walk the composed tree from |node|.\n   * @param {!Node} node\n   * @param {(function (!HTMLElement))=} callback Callback to be called for each element traversed,\n   *     before descending into child nodes.\n   * @param {?ShadowRoot=} shadowRootAncestor The nearest ShadowRoot ancestor, if any.\n   */\n\n\n  function composedTreeWalk(node, callback, shadowRootAncestor) {\n    if (node.nodeType == Node.ELEMENT_NODE) {\n      var element = /** @type {!HTMLElement} */node;\n      if (callback) {\n        callback(element);\n      }\n\n      // Descend into node:\n      // If it has a ShadowRoot, ignore all child elements - these will be picked\n      // up by the <content> or <shadow> elements. Descend straight into the\n      // ShadowRoot.\n      var shadowRoot = /** @type {!HTMLElement} */element.shadowRoot;\n      if (shadowRoot) {\n        composedTreeWalk(shadowRoot, callback, shadowRoot);\n        return;\n      }\n\n      // If it is a <content> element, descend into distributed elements - these\n      // are elements from outside the shadow root which are rendered inside the\n      // shadow DOM.\n      if (element.localName == 'content') {\n        var content = /** @type {!HTMLContentElement} */element;\n        // Verifies if ShadowDom v0 is supported.\n        var distributedNodes = content.getDistributedNodes ? content.getDistributedNodes() : [];\n        for (var i = 0; i < distributedNodes.length; i++) {\n          composedTreeWalk(distributedNodes[i], callback, shadowRootAncestor);\n        }\n        return;\n      }\n\n      // If it is a <slot> element, descend into assigned nodes - these\n      // are elements from outside the shadow root which are rendered inside the\n      // shadow DOM.\n      if (element.localName == 'slot') {\n        var slot = /** @type {!HTMLSlotElement} */element;\n        // Verify if ShadowDom v1 is supported.\n        var _distributedNodes = slot.assignedNodes ? slot.assignedNodes({ flatten: true }) : [];\n        for (var _i = 0; _i < _distributedNodes.length; _i++) {\n          composedTreeWalk(_distributedNodes[_i], callback, shadowRootAncestor);\n        }\n        return;\n      }\n    }\n\n    // If it is neither the parent of a ShadowRoot, a <content> element, a <slot>\n    // element, nor a <shadow> element recurse normally.\n    var child = node.firstChild;\n    while (child != null) {\n      composedTreeWalk(child, callback, shadowRootAncestor);\n      child = child.nextSibling;\n    }\n  }\n\n  /**\n   * Adds a style element to the node containing the inert specific styles\n   * @param {!Node} node\n   */\n  function addInertStyle(node) {\n    if (node.querySelector('style#inert-style, link#inert-style')) {\n      return;\n    }\n    var style = document.createElement('style');\n    style.setAttribute('id', 'inert-style');\n    style.textContent = '\\n' + '[inert] {\\n' + '  pointer-events: none;\\n' + '  cursor: default;\\n' + '}\\n' + '\\n' + '[inert], [inert] * {\\n' + '  -webkit-user-select: none;\\n' + '  -moz-user-select: none;\\n' + '  -ms-user-select: none;\\n' + '  user-select: none;\\n' + '}\\n';\n    node.appendChild(style);\n  }\n\n  if (!HTMLElement.prototype.hasOwnProperty('inert')) {\n    /** @type {!InertManager} */\n    var inertManager = new InertManager(document);\n\n    Object.defineProperty(HTMLElement.prototype, 'inert', {\n      enumerable: true,\n      /** @this {!HTMLElement} */\n      get: function get() {\n        return this.hasAttribute('inert');\n      },\n      /** @this {!HTMLElement} */\n      set: function set(inert) {\n        inertManager.setInert(this, inert);\n      }\n    });\n  }\n})();\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n  return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose;\n    if (async) {\n        if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n        dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n        if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n        dispose = value[Symbol.dispose];\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n      }\n      catch (e) {\n          fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n};\n"],"names":["window","JSCompiler_renameProperty","prop","_obj","defaultConverter","toAttribute","value","type","Boolean","Object","Array","JSON","stringify","fromAttribute","Number","parse","notEqual","old","defaultPropertyDeclaration","attribute","String","converter","reflect","hasChanged","finalized","UpdatingElement","HTMLElement","constructor","super","this","initialize","observedAttributes","finalize","attributes","_classProperties","forEach","v","p","attr","_attributeNameForProperty","_attributeToPropertyMap","set","push","_ensureClassProperties","hasOwnProperty","Map","superProperties","getPrototypeOf","k","createProperty","name","options","noAccessor","prototype","key","Symbol","descriptor","getPropertyDescriptor","defineProperty","get","oldValue","requestUpdateInternal","configurable","enumerable","getPropertyOptions","superCtor","props","properties","propKeys","getOwnPropertyNames","getOwnPropertySymbols","toLowerCase","_valueHasChanged","_propertyValueFromAttribute","_propertyValueToAttribute","_updateState","_updatePromise","Promise","res","_enableUpdatingResolver","_changedProperties","_saveInstanceProperties","_v","_instanceProperties","_applyInstanceProperties","connectedCallback","enableUpdating","disconnectedCallback","attributeChangedCallback","_attributeToProperty","_propertyToAttribute","ctor","attrValue","removeAttribute","setAttribute","propName","shouldRequestUpdate","has","_reflectingProperties","_hasRequestedUpdate","_enqueueUpdate","requestUpdate","updateComplete","e","result","performUpdate","hasUpdated","shouldUpdate","changedProperties","update","_markUpdated","firstUpdated","updated","_getUpdateComplete","size","standardProperty","element","kind","assign","finisher","clazz","placement","initializer","call","property","protoOrDescriptor","proto","legacyProperty","query","selector","cache","renderRoot","querySelector","legacyQuery","standardQuery","ElementProto","Element","msMatchesSelector","webkitMatchesSelector","supportsAdoptingStyleSheets","ShadowRoot","ShadyCSS","nativeShadow","Document","CSSStyleSheet","constructionToken","CSSResult","cssText","safeToken","Error","styleSheet","_styleSheet","replaceSync","toString","renderNotImplemented","LitElement","getStyles","styles","_getUniqueStyles","userStyles","isArray","addStyles","reduceRight","s","add","Set","unshift","_styles","map","slice","cssRules","reduce","css","rule","createRenderRoot","adoptStyles","attachShadow","mode","length","adoptedStyleSheets","_needsShimAdoptedStyleSheets","ScopingShim","prepareAdoptedCssText","localName","styleElement","templateResult","render","scopeName","eventContext","style","document","createElement","textContent","appendChild","AnimationKeys","cssClasses","CLOSING","OPEN","OPENING","SCROLLABLE","SCROLL_LOCK","STACKED","FULLSCREEN","SCROLL_DIVIDER_HEADER","SCROLL_DIVIDER_FOOTER","SURFACE_SCRIM_SHOWN","SURFACE_SCRIM_SHOWING","SURFACE_SCRIM_HIDING","SCRIM_HIDDEN","strings","ACTION_ATTRIBUTE","BUTTON_DEFAULT_ATTRIBUTE","BUTTON_SELECTOR","CLOSED_EVENT","CLOSE_ACTION","CLOSING_EVENT","CONTAINER_SELECTOR","CONTENT_SELECTOR","DESTROY_ACTION","INITIAL_FOCUS_ATTRIBUTE","OPENED_EVENT","OPENING_EVENT","SCRIM_SELECTOR","SUPPRESS_DEFAULT_PRESS_SELECTOR","join","SURFACE_SELECTOR","numbers","DIALOG_ANIMATION_CLOSE_TIME_MS","DIALOG_ANIMATION_OPEN_TIME_MS","AnimationFrame","rafIDs","request","callback","_this","cancel","frameID","requestAnimationFrame","frame","delete","rafID","cancelAnimationFrame","cancelAll","_","getQueue","queue","MDCFoundation","adapter","init","destroy","_super","MDCDialogFoundation","defaultAdapter","dialogOpen","isFullscreen","animationFrame","animationTimer","escapeKeyAction","scrimClickAction","autoStackButtons","areButtonsStacked","suppressDefaultPressSelector","animFrame","contentScrollHandler","handleScrollEvent","windowResizeHandler","layout","windowOrientationChangeHandler","addBodyClass","addClass","clickDefaultButton","eventTargetMatches","getActionFromEvent","getInitialFocusEl","hasClass","isContentScrollable","notifyClosed","notifyClosing","notifyOpened","notifyOpening","releaseFocus","removeBodyClass","removeClass","reverseButtons","trapFocus","registerContentEventHandler","deregisterContentEventHandler","isScrollableContentAtTop","isScrollableContentAtBottom","registerWindowEventHandler","deregisterWindowEventHandler","setAutoStackButtons","clearTimeout","handleAnimationTimerEnd","open","dialogOptions","isAboveFullscreenDialog","runNextAnimationFrame","setTimeout","close","action","showSurfaceScrim","hideSurfaceScrim","handleSurfaceScrimTransitionEnd","isOpen","getEscapeKeyAction","setEscapeKeyAction","getScrimClickAction","setScrimClickAction","getAutoStackButtons","autoStack","getSuppressDefaultPressSelector","setSuppressDefaultPressSelector","POLL_LAYOUT_CHANGE","layoutInternal","handleClick","evt","target","handleKeydown","isEnter","keyCode","composedPath","isDefault","handleDocumentKeydown","POLL_SCROLL_POS","toggleScrollDividerHeader","toggleScrollDividerFooter","detectStackedButtons","toggleScrollableClasses","applyPassive","globalObj","passiveSupported","passive","handler","addEventListener","removeEventListener","err","supportsPassiveOption","matches","supportsPassive","fn","optionsBlock","BaseElement","click","mdcRoot","focus","createFoundation","mdcFoundation","mdcFoundationClass","createAdapter","observer","_observers","observers","userUpdated","ClassList","classes","changed","classList","getAttribute","split","cls","remove","commit","classString","previousClassesCache","WeakMap","classMap","classInfo","part","committer","parts","previousClasses","blockingElements","$blockingElements","DialogBase","arguments","hideActions","stacked","heading","defaultAction","actionAttribute","initialFocusAttribute","initialSupressDefaultPressSelector","boundHandleClick","boundHandleKeydown","boundHandleDocumentKeydown","primaryButton","assignedNodes","primarySlot","filter","node","emitNotification","ev","CustomEvent","detail","dispatchEvent","initFocusSelector","lightDomQs","primaryNodes","flatten","primaryFocusElement","searchNodeTreesForAttribute","secondaryNodes","secondarySlot","secondaryFocusElement","contentNodes","contentSlot","nodes","hasAttribute","selection","className","contains","body","overflow","primary","closest","el","parentElement","contentElement","scrollHeight","offsetHeight","closingDueToDisconnect","isConnected","evtType","scrollTop","Math","ceil","clientHeight","renderHeading","actionsClasses","bind","setEventListeners","removeEventListeners","currentAction","forceLayout","initialFocusEl","blur","shadowRoot","activeEl","activeElement","root","getRootNode","show","newAction","values","acc","idx","textFromCSSResult","Dialog","tagName","classOrDescriptor","customElements","define","legacyCustomElement","elements","standardCustomElement","_a","_b","_c","_blockingElements","_alreadyInertElements","_topElParents","_siblingsToRestore","_parentMO","_topChanged","_swapInertedSibling","_inertSiblings","_restoreInertedSiblings","_getParents","_getDistributedChildren","_isInertable","_handleMutations","BlockingElementsImpl","destructor","nullable","top","elems","i","indexOf","splice","pop","newTop","toKeepInert","oldParents","clear","newParents","parentNode","toSkip","j","oldInert","newInert","siblingsToRestore","inert","disconnect","siblings","sibling","parent","children","inertedSiblings","mo","MutationObserver","parentToObserve","maybeShadyRoot","__shady","host","observe","childList","mutations","parents","mutation","inertedChild","removedNodes","console","info","addedNodes","test","current","nodeType","Node","ELEMENT_NODE","assignedSlot","slots","querySelectorAll","_createClass","defineProperties","writable","Constructor","protoProps","staticProps","_classCallCheck","instance","TypeError","_focusableElementsString","InertRoot","rootElement","inertManager","_inertManager","_rootElement","_managedNodes","_savedAriaHidden","_makeSubtreeUnfocusable","_observer","_onMutation","subtree","inertNode","_unmanageNode","startNode","_this2","composedTreeWalk","_visitNode","DOCUMENT_FRAGMENT_NODE","_adoptInertRoot","_manageNode","register","deregister","_this3","inertSubroot","getInertRoot","setInert","managedNodes","savedInertNode","records","self","record","_unmanageSubtree","attributeName","managedNode","ariaHidden","InertNode","inertRoot","_node","_overrodeFocusMethod","_inertRoots","_savedTabIndex","_destroyed","ensureUntabbable","_throwIfDestroyed","destroyed","tabIndex","hasSavedTabIndex","InertManager","_document","_watchForInert","addInertStyle","head","documentElement","readyState","_onDocumentLoaded","addInertRoot","removeInertRoot","inertElement","inertElements","shadowRootAncestor","content","distributedNodes","getDistributedNodes","slot","_distributedNodes","_i","child","firstChild","nextSibling","extendStatics","d","b","setPrototypeOf","__proto__","__extends","__","create","__assign","t","n","apply","__rest","propertyIsEnumerable","__decorate","decorators","desc","c","r","getOwnPropertyDescriptor","Reflect","decorate","__spreadArray","to","from","pack","ar","l","concat","SuppressedError"],"sourceRoot":""}