{"version":3,"file":"static/js/1575.a1f5660f.chunk.js","mappings":"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","sources":["../node_modules/@carbon/ibmdotcom-utilities/es/utilities/settings/settings.js","../node_modules/@carbon/ibmdotcom-web-components/es/globals/mixins/globals/mixins/stable-selector.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/ibmdotcom-utilities/utilities/settings/settings.js","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/decorators/globals/decorators/carbon-element.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/decorators/globals/decorators/host-listener.ts","../node_modules/lit-html/src/directives/if-defined.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/directives/globals/directives/if-non-null.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/directives/globals/directives/spread.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/mixins/globals/mixins/host-listener.ts","../node_modules/@carbon/ibmdotcom-web-components/es/internal/vendor/@carbon/web-components/globals/globals/settings.ts","../node_modules/@carbon/web-components/es/globals/wrappers/globals/wrappers/createReactCustomElementType.ts","../node_modules/@carbon/web-components/node_modules/carbon-components/es/globals/js/misc/on.js","../node_modules/@babel/runtime/helpers/interopRequireDefault.js","../node_modules/@babel/runtime/helpers/esm/decorate.js","../node_modules/@babel/runtime/helpers/esm/toArray.js","../node_modules/@babel/runtime/helpers/esm/get.js","../node_modules/@babel/runtime/helpers/esm/superPropBase.js","../node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js","../node_modules/lit-html/src/lib/modify-template.ts","../node_modules/lit-html/src/lib/shady-render.ts","../node_modules/@babel/runtime/helpers/esm/construct.js","../node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","../node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","../node_modules/lit-element/src/lib/updating-element.ts","../node_modules/lit-element/src/lib/decorators.ts","../node_modules/lit-element/src/lib/css-tag.ts","../node_modules/lit-element/src/lit-element.ts","../node_modules/lit-html/src/directives/class-map.ts","../node_modules/lit-html/src/lib/directive.ts","../node_modules/lit-html/src/lib/dom.ts","../node_modules/lit-html/src/lib/part.ts","../node_modules/lit-html/src/lib/parts.ts","../node_modules/lit-html/src/lib/render.ts","../node_modules/lit-html/src/lib/template-factory.ts","../node_modules/lit-html/src/lib/template-instance.ts","../node_modules/lit-html/src/lib/template-result.ts","../node_modules/lit-html/src/lib/template.ts","../node_modules/lit-html/src/lib/default-template-processor.ts","../node_modules/lit-html/src/lit-html.ts"],"sourcesContent":["/**\n * Copyright IBM Corp. 2020, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/**\n * Global settings\n *\n * @exports ibmdotcom.settings\n * @type {object} Settings object\n * @property {string} [prefix=dds]\n * Carbon for IBM.com v1.46.0',\n */\nvar settings = {\n  version: 'Carbon for IBM.com v1.46.0',\n  stablePrefix: 'dds'\n};\nexport default settings;","/**\n * @license\n *\n * Copyright IBM Corp. 2020, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { Constructor } from '../defs';\n\n/**\n * @param Base The base class.\n * @returns A mix-in that sets its defined stable selector.\n */\nconst StableSelectorMixin = <T extends Constructor<HTMLElement>>(Base: T) => {\n  class StableSelectorMixinImpl extends Base {\n    /**\n     * The element that will be targeted for transposition\n     *\n     * @private\n     */\n    linkNode;\n\n    /**\n     * The string array element containing the alternate attributes to target\n     *\n     * @private\n     */\n    altAttributes;\n\n    /**\n     * Mutation observer to watch for attribute changes\n     *\n     * @private\n     */\n    _mutationObserver: MutationObserver | null = null;\n\n    connectedCallback() {\n      // TS seems to miss `HTMLElement.prototype.connectedCallback()` definition\n      // @ts-ignore\n      super.connectedCallback();\n      const { stableSelector } = this\n        .constructor as typeof StableSelectorMixinImpl;\n      if (stableSelector) {\n        this.dataset.autoid = stableSelector;\n      }\n\n      this._cleanAndCreateMutationObserver({ create: true });\n      window.requestAnimationFrame(() => {\n        if (!this.linkNode) this.transposeAttributes();\n      });\n    }\n\n    disconnectedCallback() {\n      this._cleanAndCreateMutationObserver();\n    }\n\n    /**\n     * Function to transpose any data-* attributes to the anchor tag in the shadow dom.\n     *\n     * @param linkNodeArg optional argument to pass in custom element to target instead of an anchor link\n     * @param altAttributesArg optional argument to target additional attributes to transpose\n     */\n    transposeAttributes(linkNodeArg?, altAttributesArg?) {\n      this.linkNode = linkNodeArg;\n      this.altAttributes = altAttributesArg;\n      if (!this.linkNode) {\n        this.querySelectorAll('*').forEach((e) => {\n          const anchor = e.shadowRoot?.querySelector('a');\n          if (anchor) {\n            this.linkNode = anchor;\n          }\n        });\n      }\n      this.linkNode = this.linkNode || this.shadowRoot?.querySelector('a');\n      const scrapedAttributes = [].filter.call(\n        this.attributes,\n        (at) =>\n          (/^data-/.test((at as any).name) &&\n            (at as any).name !== 'data-autoid') ||\n          (this.altAttributes && this.altAttributes.includes((at as any).name))\n      );\n\n      scrapedAttributes.forEach((e) => {\n        if (this.linkNode) {\n          this.linkNode?.setAttribute((e as any).name, (e as any).value);\n        }\n      });\n    }\n\n    /**\n     * Cleans-up and creates the mutation observer.\n     *\n     * @param [options] The options.\n     * @param [options.create] `true` to create the new mutation observer.\n     */\n    _cleanAndCreateMutationObserver({ create }: { create?: boolean } = {}) {\n      if (this._mutationObserver) {\n        this._mutationObserver.disconnect();\n        this._mutationObserver = null;\n      }\n\n      if (create) {\n        const element = this;\n        this._mutationObserver = new MutationObserver((mutations) => {\n          mutations.forEach((mutation) => {\n            if (mutation.type === 'attributes') {\n              if (this.linkNode) {\n                this.transposeAttributes(this.linkNode);\n              }\n            }\n          });\n        });\n        this._mutationObserver?.observe(element, { attributes: true });\n      }\n    }\n\n    /**\n     * The stable selector for this component.\n     */\n    static stableSelector: string;\n  }\n  return StableSelectorMixinImpl;\n};\n\nexport default StableSelectorMixin;\n","/**\n * Copyright IBM Corp. 2020, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/**\n * Global settings\n *\n * @exports ibmdotcom.settings\n * @type {object} Settings object\n * @property {string} [prefix=dds]\n * Carbon for IBM.com v1.46.0',\n */\nvar settings = {\n  version: 'Carbon for IBM.com v1.46.0',\n  stablePrefix: 'dds'\n};\nexport default settings;","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2023\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/**\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/*\n * IMPORTANT: For compatibility with tsickle and the Closure Compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\n\nimport { LitElement } from 'lit-element';\n\nimport {\n  PropertyDeclaration,\n  UpdatingElement,\n} from 'lit-element/lib/updating-element';\n\nexport type Constructor<T> = {\n  // tslint:disable-next-line:no-any\n  new (...args: any[]): T;\n};\n\n// From the TC39 Decorators proposal\ninterface ClassDescriptor {\n  kind: 'class';\n  elements: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => undefined | Constructor<T>;\n}\n\n// From the TC39 Decorators proposal\ninterface ClassElement {\n  kind: 'field' | 'method';\n  key: PropertyKey;\n  placement: 'static' | 'prototype' | 'own';\n  initializer?: Function;\n  extras?: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => undefined | Constructor<T>;\n  descriptor?: PropertyDescriptor;\n}\n\nconst legacyCustomElement = (\n  tagName: string,\n  clazz: Constructor<HTMLElement>\n) => {\n  try {\n    window.customElements.define(tagName, clazz);\n  } catch (error) {\n    console.warn(`Attempting to re-define ${tagName}`);\n  }\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 as any;\n};\n\nconst standardCustomElement = (\n  tagName: string,\n  descriptor: ClassDescriptor\n) => {\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: Constructor<HTMLElement>) {\n      try {\n        window.customElements.define(tagName, clazz);\n      } catch (error) {\n        console.warn(`Attempting to re-define ${tagName}`);\n      }\n    },\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 *\n * @category Decorator\n * @param tagName The name of the custom element to define.\n */\nexport const carbonElement =\n  (tagName: string) =>\n  (classOrDescriptor: Constructor<HTMLElement> | ClassDescriptor) =>\n    typeof classOrDescriptor === 'function'\n      ? legacyCustomElement(tagName, classOrDescriptor)\n      : standardCustomElement(tagName, classOrDescriptor);\n\nconst standardProperty = (\n  options: PropertyDeclaration,\n  element: ClassElement\n) => {\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 (\n    element.kind === 'method' &&\n    element.descriptor &&\n    !('value' in element.descriptor)\n  ) {\n    return {\n      ...element,\n      finisher(clazz: typeof UpdatingElement) {\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(this: { [key: string]: unknown }) {\n        if (typeof element.initializer === 'function') {\n          this[element.key as string] = element.initializer.call(this);\n        }\n      },\n      finisher(clazz: typeof UpdatingElement) {\n        clazz.createProperty(element.key, options);\n      },\n    };\n  }\n};\n\nconst legacyProperty = (\n  options: PropertyDeclaration,\n  proto: Object,\n  name: PropertyKey\n) => {\n  (proto.constructor as typeof UpdatingElement).createProperty(name, options);\n};\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?: PropertyDeclaration) {\n  // tslint:disable-next-line:no-any decorator\n  return (protoOrDescriptor: Object | ClassElement, name?: PropertyKey): any =>\n    name !== undefined\n      ? legacyProperty(options!, protoOrDescriptor as Object, name)\n      : standardProperty(options!, protoOrDescriptor as ClassElement);\n}\n\nexport interface InternalPropertyDeclaration<Type = unknown> {\n  /**\n   * A function that indicates if a property should be considered changed when\n   * it is set. The function should take the `newValue` and `oldValue` and\n   * return `true` if an update should be requested.\n   */\n  hasChanged?(value: Type, oldValue: Type): boolean;\n}\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 the Closure Compiler.\n *\n * @category Decorator\n * @deprecated `internalProperty` has been renamed to `state` in lit-element\n *     3.0. Please update to `state` now to be compatible with 3.0.\n */\nexport function internalProperty(options?: InternalPropertyDeclaration) {\n  return property({ attribute: false, hasChanged: options?.hasChanged });\n}\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 the Closure Compiler.\n *\n * @category Decorator\n */\nexport const state = (options?: InternalPropertyDeclaration) =>\n  internalProperty(options);\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 * @see: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\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: string, cache?: boolean) {\n  return (\n    protoOrDescriptor: Object | ClassElement,\n    // tslint:disable-next-line:no-any decorator\n    name?: PropertyKey\n  ): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelector(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    if (cache) {\n      const prop =\n        name !== undefined ? name : (protoOrDescriptor as ClassElement).key;\n      const key = typeof prop === 'symbol' ? Symbol() : `__${prop}`;\n      descriptor.get = function (this: LitElement) {\n        if (\n          (this as unknown as { [key: string]: Element | null })[\n            key as string\n          ] === undefined\n        ) {\n          (this as unknown as { [key: string]: Element | null })[\n            key as string\n          ] = this.renderRoot.querySelector(selector);\n        }\n        return (this as unknown as { [key: string]: Element | null })[\n          key as string\n        ];\n      };\n    }\n    return name !== undefined\n      ? legacyQuery(descriptor, protoOrDescriptor as Object, name)\n      : standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\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 * @see: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\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: string) {\n  return (\n    protoOrDescriptor: Object | ClassElement,\n    // tslint:disable-next-line:no-any decorator\n    name?: PropertyKey\n  ): any => {\n    const descriptor = {\n      async get(this: LitElement) {\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 as Object, name)\n      : standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\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 * @see:\n * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll\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: string) {\n  return (\n    protoOrDescriptor: Object | ClassElement,\n    // tslint:disable-next-line:no-any decorator\n    name?: PropertyKey\n  ): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelectorAll(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return name !== undefined\n      ? legacyQuery(descriptor, protoOrDescriptor as Object, name)\n      : standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n\nconst legacyQuery = (\n  descriptor: PropertyDescriptor,\n  proto: Object,\n  name: PropertyKey\n) => {\n  Object.defineProperty(proto, name, descriptor);\n};\n\nconst standardQuery = (\n  descriptor: PropertyDescriptor,\n  element: ClassElement\n) => ({\n  kind: 'method',\n  placement: 'prototype',\n  key: element.key,\n  descriptor,\n});\n\nconst standardEventOptions = (\n  options: AddEventListenerOptions,\n  element: ClassElement\n) => {\n  return {\n    ...element,\n    finisher(clazz: typeof UpdatingElement) {\n      Object.assign(\n        // @ts-ignore TS2769: No overload matches this call.\n        clazz.prototype[element.key as keyof UpdatingElement],\n        options\n      );\n    },\n  };\n};\n\nconst legacyEventOptions =\n  // tslint:disable-next-line:no-any legacy decorator\n  (options: AddEventListenerOptions, proto: any, name: PropertyKey) => {\n    Object.assign(proto[name], options);\n  };\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 * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters\n * Current browsers support the `capture`, `passive`, and `once` options. See:\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: AddEventListenerOptions) {\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: Object | ClassElement, name?: string) =>\n    name !== undefined\n      ? legacyEventOptions(options, protoOrDescriptor as Object, name)\n      : standardEventOptions(\n          options,\n          protoOrDescriptor as ClassElement\n        )) as any; // tslint:disable-next-line:no-any decorator\n}\n\n// x-browser support for matches\n// tslint:disable-next-line:no-any\nconst ElementProto = Element.prototype as any;\nconst legacyMatches =\n  ElementProto.msMatchesSelector || ElementProto.webkitMatchesSelector;\n\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 * @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(\n  slotName = '',\n  flatten = false,\n  selector = ''\n) {\n  return (\n    protoOrDescriptor: Object | ClassElement,\n    // tslint:disable-next-line:no-any decorator\n    name?: PropertyKey\n  ): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        const slotSelector = `slot${\n          slotName ? `[name=${slotName}]` : ':not([name])'\n        }`;\n        const slot = this.renderRoot.querySelector(slotSelector);\n        let nodes =\n          slot && (slot as HTMLSlotElement).assignedNodes({ flatten });\n        if (nodes && selector) {\n          nodes = nodes.filter(\n            (node) =>\n              node.nodeType === Node.ELEMENT_NODE &&\n              // tslint:disable-next-line:no-any testing existence on older browsers\n              ((node as any).matches\n                ? (node as Element).matches(selector)\n                : legacyMatches.call(node as Element, selector))\n          );\n        }\n        return nodes;\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return name !== undefined\n      ? legacyQuery(descriptor, protoOrDescriptor as Object, name)\n      : standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n/**\n * Puts an event listener to an internal table for `@HostListener()`.\n *\n * @param type\n *   The event type. Can be prefixed with `document:` or `window:`.\n *   The event listener is attached to host element's owner document or its default view in such case.\n * @param options The event listener options.\n * @param Clazz The target class.\n * @param name The method name in the given target class that works as the event listener.\n */\nconst setHostListener = (\n  type: string,\n  options: boolean | AddEventListenerOptions,\n  Clazz,\n  name: string\n) => {\n  const hostListeners = Clazz._hostListeners;\n  if (!hostListeners) {\n    throw new Error(\n      'The method `@HostListener()` is defined on has to be of a class that has `HostListerMixin`.'\n    );\n  }\n  if (!hostListeners[name]) {\n    hostListeners[name] = {};\n  }\n  hostListeners[name][type] = { options };\n};\n\n/**\n * @param type\n *   The event type. Can be prefixed with `document:` or `window:`.\n *   The event listener is attached to host element's owner document or its default view in such case.\n * @param options The event listener options.\n * @param descriptor The original class element descriptor of the event listener method.\n * @returns The updated class element descriptor with `@HostListener()` decorator.\n */\nconst HostListenerStandard = (\n  type: string,\n  options: boolean | AddEventListenerOptions,\n  descriptor\n) => {\n  const { kind, key, placement } = descriptor;\n  if (\n    !(\n      (kind === 'method' && placement === 'prototype') ||\n      (kind === 'field' && placement === 'own')\n    )\n  ) {\n    throw new Error(\n      '`@HostListener()` must be defined on instance methods, but you may have defined it on static, field, etc.'\n    );\n  }\n  return {\n    ...descriptor,\n    finisher(Clazz) {\n      setHostListener(type, options, Clazz, key);\n    },\n  };\n};\n\n/**\n * A decorator to add event listener to the host element, or its `document`/`window`, of a custom element.\n * The `target` must extend `HostListenerMixin`.\n *\n * @param type\n *   The event type. Can be prefixed with `document:` or `window:`.\n *   The event listener is attached to host element's owner document or its default view in such case.\n * @param options The event listener options.\n */\nconst HostListener =\n  (type: string, options?: boolean | AddEventListenerOptions) =>\n  (targetOrDescriptor, name: string) =>\n    typeof name !== 'undefined'\n      ? setHostListener(type, options!, targetOrDescriptor.constructor, name)\n      : HostListenerStandard(type, options!, targetOrDescriptor);\n\nexport default HostListener;\n","/**\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 */\n\nimport {AttributePart, directive, Part} from '../lit-html.js';\n\nconst previousValues = new WeakMap<Part, unknown>();\n\n/**\n * For AttributeParts, sets the attribute if the value is defined and removes\n * the attribute if the value is undefined.\n *\n * For other part types, this directive is a no-op.\n */\nexport const ifDefined = directive((value: unknown) => (part: Part) => {\n  const previousValue = previousValues.get(part);\n\n  if (value === undefined && part instanceof AttributePart) {\n    // If the value is undefined, remove the attribute, but only if the value\n    // was previously defined.\n    if (previousValue !== undefined || !previousValues.has(part)) {\n      const name = part.committer.name;\n      part.committer.element.removeAttribute(name);\n    }\n  } else if (value !== previousValue) {\n    part.setValue(value);\n  }\n\n  previousValues.set(part, value);\n});\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { ifDefined } from 'lit-html/directives/if-defined';\n\n/**\n * A variant of `lit-html/directives/if-defined` which stops rendering if the given value is `null` in addition to `undefined`.\n *\n * @param The value.\n */\nexport default (value) => ifDefined(value ?? undefined);\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { Part, PropertyPart, directive } from 'lit-html';\n\nexport interface AttributesInfo {\n  readonly [name: string]: string;\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 attributesMapCache = new WeakMap();\n\n/**\n * A directive that applies attributes from a key-value pairs.\n * This must be used in the `...` name and must be the only part used in the attribute.\n * It applies the key-value pairs in the `attributesInfo` argument\n * and sets them as attribute name/value pairs.\n *\n * @param classInfo The key-value pair to be set as the attribute name/value pairs.\n */\nconst spread = directive((attributesInfo: AttributesInfo) => (part: Part) => {\n  // The first character of `...` is interpreted as one for `PropertyPart`\n  if (\n    !(part instanceof PropertyPart) ||\n    part.committer.name !== '..' ||\n    part.committer.parts.length > 1\n  ) {\n    throw new Error(\n      'The `spread` directive must be used in with `...` name and must be the only part in the attribute.'\n    );\n  }\n\n  const { committer } = part;\n  const { element } = committer;\n\n  // Removes old attributes that are no longer there\n  const oldAttributesInfo = attributesMapCache.get(part);\n  if (oldAttributesInfo) {\n    Object.keys(oldAttributesInfo).forEach((name) => {\n      if (!(name in attributesInfo)) {\n        element.removeAttribute(name);\n      }\n    });\n  }\n\n  // Adds new attributes\n  Object.keys(attributesInfo).forEach((name) => {\n    const value = attributesInfo[name];\n    if (\n      (!oldAttributesInfo || !Object.is(value, oldAttributesInfo[name])) &&\n      typeof value !== 'undefined'\n    ) {\n      element.setAttribute(name, value);\n    }\n  });\n\n  // Updates the cache\n  attributesMapCache.set(part, attributesInfo);\n});\n\nexport default spread;\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport on from 'carbon-components/es/globals/js/misc/on';\nimport Handle from '../internal/handle';\n\n/**\n * The format for the event name used by `@HostListener` decorator.\n */\nconst EVENT_NAME_FORMAT =\n  /^((document|window|parentRoot|shadowRoot):)?([\\w-]+)$/;\n\n/**\n * @param Base The base class.\n * @returns A mix-in that sets up and cleans up event listeners defined by `@HostListener` decorator.\n */\nconst HostListenerMixin = <T extends Constructor<HTMLElement>>(Base: T) => {\n  /**\n   * A mix-in class that sets up and cleans up event listeners defined by `@HostListener` decorator.\n   */\n  class HostListenerMixinImpl extends Base {\n    /**\n     * The list of handles managed by this mix-in.\n     *\n     * @private\n     */\n    _handles: Set<Handle> = new Set(); // Not using TypeScript `private` due to: microsoft/TypeScript#17744\n\n    connectedCallback() {\n      // @ts-ignore: Until `connectedCallback` is added to `HTMLElement` definition\n      super.connectedCallback();\n      const hostListeners = (this.constructor as typeof HostListenerMixinImpl)\n        ._hostListeners;\n      Object.keys(hostListeners).forEach((listenerName) => {\n        Object.keys(hostListeners[listenerName]).forEach((type) => {\n          // Parses `document:click`/`window:click` format\n          const tokens = EVENT_NAME_FORMAT.exec(type);\n          if (!tokens) {\n            throw new Error(`Could not parse the event name: ${listenerName}`);\n          }\n          const [, , targetName, unprefixedType] = tokens;\n          const target: EventTarget =\n            {\n              document: this.ownerDocument,\n              window: this.ownerDocument!.defaultView,\n              parentRoot: this.getRootNode(),\n              shadowRoot: this.shadowRoot,\n            }[targetName] || this;\n\n          const { options } = hostListeners[listenerName][type];\n\n          this._handles.add(\n            on(\n              target,\n              ((this.constructor as typeof Base)[unprefixedType] ??\n                unprefixedType) as keyof HTMLElementEventMap,\n              this[listenerName],\n              options\n            )\n          );\n        });\n      });\n    }\n\n    disconnectedCallback() {\n      this._handles.forEach((handle) => {\n        handle.release();\n        this._handles.delete(handle);\n      });\n      // @ts-ignore: Until `disconnectedCallback` is added to `HTMLElement` definition\n      super.disconnectedCallback();\n    }\n\n    /**\n     * The map, keyed by method name, of event listeners that should be attached to host element or host document.\n     *\n     * @private\n     */\n    static _hostListeners: {\n      [listenerName: string]: {\n        [type: string]: {\n          options?: boolean | AddEventListenerOptions;\n        };\n      };\n    } = {}; // Not using TypeScript `private` due to: microsoft/TypeScript#17744\n  }\n\n  return HostListenerMixinImpl;\n};\n\nexport default HostListenerMixin;\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport settings from 'carbon-components/es/globals/js/settings';\n\nconst { prefix } = settings;\n\n/**\n * A selector selecting tabbable nodes.\n * Borrowed from `carbon-angular`. tabbable === focusable.\n */\nconst selectorTabbable = `\n  a[href], area[href], input:not([disabled]):not([tabindex='-1']),\n  button:not([disabled]):not([tabindex='-1']),select:not([disabled]):not([tabindex='-1']),\n  textarea:not([disabled]):not([tabindex='-1']),\n  iframe, object, embed, *[tabindex]:not([tabindex='-1']), *[contenteditable=true],\n  ${prefix}-accordion-item,\n  ${prefix}-btn,\n  ${prefix}-breadcrumb-link,\n  ${prefix}-checkbox,\n  ${prefix}-code-snippet,\n  ${prefix}-combo-box,\n  ${prefix}-content-switcher-item,\n  ${prefix}-copy-button,\n  ${prefix}-table-header-row,\n  ${prefix}-table-row,\n  ${prefix}-table-toolbar-search,\n  ${prefix}-date-picker-input,\n  ${prefix}-dropdown,\n  ${prefix}-input,\n  ${prefix}-link,\n  ${prefix}-number-input,\n  ${prefix}-modal,\n  ${prefix}-modal-close-button,\n  ${prefix}-multi-select,\n  ${prefix}-inline-notification,\n  ${prefix}-toast-notification,\n  ${prefix}-overflow-menu,\n  ${prefix}-overflow-menu-item,\n  ${prefix}-page-sizes-select,\n  ${prefix}-pages-select,\n  ${prefix}-progress-step,\n  ${prefix}-radio-button,\n  ${prefix}-search,\n  ${prefix}-slider,\n  ${prefix}-slider-input,\n  ${prefix}-structured-list,\n  ${prefix}-tab,\n  ${prefix}-filter-tag,\n  ${prefix}-textarea,\n  ${prefix}-clickable-tile,\n  ${prefix}-expandable-tile,\n  ${prefix}-radio-tile,\n  ${prefix}-selectable-tile,\n  ${prefix}-toggle,\n  ${prefix}-tooltip,\n  ${prefix}-tooltip-definition,\n  ${prefix}-tooltip-icon,\n  ${prefix}-header-menu,\n  ${prefix}-header-menu-button,\n  ${prefix}-header-menu-item,\n  ${prefix}-header-name,\n  ${prefix}-header-nav-item,\n  ${prefix}-side-nav-link,\n  ${prefix}-side-nav-menu,\n  ${prefix}-side-nav-menu-item\n`;\n\n// Because we're going to have a bunch of exports\nexport { selectorTabbable };\n","/**\n * @license\n *\n * Copyright IBM Corp. 2019, 2022\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport React, { Component, createElement, forwardRef } from 'react';\nimport on from 'carbon-components/es/globals/js/misc/on';\nimport Handle from '../internal/handle';\n\n/**\n * A descriptor for a React event prop of a custom element.\n */\ninterface CustomElementEventDescriptor {\n  /**\n   * The event name.\n   */\n  name: string;\n\n  /**\n   * A boolean to detemine usage of capture mode or the event options.\n   */\n  options?: boolean | EventListenerOptions;\n}\n\n/**\n * A descriptor for a React prop for an attribute of a custom element.\n */\ninterface CustomElementPropDescriptor {\n  /**\n   * The attribute name for the prop.\n   */\n  attribute?: string | false;\n\n  /**\n   * The event name (or descriptor) for the prop.\n   */\n  event?: string | CustomElementEventDescriptor;\n\n  /**\n   * A function that takes a property value and returns the corresponding attribute value.\n   */\n  serialize?: (value: any) => string | void;\n}\n\n/**\n * A descriptor for a set of React props for attributes of a custom element.\n */\ninterface CustomElementPropsDescriptor {\n  [propName: string]: CustomElementPropDescriptor;\n}\n\n/**\n * React props for the component `createCustomElementType()` generates.\n */\ninterface CustomElementTypeProps {\n  /**\n   * Ordinal prop.\n   */\n  [propName: string]: any;\n\n  /**\n   * Child nodes.\n   */\n  // eslint-disable-next-line react/no-unused-prop-types\n  children?: React.ReactNode;\n}\n\n/**\n * @param refs List of React refs to merge.\n * @returns Merged React ref.\n */\nconst mergeRefs =\n  <T>(...refs: React.Ref<T>[]) =>\n  (el) => {\n    refs.forEach((ref) => {\n      // https://github.com/facebook/react/issues/13029#issuecomment-410002316\n      if (typeof ref === 'function') {\n        ref(el);\n      } else if (Object(ref) === ref) {\n        // `React.Ref.current` is read-only for regular use case, but we update it here\n        (ref as { current: T }).current = el;\n      }\n    });\n  };\n\n/**\n * @param prop A prop value.\n * @param descriptor A React prop descriptor.\n * @returns The corresponding attribute value for the given prop value.\n */\nconst convertProp = (prop: any, descriptor: CustomElementPropDescriptor) => {\n  if (!descriptor) {\n    return prop;\n  }\n  const { event, serialize } = descriptor;\n  if (event) {\n    // Events are not set as props, we use DOM `addEventListener()` instead\n    return undefined;\n  }\n  return !serialize ? prop : serialize(prop);\n};\n\n/**\n * @param props A set of React props.\n * @param descriptor A set of React prop desciptor.\n * @returns The set of React props to set to a custom element, corresponding to the given React props.\n */\nconst convertProps = (\n  props: CustomElementTypeProps,\n  descriptor: CustomElementPropsDescriptor\n) =>\n  Object.keys(props).reduce((acc, propName) => {\n    const { [propName]: descriptorItem } = descriptor;\n    const converted = convertProp(props[propName], descriptorItem);\n    const { attribute } = descriptorItem ?? {};\n    return attribute === false\n      ? acc\n      : {\n          ...acc,\n          [attribute || propName]: converted,\n        };\n  }, {});\n\n/**\n * Attaches listeners of custom events, to a custom element.\n *\n * @param elem The custom element.\n * @param descriptor An object, keyed by prop name, of data that may have custom event names.\n * @param callback A callback function that runs as the custom events fire.\n * @returns A handle that allows to release all event listeners attached.\n */\nconst attachEventListeners = (\n  elem: HTMLElement,\n  descriptor: CustomElementPropsDescriptor,\n  callback: (name: string, event: Event) => void\n): Handle => {\n  const handles = new Set<Handle>();\n  Object.keys(descriptor).forEach((propName) => {\n    if (descriptor[propName]) {\n      const { event: eventDescriptor } = descriptor[propName];\n      const name =\n        Object(eventDescriptor) !== eventDescriptor\n          ? (eventDescriptor as string)\n          : (eventDescriptor as CustomElementEventDescriptor).name;\n      const options =\n        Object(eventDescriptor) !== eventDescriptor\n          ? undefined\n          : (eventDescriptor as CustomElementEventDescriptor).options;\n      if (name) {\n        handles.add(\n          on(\n            elem,\n            name,\n            (event) => {\n              callback(propName, event);\n            },\n            options\n          )\n        );\n      }\n    }\n  });\n  return {\n    release() {\n      handles.forEach((handle) => {\n        handle.release();\n        handles.delete(handle);\n      });\n      return null;\n    },\n  };\n};\n\n/**\n * @param name The tag name of the custom element.\n * @param descriptor A descriptor for a set of React props for attributes of a custom element.\n * @returns A React component working as a wrapper for the given custom element.\n * @example\n * import { render } from 'react-dom';\n * import createCustomElementType, { booleanSerializer } from '/path/to/createCustomElementType';\n *\n * const BXDropdown = createCustomElementType('bx-dropdown', {\n *   disabled: {\n *     // Sets `disabled` attribute when the React prop value is truthy, unsets otherwise\n *     serialize: booleanSerializer,\n *   },\n *   helperText: {\n *     // Maps `helperText` React prop to `helper-text` attribute\n *     attribute: 'helper-text',\n *   },\n *   onBeforeSelect: {\n *     // Sets `onBeforeSelect` React prop value as a listener of `bx-dropdown-beingselected` custom event\n *     event: 'bx-dropdown-beingselected',\n *   },\n * });\n *\n * render(\n *   (\n *     <BXDropdown\n *       disabled={true}\n *       helperText=\"some-helper-text\"\n *       onBeforeSelect={event => { console.log('bx-dropdown-beingselected is fired!', event); }}>\n *       <bx-dropdown-item value=\"all\">Option 1</bx-dropdown-item>\n *       <bx-dropdown-item value=\"cloudFoundry\">Option 2</bx-dropdown-item>\n *       <bx-dropdown-item value=\"staging\">Option 3</bx-dropdown-item>\n *     </BXDropdown>\n *   )\n *   document.body\n * );\n */\nconst createReactCustomElementType = (\n  name: string,\n  descriptor: CustomElementPropsDescriptor\n) => {\n  /**\n   * Array of React prop names that should be mapped to DOM properties instead of attributes.\n   */\n  const nonAttributeProps = Object.keys(descriptor).filter((propName) => {\n    const { [propName]: descriptorItem } = descriptor;\n    const { attribute } = descriptorItem ?? {};\n    return attribute === false;\n  });\n\n  /**\n   * A React component working as a wrapper for the custom element.\n   */\n  class CustomElementType extends Component<CustomElementTypeProps> {\n    /**\n     * The element.\n     */\n    private _elem: HTMLElement | null = null;\n\n    /**\n     * The handle that allows to release all event listeners attached to this custom element.\n     */\n    private _eventListenersHandle: Handle | null = null;\n\n    /**\n     * The callback function that runs as the custom events fire.\n     *\n     * @param propName The React prop name associated with the event listener.\n     * @param event The event.\n     */\n    private _handleEvent = (propName: string, event: Event) => {\n      const { [propName]: listener } = this.props;\n      if (listener) {\n        listener.call(event.currentTarget, event);\n      }\n    };\n\n    /**\n     * Handles getting/losing the React `ref` object of this custom element.\n     *\n     * @param elem The custom element.\n     */\n    private _handleElemRef = (elem: HTMLElement) => {\n      this._elem = elem;\n      if (this._eventListenersHandle) {\n        this._eventListenersHandle.release();\n        this._eventListenersHandle = null;\n      }\n      if (elem) {\n        this._eventListenersHandle = attachEventListeners(\n          elem,\n          descriptor,\n          this._handleEvent\n        );\n      }\n    };\n\n    /**\n     * Reflects change in React props to DOM properties.\n     *\n     * @param prevProps The previous props.\n     */\n    updateProps(prevProps: { [key: string]: any } = {}) {\n      const { props, _elem: elem } = this;\n      nonAttributeProps.forEach((propName) => {\n        const { [propName]: prevValue } = prevProps;\n        const { [propName]: value } = props;\n        if (prevValue !== value) {\n          elem![propName] = value;\n        }\n      });\n    }\n\n    componentDidMount() {\n      this.updateProps();\n    }\n\n    componentDidUpdate(prevProps) {\n      this.updateProps(prevProps);\n    }\n\n    render() {\n      // eslint-disable-next-line react/prop-types\n      const { children, innerRef, ...props } = this.props;\n      const mergedRef = mergeRefs<HTMLElement>(innerRef, this._handleElemRef);\n      return createElement(\n        name,\n        { ref: mergedRef, ...convertProps(props, descriptor) },\n        children\n      );\n    }\n  }\n\n  return forwardRef<HTMLElement, CustomElementTypeProps>((props, ref) =>\n    createElement(CustomElementType, { ...props, innerRef: ref })\n  );\n};\n\n/**\n * @param value A React prop value.\n * @returns Serialized version of React prop value, as a boolean attribute in a custom element.\n */\nexport const booleanSerializer = (value) => (!value ? undefined : '');\n\n/**\n * @param value A React prop value.\n * @returns Serialized version of React prop value, as a number attribute in a custom element.\n */\nexport const numberSerializer = (value) =>\n  value == null ? value : String(value);\n\n/**\n * @param value A React prop value.\n * @returns Serialized version of React prop value, as a object attribute in a custom element.\n */\nexport const objectSerializer = (value) =>\n  value == null ? value : JSON.stringify(value);\n\nexport default createReactCustomElementType;\n","/**\n * Copyright IBM Corp. 2016, 2018\n *\n * This source code is licensed under the Apache-2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\nexport default function on(element) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  element.addEventListener.apply(element, args);\n  return {\n    release: function release() {\n      element.removeEventListener.apply(element, args);\n      return null;\n    }\n  };\n}","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import toArray from \"./toArray.js\";\nimport toPropertyKey from \"./toPropertyKey.js\";\nexport default function _decorate(decorators, factory, superClass, mixins) {\n  var api = _getDecoratorsApi();\n  if (mixins) {\n    for (var i = 0; i < mixins.length; i++) {\n      api = mixins[i](api);\n    }\n  }\n  var r = factory(function initialize(O) {\n    api.initializeInstanceElements(O, decorated.elements);\n  }, superClass);\n  var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);\n  api.initializeClassElements(r.F, decorated.elements);\n  return api.runClassFinishers(r.F, decorated.finishers);\n}\nfunction _getDecoratorsApi() {\n  _getDecoratorsApi = function _getDecoratorsApi() {\n    return api;\n  };\n  var api = {\n    elementsDefinitionOrder: [[\"method\"], [\"field\"]],\n    initializeInstanceElements: function initializeInstanceElements(O, elements) {\n      [\"method\", \"field\"].forEach(function (kind) {\n        elements.forEach(function (element) {\n          if (element.kind === kind && element.placement === \"own\") {\n            this.defineClassElement(O, element);\n          }\n        }, this);\n      }, this);\n    },\n    initializeClassElements: function initializeClassElements(F, elements) {\n      var proto = F.prototype;\n      [\"method\", \"field\"].forEach(function (kind) {\n        elements.forEach(function (element) {\n          var placement = element.placement;\n          if (element.kind === kind && (placement === \"static\" || placement === \"prototype\")) {\n            var receiver = placement === \"static\" ? F : proto;\n            this.defineClassElement(receiver, element);\n          }\n        }, this);\n      }, this);\n    },\n    defineClassElement: function defineClassElement(receiver, element) {\n      var descriptor = element.descriptor;\n      if (element.kind === \"field\") {\n        var initializer = element.initializer;\n        descriptor = {\n          enumerable: descriptor.enumerable,\n          writable: descriptor.writable,\n          configurable: descriptor.configurable,\n          value: initializer === void 0 ? void 0 : initializer.call(receiver)\n        };\n      }\n      Object.defineProperty(receiver, element.key, descriptor);\n    },\n    decorateClass: function decorateClass(elements, decorators) {\n      var newElements = [];\n      var finishers = [];\n      var placements = {\n        \"static\": [],\n        prototype: [],\n        own: []\n      };\n      elements.forEach(function (element) {\n        this.addElementPlacement(element, placements);\n      }, this);\n      elements.forEach(function (element) {\n        if (!_hasDecorators(element)) return newElements.push(element);\n        var elementFinishersExtras = this.decorateElement(element, placements);\n        newElements.push(elementFinishersExtras.element);\n        newElements.push.apply(newElements, elementFinishersExtras.extras);\n        finishers.push.apply(finishers, elementFinishersExtras.finishers);\n      }, this);\n      if (!decorators) {\n        return {\n          elements: newElements,\n          finishers: finishers\n        };\n      }\n      var result = this.decorateConstructor(newElements, decorators);\n      finishers.push.apply(finishers, result.finishers);\n      result.finishers = finishers;\n      return result;\n    },\n    addElementPlacement: function addElementPlacement(element, placements, silent) {\n      var keys = placements[element.placement];\n      if (!silent && keys.indexOf(element.key) !== -1) {\n        throw new TypeError(\"Duplicated element (\" + element.key + \")\");\n      }\n      keys.push(element.key);\n    },\n    decorateElement: function decorateElement(element, placements) {\n      var extras = [];\n      var finishers = [];\n      for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {\n        var keys = placements[element.placement];\n        keys.splice(keys.indexOf(element.key), 1);\n        var elementObject = this.fromElementDescriptor(element);\n        var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);\n        element = elementFinisherExtras.element;\n        this.addElementPlacement(element, placements);\n        if (elementFinisherExtras.finisher) {\n          finishers.push(elementFinisherExtras.finisher);\n        }\n        var newExtras = elementFinisherExtras.extras;\n        if (newExtras) {\n          for (var j = 0; j < newExtras.length; j++) {\n            this.addElementPlacement(newExtras[j], placements);\n          }\n          extras.push.apply(extras, newExtras);\n        }\n      }\n      return {\n        element: element,\n        finishers: finishers,\n        extras: extras\n      };\n    },\n    decorateConstructor: function decorateConstructor(elements, decorators) {\n      var finishers = [];\n      for (var i = decorators.length - 1; i >= 0; i--) {\n        var obj = this.fromClassDescriptor(elements);\n        var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj);\n        if (elementsAndFinisher.finisher !== undefined) {\n          finishers.push(elementsAndFinisher.finisher);\n        }\n        if (elementsAndFinisher.elements !== undefined) {\n          elements = elementsAndFinisher.elements;\n          for (var j = 0; j < elements.length - 1; j++) {\n            for (var k = j + 1; k < elements.length; k++) {\n              if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {\n                throw new TypeError(\"Duplicated element (\" + elements[j].key + \")\");\n              }\n            }\n          }\n        }\n      }\n      return {\n        elements: elements,\n        finishers: finishers\n      };\n    },\n    fromElementDescriptor: function fromElementDescriptor(element) {\n      var obj = {\n        kind: element.kind,\n        key: element.key,\n        placement: element.placement,\n        descriptor: element.descriptor\n      };\n      var desc = {\n        value: \"Descriptor\",\n        configurable: true\n      };\n      Object.defineProperty(obj, Symbol.toStringTag, desc);\n      if (element.kind === \"field\") obj.initializer = element.initializer;\n      return obj;\n    },\n    toElementDescriptors: function toElementDescriptors(elementObjects) {\n      if (elementObjects === undefined) return;\n      return toArray(elementObjects).map(function (elementObject) {\n        var element = this.toElementDescriptor(elementObject);\n        this.disallowProperty(elementObject, \"finisher\", \"An element descriptor\");\n        this.disallowProperty(elementObject, \"extras\", \"An element descriptor\");\n        return element;\n      }, this);\n    },\n    toElementDescriptor: function toElementDescriptor(elementObject) {\n      var kind = String(elementObject.kind);\n      if (kind !== \"method\" && kind !== \"field\") {\n        throw new TypeError('An element descriptor\\'s .kind property must be either \"method\" or' + ' \"field\", but a decorator created an element descriptor with' + ' .kind \"' + kind + '\"');\n      }\n      var key = toPropertyKey(elementObject.key);\n      var placement = String(elementObject.placement);\n      if (placement !== \"static\" && placement !== \"prototype\" && placement !== \"own\") {\n        throw new TypeError('An element descriptor\\'s .placement property must be one of \"static\",' + ' \"prototype\" or \"own\", but a decorator created an element descriptor' + ' with .placement \"' + placement + '\"');\n      }\n      var descriptor = elementObject.descriptor;\n      this.disallowProperty(elementObject, \"elements\", \"An element descriptor\");\n      var element = {\n        kind: kind,\n        key: key,\n        placement: placement,\n        descriptor: Object.assign({}, descriptor)\n      };\n      if (kind !== \"field\") {\n        this.disallowProperty(elementObject, \"initializer\", \"A method descriptor\");\n      } else {\n        this.disallowProperty(descriptor, \"get\", \"The property descriptor of a field descriptor\");\n        this.disallowProperty(descriptor, \"set\", \"The property descriptor of a field descriptor\");\n        this.disallowProperty(descriptor, \"value\", \"The property descriptor of a field descriptor\");\n        element.initializer = elementObject.initializer;\n      }\n      return element;\n    },\n    toElementFinisherExtras: function toElementFinisherExtras(elementObject) {\n      var element = this.toElementDescriptor(elementObject);\n      var finisher = _optionalCallableProperty(elementObject, \"finisher\");\n      var extras = this.toElementDescriptors(elementObject.extras);\n      return {\n        element: element,\n        finisher: finisher,\n        extras: extras\n      };\n    },\n    fromClassDescriptor: function fromClassDescriptor(elements) {\n      var obj = {\n        kind: \"class\",\n        elements: elements.map(this.fromElementDescriptor, this)\n      };\n      var desc = {\n        value: \"Descriptor\",\n        configurable: true\n      };\n      Object.defineProperty(obj, Symbol.toStringTag, desc);\n      return obj;\n    },\n    toClassDescriptor: function toClassDescriptor(obj) {\n      var kind = String(obj.kind);\n      if (kind !== \"class\") {\n        throw new TypeError('A class descriptor\\'s .kind property must be \"class\", but a decorator' + ' created a class descriptor with .kind \"' + kind + '\"');\n      }\n      this.disallowProperty(obj, \"key\", \"A class descriptor\");\n      this.disallowProperty(obj, \"placement\", \"A class descriptor\");\n      this.disallowProperty(obj, \"descriptor\", \"A class descriptor\");\n      this.disallowProperty(obj, \"initializer\", \"A class descriptor\");\n      this.disallowProperty(obj, \"extras\", \"A class descriptor\");\n      var finisher = _optionalCallableProperty(obj, \"finisher\");\n      var elements = this.toElementDescriptors(obj.elements);\n      return {\n        elements: elements,\n        finisher: finisher\n      };\n    },\n    runClassFinishers: function runClassFinishers(constructor, finishers) {\n      for (var i = 0; i < finishers.length; i++) {\n        var newConstructor = (0, finishers[i])(constructor);\n        if (newConstructor !== undefined) {\n          if (typeof newConstructor !== \"function\") {\n            throw new TypeError(\"Finishers must return a constructor.\");\n          }\n          constructor = newConstructor;\n        }\n      }\n      return constructor;\n    },\n    disallowProperty: function disallowProperty(obj, name, objectType) {\n      if (obj[name] !== undefined) {\n        throw new TypeError(objectType + \" can't have a .\" + name + \" property.\");\n      }\n    }\n  };\n  return api;\n}\nfunction _createElementDescriptor(def) {\n  var key = toPropertyKey(def.key);\n  var descriptor;\n  if (def.kind === \"method\") {\n    descriptor = {\n      value: def.value,\n      writable: true,\n      configurable: true,\n      enumerable: false\n    };\n  } else if (def.kind === \"get\") {\n    descriptor = {\n      get: def.value,\n      configurable: true,\n      enumerable: false\n    };\n  } else if (def.kind === \"set\") {\n    descriptor = {\n      set: def.value,\n      configurable: true,\n      enumerable: false\n    };\n  } else if (def.kind === \"field\") {\n    descriptor = {\n      configurable: true,\n      writable: true,\n      enumerable: true\n    };\n  }\n  var element = {\n    kind: def.kind === \"field\" ? \"field\" : \"method\",\n    key: key,\n    placement: def[\"static\"] ? \"static\" : def.kind === \"field\" ? \"own\" : \"prototype\",\n    descriptor: descriptor\n  };\n  if (def.decorators) element.decorators = def.decorators;\n  if (def.kind === \"field\") element.initializer = def.value;\n  return element;\n}\nfunction _coalesceGetterSetter(element, other) {\n  if (element.descriptor.get !== undefined) {\n    other.descriptor.get = element.descriptor.get;\n  } else {\n    other.descriptor.set = element.descriptor.set;\n  }\n}\nfunction _coalesceClassElements(elements) {\n  var newElements = [];\n  var isSameElement = function isSameElement(other) {\n    return other.kind === \"method\" && other.key === element.key && other.placement === element.placement;\n  };\n  for (var i = 0; i < elements.length; i++) {\n    var element = elements[i];\n    var other;\n    if (element.kind === \"method\" && (other = newElements.find(isSameElement))) {\n      if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {\n        if (_hasDecorators(element) || _hasDecorators(other)) {\n          throw new ReferenceError(\"Duplicated methods (\" + element.key + \") can't be decorated.\");\n        }\n        other.descriptor = element.descriptor;\n      } else {\n        if (_hasDecorators(element)) {\n          if (_hasDecorators(other)) {\n            throw new ReferenceError(\"Decorators can't be placed on different accessors with for \" + \"the same property (\" + element.key + \").\");\n          }\n          other.decorators = element.decorators;\n        }\n        _coalesceGetterSetter(element, other);\n      }\n    } else {\n      newElements.push(element);\n    }\n  }\n  return newElements;\n}\nfunction _hasDecorators(element) {\n  return element.decorators && element.decorators.length;\n}\nfunction _isDataDescriptor(desc) {\n  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);\n}\nfunction _optionalCallableProperty(obj, name) {\n  var value = obj[name];\n  if (value !== undefined && typeof value !== \"function\") {\n    throw new TypeError(\"Expected '\" + name + \"' to be a function\");\n  }\n  return value;\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _toArray(arr) {\n  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();\n}","import superPropBase from \"./superPropBase.js\";\nexport default function _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get.bind();\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n      return desc.value;\n    };\n  }\n  return _get.apply(this, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n  return object;\n}","export default function _taggedTemplateLiteral(strings, raw) {\n  if (!raw) {\n    raw = strings.slice(0);\n  }\n  return Object.freeze(Object.defineProperties(strings, {\n    raw: {\n      value: Object.freeze(raw)\n    }\n  }));\n}","/**\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\nimport {isTemplatePartActive, Template, TemplatePart} from './template.js';\n\nconst walkerNodeFilter = 133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */;\n\n/**\n * Removes the list of nodes from a Template safely. In addition to removing\n * nodes from the Template, the Template part indices are updated to match\n * the mutated Template DOM.\n *\n * As the template is walked the removal state is tracked and\n * part indices are adjusted as needed.\n *\n * div\n *   div#1 (remove) <-- start removing (removing node is div#1)\n *     div\n *       div#2 (remove)  <-- continue removing (removing node is still div#1)\n *         div\n * div <-- stop removing since previous sibling is the removing node (div#1,\n * removed 4 nodes)\n */\nexport function removeNodesFromTemplate(\n    template: Template, nodesToRemove: Set<Node>) {\n  const {element: {content}, parts} = template;\n  const walker =\n      document.createTreeWalker(content, walkerNodeFilter, null, false);\n  let partIndex = nextActiveIndexInTemplateParts(parts);\n  let part = parts[partIndex];\n  let nodeIndex = -1;\n  let removeCount = 0;\n  const nodesToRemoveInTemplate = [];\n  let currentRemovingNode: Node|null = null;\n  while (walker.nextNode()) {\n    nodeIndex++;\n    const node = walker.currentNode as Element;\n    // End removal if stepped past the removing node\n    if (node.previousSibling === currentRemovingNode) {\n      currentRemovingNode = null;\n    }\n    // A node to remove was found in the template\n    if (nodesToRemove.has(node)) {\n      nodesToRemoveInTemplate.push(node);\n      // Track node we're removing\n      if (currentRemovingNode === null) {\n        currentRemovingNode = node;\n      }\n    }\n    // When removing, increment count by which to adjust subsequent part indices\n    if (currentRemovingNode !== null) {\n      removeCount++;\n    }\n    while (part !== undefined && part.index === nodeIndex) {\n      // If part is in a removed node deactivate it by setting index to -1 or\n      // adjust the index as needed.\n      part.index = currentRemovingNode !== null ? -1 : part.index - removeCount;\n      // go to the next active part.\n      partIndex = nextActiveIndexInTemplateParts(parts, partIndex);\n      part = parts[partIndex];\n    }\n  }\n  nodesToRemoveInTemplate.forEach((n) => n.parentNode!.removeChild(n));\n}\n\nconst countNodes = (node: Node) => {\n  let count = (node.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */) ? 0 : 1;\n  const walker = document.createTreeWalker(node, walkerNodeFilter, null, false);\n  while (walker.nextNode()) {\n    count++;\n  }\n  return count;\n};\n\nconst nextActiveIndexInTemplateParts =\n    (parts: TemplatePart[], startIndex = -1) => {\n      for (let i = startIndex + 1; i < parts.length; i++) {\n        const part = parts[i];\n        if (isTemplatePartActive(part)) {\n          return i;\n        }\n      }\n      return -1;\n    };\n\n/**\n * Inserts the given node into the Template, optionally before the given\n * refNode. In addition to inserting the node into the Template, the Template\n * part indices are updated to match the mutated Template DOM.\n */\nexport function insertNodeIntoTemplate(\n    template: Template, node: Node, refNode: Node|null = null) {\n  const {element: {content}, parts} = template;\n  // If there's no refNode, then put node at end of template.\n  // No part indices need to be shifted in this case.\n  if (refNode === null || refNode === undefined) {\n    content.appendChild(node);\n    return;\n  }\n  const walker =\n      document.createTreeWalker(content, walkerNodeFilter, null, false);\n  let partIndex = nextActiveIndexInTemplateParts(parts);\n  let insertCount = 0;\n  let walkerIndex = -1;\n  while (walker.nextNode()) {\n    walkerIndex++;\n    const walkerNode = walker.currentNode as Element;\n    if (walkerNode === refNode) {\n      insertCount = countNodes(node);\n      refNode.parentNode!.insertBefore(node, refNode);\n    }\n    while (partIndex !== -1 && parts[partIndex].index === walkerIndex) {\n      // If we've inserted the node, simply adjust all subsequent parts\n      if (insertCount > 0) {\n        while (partIndex !== -1) {\n          parts[partIndex].index += insertCount;\n          partIndex = nextActiveIndexInTemplateParts(parts, partIndex);\n        }\n        return;\n      }\n      partIndex = nextActiveIndexInTemplateParts(parts, partIndex);\n    }\n  }\n}\n","/**\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/**\n * Module to add shady DOM/shady CSS polyfill support to lit-html template\n * rendering. See the [[render]] method for details.\n *\n * @packageDocumentation\n */\n\n/**\n * Do not remove this comment; it keeps typedoc from misplacing the module\n * docs.\n */\nimport {removeNodes} from './dom.js';\nimport {insertNodeIntoTemplate, removeNodesFromTemplate} from './modify-template.js';\nimport {RenderOptions} from './render-options.js';\nimport {parts, render as litRender} from './render.js';\nimport {templateCaches} from './template-factory.js';\nimport {TemplateInstance} from './template-instance.js';\nimport {TemplateResult} from './template-result.js';\nimport {marker, Template} from './template.js';\n\nexport {html, svg, TemplateResult} from '../lit-html.js';\n\n// Get a key to lookup in `templateCaches`.\nconst getTemplateCacheKey = (type: string, scopeName: string) =>\n    `${type}--${scopeName}`;\n\nlet compatibleShadyCSSVersion = true;\n\nif (typeof window.ShadyCSS === 'undefined') {\n  compatibleShadyCSSVersion = false;\n} else if (typeof window.ShadyCSS.prepareTemplateDom === 'undefined') {\n  console.warn(\n      `Incompatible ShadyCSS version detected. ` +\n      `Please update to at least @webcomponents/webcomponentsjs@2.0.2 and ` +\n      `@webcomponents/shadycss@1.3.1.`);\n  compatibleShadyCSSVersion = false;\n}\n\n/**\n * Template factory which scopes template DOM using ShadyCSS.\n * @param scopeName {string}\n */\nexport const shadyTemplateFactory = (scopeName: string) =>\n    (result: TemplateResult) => {\n      const cacheKey = getTemplateCacheKey(result.type, scopeName);\n      let templateCache = templateCaches.get(cacheKey);\n      if (templateCache === undefined) {\n        templateCache = {\n          stringsArray: new WeakMap<TemplateStringsArray, Template>(),\n          keyString: new Map<string, Template>()\n        };\n        templateCaches.set(cacheKey, templateCache);\n      }\n\n      let template = templateCache.stringsArray.get(result.strings);\n      if (template !== undefined) {\n        return template;\n      }\n\n      const key = result.strings.join(marker);\n      template = templateCache.keyString.get(key);\n      if (template === undefined) {\n        const element = result.getTemplateElement();\n        if (compatibleShadyCSSVersion) {\n          window.ShadyCSS!.prepareTemplateDom(element, scopeName);\n        }\n        template = new Template(result, element);\n        templateCache.keyString.set(key, template);\n      }\n      templateCache.stringsArray.set(result.strings, template);\n      return template;\n    };\n\nconst TEMPLATE_TYPES = ['html', 'svg'];\n\n/**\n * Removes all style elements from Templates for the given scopeName.\n */\nconst removeStylesFromLitTemplates = (scopeName: string) => {\n  TEMPLATE_TYPES.forEach((type) => {\n    const templates = templateCaches.get(getTemplateCacheKey(type, scopeName));\n    if (templates !== undefined) {\n      templates.keyString.forEach((template) => {\n        const {element: {content}} = template;\n        // IE 11 doesn't support the iterable param Set constructor\n        const styles = new Set<Element>();\n        Array.from(content.querySelectorAll('style')).forEach((s: Element) => {\n          styles.add(s);\n        });\n        removeNodesFromTemplate(template, styles);\n      });\n    }\n  });\n};\n\nconst shadyRenderSet = new Set<string>();\n\n/**\n * For the given scope name, ensures that ShadyCSS style scoping is performed.\n * This is done just once per scope name so the fragment and template cannot\n * be modified.\n * (1) extracts styles from the rendered fragment and hands them to ShadyCSS\n * to be scoped and appended to the document\n * (2) removes style elements from all lit-html Templates for this scope name.\n *\n * Note, <style> elements can only be placed into templates for the\n * initial rendering of the scope. If <style> elements are included in templates\n * dynamically rendered to the scope (after the first scope render), they will\n * not be scoped and the <style> will be left in the template and rendered\n * output.\n */\nconst prepareTemplateStyles =\n    (scopeName: string, renderedDOM: DocumentFragment, template?: Template) => {\n      shadyRenderSet.add(scopeName);\n      // If `renderedDOM` is stamped from a Template, then we need to edit that\n      // Template's underlying template element. Otherwise, we create one here\n      // to give to ShadyCSS, which still requires one while scoping.\n      const templateElement =\n          !!template ? template.element : document.createElement('template');\n      // Move styles out of rendered DOM and store.\n      const styles = renderedDOM.querySelectorAll('style');\n      const {length} = styles;\n      // If there are no styles, skip unnecessary work\n      if (length === 0) {\n        // Ensure prepareTemplateStyles is called to support adding\n        // styles via `prepareAdoptedCssText` since that requires that\n        // `prepareTemplateStyles` is called.\n        //\n        // ShadyCSS will only update styles containing @apply in the template\n        // given to `prepareTemplateStyles`. If no lit Template was given,\n        // ShadyCSS will not be able to update uses of @apply in any relevant\n        // template. However, this is not a problem because we only create the\n        // template for the purpose of supporting `prepareAdoptedCssText`,\n        // which doesn't support @apply at all.\n        window.ShadyCSS!.prepareTemplateStyles(templateElement, scopeName);\n        return;\n      }\n      const condensedStyle = document.createElement('style');\n      // Collect styles into a single style. This helps us make sure ShadyCSS\n      // manipulations will not prevent us from being able to fix up template\n      // part indices.\n      // NOTE: collecting styles is inefficient for browsers but ShadyCSS\n      // currently does this anyway. When it does not, this should be changed.\n      for (let i = 0; i < length; i++) {\n        const style = styles[i];\n        style.parentNode!.removeChild(style);\n        condensedStyle.textContent! += style.textContent;\n      }\n      // Remove styles from nested templates in this scope.\n      removeStylesFromLitTemplates(scopeName);\n      // And then put the condensed style into the \"root\" template passed in as\n      // `template`.\n      const content = templateElement.content;\n      if (!!template) {\n        insertNodeIntoTemplate(template, condensedStyle, content.firstChild);\n      } else {\n        content.insertBefore(condensedStyle, content.firstChild);\n      }\n      // Note, it's important that ShadyCSS gets the template that `lit-html`\n      // will actually render so that it can update the style inside when\n      // needed (e.g. @apply native Shadow DOM case).\n      window.ShadyCSS!.prepareTemplateStyles(templateElement, scopeName);\n      const style = content.querySelector('style');\n      if (window.ShadyCSS!.nativeShadow && style !== null) {\n        // When in native Shadow DOM, ensure the style created by ShadyCSS is\n        // included in initially rendered output (`renderedDOM`).\n        renderedDOM.insertBefore(style.cloneNode(true), renderedDOM.firstChild);\n      } else if (!!template) {\n        // When no style is left in the template, parts will be broken as a\n        // result. To fix this, we put back the style node ShadyCSS removed\n        // and then tell lit to remove that node from the template.\n        // There can be no style in the template in 2 cases (1) when Shady DOM\n        // is in use, ShadyCSS removes all styles, (2) when native Shadow DOM\n        // is in use ShadyCSS removes the style if it contains no content.\n        // NOTE, ShadyCSS creates its own style so we can safely add/remove\n        // `condensedStyle` here.\n        content.insertBefore(condensedStyle, content.firstChild);\n        const removes = new Set<Node>();\n        removes.add(condensedStyle);\n        removeNodesFromTemplate(template, removes);\n      }\n    };\n\nexport interface ShadyRenderOptions extends Partial<RenderOptions> {\n  scopeName: string;\n}\n\n/**\n * Extension to the standard `render` method which supports rendering\n * to ShadowRoots when the ShadyDOM (https://github.com/webcomponents/shadydom)\n * and ShadyCSS (https://github.com/webcomponents/shadycss) polyfills are used\n * or when the webcomponentsjs\n * (https://github.com/webcomponents/webcomponentsjs) polyfill is used.\n *\n * Adds a `scopeName` option which is used to scope element DOM and stylesheets\n * when native ShadowDOM is unavailable. The `scopeName` will be added to\n * the class attribute of all rendered DOM. In addition, any style elements will\n * be automatically re-written with this `scopeName` selector and moved out\n * of the rendered DOM and into the document `<head>`.\n *\n * It is common to use this render method in conjunction with a custom element\n * which renders a shadowRoot. When this is done, typically the element's\n * `localName` should be used as the `scopeName`.\n *\n * In addition to DOM scoping, ShadyCSS also supports a basic shim for css\n * custom properties (needed only on older browsers like IE11) and a shim for\n * a deprecated feature called `@apply` that supports applying a set of css\n * custom properties to a given location.\n *\n * Usage considerations:\n *\n * * Part values in `<style>` elements are only applied the first time a given\n * `scopeName` renders. Subsequent changes to parts in style elements will have\n * no effect. Because of this, parts in style elements should only be used for\n * values that will never change, for example parts that set scope-wide theme\n * values or parts which render shared style elements.\n *\n * * Note, due to a limitation of the ShadyDOM polyfill, rendering in a\n * custom element's `constructor` is not supported. Instead rendering should\n * either done asynchronously, for example at microtask timing (for example\n * `Promise.resolve()`), or be deferred until the first time the element's\n * `connectedCallback` runs.\n *\n * Usage considerations when using shimmed custom properties or `@apply`:\n *\n * * Whenever any dynamic changes are made which affect\n * css custom properties, `ShadyCSS.styleElement(element)` must be called\n * to update the element. There are two cases when this is needed:\n * (1) the element is connected to a new parent, (2) a class is added to the\n * element that causes it to match different custom properties.\n * To address the first case when rendering a custom element, `styleElement`\n * should be called in the element's `connectedCallback`.\n *\n * * Shimmed custom properties may only be defined either for an entire\n * shadowRoot (for example, in a `:host` rule) or via a rule that directly\n * matches an element with a shadowRoot. In other words, instead of flowing from\n * parent to child as do native css custom properties, shimmed custom properties\n * flow only from shadowRoots to nested shadowRoots.\n *\n * * When using `@apply` mixing css shorthand property names with\n * non-shorthand names (for example `border` and `border-width`) is not\n * supported.\n */\nexport const render =\n    (result: unknown,\n     container: Element|DocumentFragment|ShadowRoot,\n     options: ShadyRenderOptions) => {\n      if (!options || typeof options !== 'object' || !options.scopeName) {\n        throw new Error('The `scopeName` option is required.');\n      }\n      const scopeName = options.scopeName;\n      const hasRendered = parts.has(container);\n      const needsScoping = compatibleShadyCSSVersion &&\n          container.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */ &&\n          !!(container as ShadowRoot).host;\n      // Handle first render to a scope specially...\n      const firstScopeRender = needsScoping && !shadyRenderSet.has(scopeName);\n      // On first scope render, render into a fragment; this cannot be a single\n      // fragment that is reused since nested renders can occur synchronously.\n      const renderContainer =\n          firstScopeRender ? document.createDocumentFragment() : container;\n      litRender(\n          result,\n          renderContainer,\n          {templateFactory: shadyTemplateFactory(scopeName), ...options} as\n              RenderOptions);\n      // When performing first scope render,\n      // (1) We've rendered into a fragment so that there's a chance to\n      // `prepareTemplateStyles` before sub-elements hit the DOM\n      // (which might cause them to render based on a common pattern of\n      // rendering in a custom element's `connectedCallback`);\n      // (2) Scope the template with ShadyCSS one time only for this scope.\n      // (3) Render the fragment into the container and make sure the\n      // container knows its `part` is the one we just rendered. This ensures\n      // DOM will be re-used on subsequent renders.\n      if (firstScopeRender) {\n        const part = parts.get(renderContainer)!;\n        parts.delete(renderContainer);\n        // ShadyCSS might have style sheets (e.g. from `prepareAdoptedCssText`)\n        // that should apply to `renderContainer` even if the rendered value is\n        // not a TemplateInstance. However, it will only insert scoped styles\n        // into the document if `prepareTemplateStyles` has already been called\n        // for the given scope name.\n        const template = part.value instanceof TemplateInstance ?\n            part.value.template :\n            undefined;\n        prepareTemplateStyles(\n            scopeName, renderContainer as DocumentFragment, template);\n        removeNodes(container, container.firstChild);\n        container.appendChild(renderContainer);\n        parts.set(container, part);\n      }\n      // After elements have hit the DOM, update styling if this is the\n      // initial render to this container.\n      // This is needed whenever dynamic changes are made so it would be\n      // safest to do every render; however, this would regress performance\n      // so we leave it up to the user to call `ShadyCSS.styleElement`\n      // for dynamic changes.\n      if (!hasRendered && needsScoping) {\n        window.ShadyCSS!.styleElement((container as ShadowRoot).host);\n      }\n    };\n","import setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct.bind();\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n  return _construct.apply(null, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeFunction from \"./isNativeFunction.js\";\nimport construct from \"./construct.js\";\nexport default function _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n      _cache.set(Class, Wrapper);\n    }\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  };\n  return _wrapNativeSuper(Class);\n}","export default function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}","/**\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/**\n * Use this module if you want to create your own base class extending\n * [[UpdatingElement]].\n * @packageDocumentation\n */\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    <P extends PropertyKey>(prop: P, _obj: unknown): P => prop;\n\ndeclare global {\n  var JSCompiler_renameProperty: <P extends PropertyKey>(\n      prop: P, _obj: unknown) => P;\n\n  interface Window {\n    JSCompiler_renameProperty: typeof JSCompiler_renameProperty;\n  }\n}\n\n/**\n * Converts property values to and from attribute values.\n */\nexport interface ComplexAttributeConverter<Type = unknown, TypeHint = unknown> {\n  /**\n   * Function called to convert an attribute value to a property\n   * value.\n   */\n  fromAttribute?(value: string|null, type?: TypeHint): Type;\n\n  /**\n   * Function called to convert a property value to an attribute\n   * value.\n   *\n   * It returns unknown instead of string, to be compatible with\n   * https://github.com/WICG/trusted-types (and similar efforts).\n   */\n  toAttribute?(value: Type, type?: TypeHint): unknown;\n}\n\ntype AttributeConverter<Type = unknown, TypeHint = unknown> =\n    ComplexAttributeConverter<Type>|\n    ((value: string|null, type?: TypeHint) => Type);\n\n/**\n * Defines options for a property accessor.\n */\nexport interface PropertyDeclaration<Type = unknown, TypeHint = unknown> {\n  /**\n   * Indicates how and whether the property becomes an observed attribute.\n   * If the value is `false`, the property is not added to `observedAttributes`.\n   * If true or absent, the lowercased property name is observed (e.g. `fooBar`\n   * becomes `foobar`). If a string, the string value is observed (e.g\n   * `attribute: 'foo-bar'`).\n   */\n  readonly attribute?: boolean|string;\n\n  /**\n   * Indicates the type of the property. This is used only as a hint for the\n   * `converter` to determine how to convert the attribute\n   * to/from a property.\n   */\n  readonly type?: TypeHint;\n\n  /**\n   * Indicates how to convert the attribute to/from a property. If this value\n   * is a function, it is used to convert the attribute value a the property\n   * value. If it's an object, it can have keys for `fromAttribute` and\n   * `toAttribute`. If no `toAttribute` function is provided and\n   * `reflect` is set to `true`, the property value is set directly to the\n   * attribute. A default `converter` is used if none is provided; it supports\n   * `Boolean`, `String`, `Number`, `Object`, and `Array`. Note,\n   * when a property changes and the converter is used to update the attribute,\n   * the property is never updated again as a result of the attribute changing,\n   * and vice versa.\n   */\n  readonly converter?: AttributeConverter<Type, TypeHint>;\n\n  /**\n   * Indicates if the property should reflect to an attribute.\n   * If `true`, when the property is set, the attribute is set using the\n   * attribute name determined according to the rules for the `attribute`\n   * property option and the value of the property converted using the rules\n   * from the `converter` property option.\n   */\n  readonly reflect?: boolean;\n\n  /**\n   * A function that indicates if a property should be considered changed when\n   * it is set. The function should take the `newValue` and `oldValue` and\n   * return `true` if an update should be requested.\n   */\n  hasChanged?(value: Type, oldValue: Type): boolean;\n\n  /**\n   * Indicates whether an accessor will be created for this property. By\n   * default, an accessor will be generated for this property that requests an\n   * update when set. If this flag is `true`, no accessor will be created, and\n   * it will be the user's responsibility to call\n   * `this.requestUpdate(propertyName, oldValue)` to request an update when\n   * the property changes.\n   */\n  readonly noAccessor?: boolean;\n}\n\n/**\n * Map of properties to PropertyDeclaration options. For each property an\n * accessor is made, and the property is processed according to the\n * PropertyDeclaration options.\n */\nexport interface PropertyDeclarations {\n  readonly [key: string]: PropertyDeclaration;\n}\n\ntype PropertyDeclarationMap = Map<PropertyKey, PropertyDeclaration>;\n\ntype AttributeMap = Map<string, PropertyKey>;\n\n/**\n * Map of changed properties with old values. Takes an optional generic\n * interface corresponding to the declared element properties.\n */\n// tslint:disable-next-line:no-any\nexport type PropertyValues<T = any> =\n    keyof T extends PropertyKey ? Map<keyof T, unknown>: never;\n\nexport const defaultConverter: ComplexAttributeConverter = {\n\n  toAttribute(value: unknown, type?: unknown): unknown {\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\n  fromAttribute(value: string|null, type?: unknown) {\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        // Type assert to adhere to Bazel's \"must type assert JSON parse\" rule.\n        return JSON.parse(value!) as unknown;\n    }\n    return value;\n  }\n\n};\n\nexport interface HasChanged {\n  (value: unknown, old: unknown): boolean;\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: HasChanged = (value: unknown, old: unknown): boolean => {\n  // This ensures (old==NaN, value==NaN) always returns false\n  return old !== value && (old === old || value === value);\n};\n\nconst defaultPropertyDeclaration: PropertyDeclaration = {\n  attribute: true,\n  type: String,\n  converter: defaultConverter,\n  reflect: false,\n  hasChanged: notEqual\n};\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;\ntype UpdateState = typeof STATE_HAS_UPDATED|typeof STATE_UPDATE_REQUESTED|\n    typeof STATE_IS_REFLECTING_TO_ATTRIBUTE|\n    typeof STATE_IS_REFLECTING_TO_PROPERTY;\n\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/**\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 abstract class UpdatingElement extends HTMLElement {\n  /*\n   * Due to closure compiler ES6 compilation bugs, @nocollapse is required on\n   * all static methods and properties with initializers.  Reference:\n   * - https://github.com/google/closure-compiler/issues/1776\n   */\n\n  /**\n   * Maps attribute names to properties; for example `foobar` attribute to\n   * `fooBar` property. Created lazily on user subclasses when finalizing the\n   * class.\n   */\n  private static _attributeToPropertyMap: AttributeMap;\n\n  /**\n   * Marks class as having finished creating properties.\n   */\n  protected static[finalized] = true;\n\n  /**\n   * Memoized list of all class properties, including any superclass properties.\n   * Created lazily on user subclasses when finalizing the class.\n   */\n  private static _classProperties?: PropertyDeclarationMap;\n\n  /**\n   * User-supplied object that maps property names to `PropertyDeclaration`\n   * objects containing options for configuring the property.\n   */\n  static properties: PropertyDeclarations;\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: string[] = [];\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  /**\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  private static _ensureClassProperties() {\n    // ensure private storage for property declarations.\n    if (!this.hasOwnProperty(\n            JSCompiler_renameProperty('_classProperties', this))) {\n      this._classProperties = new Map();\n      // NOTE: Workaround IE11 not supporting Map constructor argument.\n      const superProperties: PropertyDeclarationMap =\n          Object.getPrototypeOf(this)._classProperties;\n      if (superProperties !== undefined) {\n        superProperties.forEach(\n            (v: PropertyDeclaration, k: PropertyKey) =>\n                this._classProperties!.set(k, v));\n      }\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(\n      name: PropertyKey,\n      options: PropertyDeclaration = 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  /**\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  protected static getPropertyDescriptor(\n      name: PropertyKey, key: string|symbol, options: PropertyDeclaration) {\n    return {\n      // tslint:disable-next-line:no-any no symbol in index\n      get(): any {\n        return (this as {[key: string]: unknown})[key as string];\n      },\n      set(this: UpdatingElement, value: unknown) {\n        const oldValue =\n            (this as {} as {[key: string]: unknown})[name as string];\n        (this as {} as {[key: string]: unknown})[key as string] = value;\n        (this as unknown as UpdatingElement)\n            .requestUpdateInternal(name, oldValue, options);\n      },\n      configurable: true,\n      enumerable: true\n    };\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  protected static getPropertyOptions(name: PropertyKey) {\n    return this._classProperties && this._classProperties.get(name) ||\n        defaultPropertyDeclaration;\n  }\n\n  /**\n   * Creates property accessors for registered properties and ensures\n   * any superclasses are also finalized.\n   * @nocollapse\n   */\n  protected 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 as any)[p]);\n      }\n    }\n  }\n\n  /**\n   * Returns the property name for the given attribute `name`.\n   * @nocollapse\n   */\n  private static _attributeNameForProperty(\n      name: PropertyKey, options: PropertyDeclaration) {\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  /**\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  private static _valueHasChanged(\n      value: unknown, old: unknown, hasChanged: HasChanged = notEqual) {\n    return hasChanged(value, old);\n  }\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  private static _propertyValueFromAttribute(\n      value: string|null, options: PropertyDeclaration) {\n    const type = options.type;\n    const converter = options.converter || defaultConverter;\n    const fromAttribute =\n        (typeof converter === 'function' ? converter : converter.fromAttribute);\n    return fromAttribute ? fromAttribute(value, type) : value;\n  }\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  private static _propertyValueToAttribute(\n      value: unknown, options: PropertyDeclaration) {\n    if (options.reflect === undefined) {\n      return;\n    }\n    const type = options.type;\n    const converter = options.converter;\n    const toAttribute =\n        converter && (converter as ComplexAttributeConverter).toAttribute ||\n        defaultConverter.toAttribute;\n    return toAttribute!(value, type);\n  }\n\n  private _updateState!: UpdateState;\n  private _instanceProperties?: PropertyValues;\n  // Initialize to an unresolved Promise so we can make sure the element has\n  // connected before first update.\n  private _updatePromise!: Promise<unknown>;\n  private _enableUpdatingResolver: ((r?: unknown) => void)|undefined;\n\n  /**\n   * Map with keys for any properties that have changed since the last\n   * update cycle with previous values.\n   */\n  private _changedProperties!: PropertyValues;\n\n  /**\n   * Map with keys of properties that should be reflected when updated.\n   */\n  private _reflectingProperties?: Map<PropertyKey, PropertyDeclaration>;\n\n  constructor() {\n    super();\n    this.initialize();\n  }\n\n  /**\n   * Performs element initialization. By default captures any pre-set values for\n   * registered properties.\n   */\n  protected 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  /**\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  private _saveInstanceProperties() {\n    // Use forEach so this works even if for/of loops are compiled to for loops\n    // expecting arrays\n    (this.constructor as typeof UpdatingElement)\n        ._classProperties!.forEach((_v, p) => {\n          if (this.hasOwnProperty(p)) {\n            const value = this[p as keyof this];\n            delete this[p as keyof this];\n            if (!this._instanceProperties) {\n              this._instanceProperties = new Map();\n            }\n            this._instanceProperties.set(p, value);\n          }\n        });\n  }\n\n  /**\n   * Applies previously saved instance properties.\n   */\n  private _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 as any)[p] = v);\n    this._instanceProperties = undefined;\n  }\n\n  connectedCallback() {\n    // Ensure first connection completes an update. Updates cannot complete\n    // before connection.\n    this.enableUpdating();\n  }\n\n  protected enableUpdating() {\n    if (this._enableUpdatingResolver !== undefined) {\n      this._enableUpdatingResolver();\n      this._enableUpdatingResolver = undefined;\n    }\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  /**\n   * Synchronizes property values when attributes change.\n   */\n  attributeChangedCallback(name: string, old: string|null, value: string|null) {\n    if (old !== value) {\n      this._attributeToProperty(name, value);\n    }\n  }\n\n  private _propertyToAttribute(\n      name: PropertyKey, value: unknown,\n      options: PropertyDeclaration = defaultPropertyDeclaration) {\n    const ctor = (this.constructor as typeof UpdatingElement);\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      } else {\n        this.setAttribute(attr, attrValue as string);\n      }\n      // mark state not reflecting\n      this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_ATTRIBUTE;\n    }\n  }\n\n  private _attributeToProperty(name: string, value: string|null) {\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 as typeof UpdatingElement);\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 as AttributeMap).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 as keyof this] =\n          // tslint:disable-next-line:no-any\n          ctor._propertyValueFromAttribute(value, options) as any;\n      // mark state not reflecting\n      this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_PROPERTY;\n    }\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  protected requestUpdateInternal(\n      name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration) {\n    let shouldRequestUpdate = true;\n    // If we have a property key, perform property update steps.\n    if (name !== undefined) {\n      const ctor = this.constructor as typeof UpdatingElement;\n      options = options || ctor.getPropertyOptions(name);\n      if (ctor._valueHasChanged(\n              this[name as keyof this], 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      } 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  /**\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?: PropertyKey, oldValue?: unknown) {\n    this.requestUpdateInternal(name, oldValue);\n    return this.updateComplete;\n  }\n\n  /**\n   * Sets up the element to asynchronously update.\n   */\n  private 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    } 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\n  private get _hasRequestedUpdate() {\n    return (this._updateState & STATE_UPDATE_REQUESTED);\n  }\n\n  protected get hasUpdated() {\n    return (this._updateState & STATE_HAS_UPDATED);\n  }\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  protected performUpdate(): void|Promise<unknown> {\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      } else {\n        this._markUpdated();\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\n  private _markUpdated() {\n    this._changedProperties = new Map();\n    this._updateState = this._updateState & ~STATE_UPDATE_REQUESTED;\n  }\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  /**\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   * @deprecated Override `getUpdateComplete()` instead for forward\n   *     compatibility with `lit-element` 3.0 / `@lit/reactive-element`.\n   */\n  protected _getUpdateComplete() {\n    return this.getUpdateComplete();\n  }\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  protected getUpdateComplete() {\n    return this._updatePromise;\n  }\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  protected shouldUpdate(_changedProperties: PropertyValues): boolean {\n    return true;\n  }\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  protected update(_changedProperties: PropertyValues) {\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(\n          (v, k) => this._propertyToAttribute(k, this[k as keyof this], v));\n      this._reflectingProperties = undefined;\n    }\n    this._markUpdated();\n  }\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  protected updated(_changedProperties: PropertyValues) {\n  }\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  protected firstUpdated(_changedProperties: PropertyValues) {\n  }\n}\n","/**\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/*\n * IMPORTANT: For compatibility with tsickle and the Closure Compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\n\nimport {LitElement} from '../lit-element.js';\n\nimport {PropertyDeclaration, UpdatingElement} from './updating-element.js';\n\nexport type Constructor<T> = {\n  // tslint:disable-next-line:no-any\n  new (...args: any[]): T\n};\n\n// From the TC39 Decorators proposal\ninterface ClassDescriptor {\n  kind: 'class';\n  elements: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => undefined | Constructor<T>;\n}\n\n// From the TC39 Decorators proposal\ninterface ClassElement {\n  kind: 'field'|'method';\n  key: PropertyKey;\n  placement: 'static'|'prototype'|'own';\n  initializer?: Function;\n  extras?: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => undefined | Constructor<T>;\n  descriptor?: PropertyDescriptor;\n}\n\nconst legacyCustomElement =\n    (tagName: string, clazz: Constructor<HTMLElement>) => {\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 as any;\n    };\n\nconst standardCustomElement =\n    (tagName: string, descriptor: ClassDescriptor) => {\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: Constructor<HTMLElement>) {\n          window.customElements.define(tagName, clazz);\n        }\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: string) =>\n    (classOrDescriptor: Constructor<HTMLElement>|ClassDescriptor) =>\n        (typeof classOrDescriptor === 'function') ?\n    legacyCustomElement(tagName, classOrDescriptor) :\n    standardCustomElement(tagName, classOrDescriptor);\n\nconst standardProperty =\n    (options: PropertyDeclaration, element: ClassElement) => {\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 {\n          ...element,\n          finisher(clazz: typeof UpdatingElement) {\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(this: {[key: string]: unknown}) {\n            if (typeof element.initializer === 'function') {\n              this[element.key as string] = element.initializer.call(this);\n            }\n          },\n          finisher(clazz: typeof UpdatingElement) {\n            clazz.createProperty(element.key, options);\n          }\n        };\n      }\n    };\n\nconst legacyProperty =\n    (options: PropertyDeclaration, proto: Object, name: PropertyKey) => {\n      (proto.constructor as typeof UpdatingElement)\n          .createProperty(name, options);\n    };\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?: PropertyDeclaration) {\n  // tslint:disable-next-line:no-any decorator\n  return (protoOrDescriptor: Object|ClassElement, name?: PropertyKey): any =>\n             (name !== undefined) ?\n      legacyProperty(options!, protoOrDescriptor as Object, name) :\n      standardProperty(options!, protoOrDescriptor as ClassElement);\n}\n\nexport interface InternalPropertyDeclaration<Type = unknown> {\n  /**\n   * A function that indicates if a property should be considered changed when\n   * it is set. The function should take the `newValue` and `oldValue` and\n   * return `true` if an update should be requested.\n   */\n  hasChanged?(value: Type, oldValue: Type): boolean;\n}\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 the Closure Compiler.\n * @category Decorator\n * @deprecated `internalProperty` has been renamed to `state` in lit-element\n *     3.0. Please update to `state` now to be compatible with 3.0.\n */\nexport function internalProperty(options?: InternalPropertyDeclaration) {\n  return property({attribute: false, hasChanged: options?.hasChanged});\n}\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 the Closure Compiler.\n * @category Decorator\n */\nexport const state = (options?: InternalPropertyDeclaration) =>\n    internalProperty(options);\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: string, cache?: boolean) {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelector(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    if (cache) {\n      const prop =\n          name !== undefined ? name : (protoOrDescriptor as ClassElement).key;\n      const key = typeof prop === 'symbol' ? Symbol() : `__${prop}`;\n      descriptor.get = function(this: LitElement) {\n        if ((this as unknown as\n             {[key: string]: Element | null})[key as string] === undefined) {\n          ((this as unknown as {[key: string]: Element | null})[key as string] =\n               this.renderRoot.querySelector(selector));\n        }\n        return (\n            this as unknown as {[key: string]: Element | null})[key as string];\n      };\n    }\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\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: string) {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      async get(this: LitElement) {\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 as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\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: string) {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelectorAll(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n\nconst legacyQuery =\n    (descriptor: PropertyDescriptor, proto: Object, name: PropertyKey) => {\n      Object.defineProperty(proto, name, descriptor);\n    };\n\nconst standardQuery = (descriptor: PropertyDescriptor, element: ClassElement) =>\n    ({\n      kind: 'method',\n      placement: 'prototype',\n      key: element.key,\n      descriptor,\n    });\n\nconst standardEventOptions =\n    (options: AddEventListenerOptions, element: ClassElement) => {\n      return {\n        ...element,\n        finisher(clazz: typeof UpdatingElement) {\n          Object.assign(\n              clazz.prototype[element.key as keyof UpdatingElement], options);\n        }\n      };\n    };\n\nconst legacyEventOptions =\n    // tslint:disable-next-line:no-any legacy decorator\n    (options: AddEventListenerOptions, proto: any, name: PropertyKey) => {\n      Object.assign(proto[name], options);\n    };\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: AddEventListenerOptions) {\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: Object|ClassElement, name?: string) =>\n              (name !== undefined) ?\n              legacyEventOptions(options, protoOrDescriptor as Object, name) :\n              standardEventOptions(\n                  options, protoOrDescriptor as ClassElement)) as\n             // tslint:disable-next-line:no-any decorator\n             any;\n}\n\n// x-browser support for matches\n// tslint:disable-next-line:no-any\nconst ElementProto = Element.prototype as any;\nconst legacyMatches =\n    ElementProto.msMatchesSelector || ElementProto.webkitMatchesSelector;\n\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(\n    slotName = '', flatten = false, selector = '') {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        const slotSelector =\n            `slot${slotName ? `[name=${slotName}]` : ':not([name])'}`;\n        const slot = this.renderRoot.querySelector(slotSelector);\n        let nodes = slot && (slot as HTMLSlotElement).assignedNodes({flatten});\n        if (nodes && selector) {\n          nodes = nodes.filter(\n              (node) => node.nodeType === Node.ELEMENT_NODE &&\n                  // tslint:disable-next-line:no-any testing existence on older browsers\n                  ((node as any).matches ?\n                       (node as Element).matches(selector) :\n                       legacyMatches.call(node as Element, selector)));\n        }\n        return nodes;\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n","/**\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/**\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);\n\nconst constructionToken = Symbol();\n\nexport class CSSResult {\n  _styleSheet?: CSSStyleSheet|null;\n\n  readonly cssText: string;\n\n  constructor(cssText: string, safeToken: symbol) {\n    if (safeToken !== constructionToken) {\n      throw new Error(\n          'CSSResult is not constructable. Use `unsafeCSS` or `css` instead.');\n    }\n\n    this.cssText = cssText;\n  }\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(): CSSStyleSheet|null {\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      } else {\n        this._styleSheet = null;\n      }\n    }\n    return this._styleSheet;\n  }\n\n  toString(): string {\n    return this.cssText;\n  }\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: unknown) => {\n  return new CSSResult(String(value), constructionToken);\n};\n\nconst textFromCSSResult = (value: CSSResult|number) => {\n  if (value instanceof CSSResult) {\n    return value.cssText;\n  } else if (typeof value === 'number') {\n    return value;\n  } else {\n    throw new Error(\n        `Value passed to 'css' function must be a 'css' function result: ${\n            value}. Use 'unsafeCSS' to pass non-literal values, but\n            take care to ensure page security.`);\n  }\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 =\n    (strings: TemplateStringsArray, ...values: (CSSResult|number)[]) => {\n      const cssText = values.reduce(\n          (acc, v, idx) => acc + textFromCSSResult(v) + strings[idx + 1],\n          strings[0]);\n      return new CSSResult(cssText, constructionToken);\n    };\n","/**\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/**\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, ShadyRenderOptions} from 'lit-html/lib/shady-render.js';\n\nimport {PropertyValues, UpdatingElement} from './lib/updating-element.js';\n\nexport * from './lib/updating-element.js';\nexport {UpdatingElement as ReactiveElement} from './lib/updating-element.js';\nexport * from './lib/decorators.js';\nexport {html, svg, TemplateResult, SVGTemplateResult} from 'lit-html/lit-html.js';\nimport {supportsAdoptingStyleSheets, CSSResult, unsafeCSS} from './lib/css-tag.js';\nexport * from './lib/css-tag.js';\n\ndeclare global {\n  interface Window {\n    litElementVersions: string[];\n  }\n}\n\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.5.1');\n\nexport type CSSResultOrNative = CSSResult|CSSStyleSheet;\n\nexport interface CSSResultArray extends\n    Array<CSSResultOrNative|CSSResultArray> {}\n\nexport type CSSResultGroup = CSSResultOrNative|CSSResultArray;\n\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/**\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   * 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   */\n  protected static['finalized'] = true;\n\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   */\n  static render:\n      (result: unknown, container: Element|DocumentFragment,\n       options: ShadyRenderOptions) => void = render;\n\n  /**\n   * Array of styles to apply to the element. The styles should be defined\n   * using the [[`css`]] tag function or via constructible stylesheets.\n   */\n  static styles?: CSSResultGroup;\n\n  /** @nocollapse */\n  static shadowRootOptions: ShadowRootInit = {mode: 'open'};\n\n  private static _styles: Array<CSSResultOrNative|CSSResult>|undefined;\n\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(): CSSResultGroup|undefined {\n    return this.styles;\n  }\n\n  /** @nocollapse */\n  private 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\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: CSSResultArray, set: Set<CSSResultOrNative>):\n          Set<CSSResultOrNative> => styles.reduceRight(\n              (set: Set<CSSResultOrNative>, s) =>\n                  // Note: On IE set.add() does not return the set\n              Array.isArray(s) ? addStyles(s, set) : (set.add(s), set),\n              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<CSSResultOrNative>());\n      const styles: CSSResultOrNative[] = [];\n      set.forEach((v) => styles.unshift(v));\n      this._styles = styles;\n    } else {\n      this._styles = userStyles === undefined ? [] : [userStyles];\n    }\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  private _needsShimAdoptedStyleSheets?: boolean;\n\n  /**\n   * Node or ShadowRoot into which element DOM should be rendered. Defaults\n   * to an open shadowRoot.\n   */\n  readonly renderRoot!: Element|DocumentFragment;\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  protected initialize() {\n    super.initialize();\n    (this.constructor as typeof LitElement)._getUniqueStyles();\n    (this as {\n      renderRoot: Element|DocumentFragment;\n    }).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  /**\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  protected createRenderRoot(): Element|ShadowRoot {\n    return this.attachShadow(\n        (this.constructor as typeof LitElement).shadowRootOptions);\n  }\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  protected adoptStyles() {\n    const styles = (this.constructor as typeof LitElement)._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(\n          styles.map((s) => (s as CSSResult).cssText), this.localName);\n    } else if (supportsAdoptingStyleSheets) {\n      (this.renderRoot as ShadowRoot).adoptedStyleSheets =\n          styles.map((s) => s instanceof CSSStyleSheet ? s : s.styleSheet!);\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\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  /**\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  protected update(changedProperties: PropertyValues) {\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 as typeof LitElement)\n          .render(\n              templateResult,\n              this.renderRoot,\n              {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 as typeof LitElement)._styles!.forEach((s) => {\n        const style = document.createElement('style');\n        style.textContent = (s as CSSResult).cssText;\n        this.renderRoot.appendChild(style);\n      });\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  protected render(): unknown {\n    return renderNotImplemented;\n  }\n}\n","/**\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 */\n\nimport {AttributePart, directive, Part, PropertyPart} from '../lit-html.js';\n\n// IE11 doesn't support classList on SVG elements, so we emulate it with a Set\nclass ClassList {\n  element: Element;\n  classes: Set<string> = new Set();\n  changed = false;\n\n  constructor(element: Element) {\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: string) {\n    this.classes.add(cls);\n    this.changed = true;\n  }\n\n  remove(cls: string) {\n    this.classes.delete(cls);\n    this.changed = true;\n  }\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\nexport interface ClassInfo {\n  readonly [name: string]: string|boolean|number;\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<Part, Set<string>>();\n\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: ClassInfo) => (part: Part) => {\n  if (!(part instanceof AttributePart) || (part instanceof PropertyPart) ||\n      part.committer.name !== 'class' || part.committer.parts.length > 1) {\n    throw new Error(\n        'The `classMap` directive must be used in the `class` attribute ' +\n        'and must be the only part in the attribute.');\n  }\n\n  const {committer} = part;\n  const {element} = committer;\n\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\n  const classList =\n      (element.classList || new ClassList(element)) as DOMTokenList | ClassList;\n\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\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      } else {\n        classList.remove(name);\n        previousClasses.delete(name);\n      }\n    }\n  }\n  if (typeof (classList as ClassList).commit === 'function') {\n    (classList as ClassList).commit();\n  }\n});\n","/**\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\nimport {Part} from './part.js';\n\nconst directives = new WeakMap<object, true>();\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type DirectiveFactory = (...args: any[]) => object;\n\nexport type DirectiveFn = (part: Part) => void;\n\n/**\n * Brands a function as a directive factory function so that lit-html will call\n * the function during template rendering, rather than passing as a value.\n *\n * A _directive_ is a function that takes a Part as an argument. It has the\n * signature: `(part: Part) => void`.\n *\n * A directive _factory_ is a function that takes arguments for data and\n * configuration and returns a directive. Users of directive usually refer to\n * the directive factory as the directive. For example, \"The repeat directive\".\n *\n * Usually a template author will invoke a directive factory in their template\n * with relevant arguments, which will then return a directive function.\n *\n * Here's an example of using the `repeat()` directive factory that takes an\n * array and a function to render an item:\n *\n * ```js\n * html`<ul><${repeat(items, (item) => html`<li>${item}</li>`)}</ul>`\n * ```\n *\n * When `repeat` is invoked, it returns a directive function that closes over\n * `items` and the template function. When the outer template is rendered, the\n * return directive function is called with the Part for the expression.\n * `repeat` then performs it's custom logic to render multiple items.\n *\n * @param f The directive factory function. Must be a function that returns a\n * function of the signature `(part: Part) => void`. The returned function will\n * be called with the part object.\n *\n * @example\n *\n * import {directive, html} from 'lit-html';\n *\n * const immutable = directive((v) => (part) => {\n *   if (part.value !== v) {\n *     part.setValue(v)\n *   }\n * });\n */\nexport const directive = <F extends DirectiveFactory>(f: F): F =>\n    ((...args: unknown[]) => {\n      const d = f(...args);\n      directives.set(d, true);\n      return d;\n    }) as F;\n\nexport const isDirective = (o: unknown): o is DirectiveFn => {\n  return typeof o === 'function' && directives.has(o);\n};\n","/**\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\ninterface MaybePolyfilledCe extends CustomElementRegistry {\n  readonly polyfillWrapFlushCallback?: object;\n}\n\n/**\n * True if the custom elements polyfill is in use.\n */\nexport const isCEPolyfill = typeof window !== 'undefined' &&\n    window.customElements != null &&\n    (window.customElements as MaybePolyfilledCe).polyfillWrapFlushCallback !==\n        undefined;\n\n/**\n * Reparents nodes, starting from `start` (inclusive) to `end` (exclusive),\n * into another container (could be the same container), before `before`. If\n * `before` is null, it appends the nodes to the container.\n */\nexport const reparentNodes =\n    (container: Node,\n     start: Node|null,\n     end: Node|null = null,\n     before: Node|null = null): void => {\n      while (start !== end) {\n        const n = start!.nextSibling;\n        container.insertBefore(start!, before);\n        start = n;\n      }\n    };\n\n/**\n * Removes nodes, starting from `start` (inclusive) to `end` (exclusive), from\n * `container`.\n */\nexport const removeNodes =\n    (container: Node, start: Node|null, end: Node|null = null): void => {\n      while (start !== end) {\n        const n = start!.nextSibling;\n        container.removeChild(start!);\n        start = n;\n      }\n    };\n","/**\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 */\n\n/**\n * The Part interface represents a dynamic part of a template instance rendered\n * by lit-html.\n */\nexport interface Part {\n  readonly value: unknown;\n\n  /**\n   * Sets the current part value, but does not write it to the DOM.\n   * @param value The value that will be committed.\n   */\n  setValue(value: unknown): void;\n\n  /**\n   * Commits the current part value, causing it to actually be written to the\n   * DOM.\n   *\n   * Directives are run at the start of `commit`, so that if they call\n   * `part.setValue(...)` synchronously that value will be used in the current\n   * commit, and there's no need to call `part.commit()` within the directive.\n   * If directives set a part value asynchronously, then they must call\n   * `part.commit()` manually.\n   */\n  commit(): void;\n}\n\n/**\n * A sentinel value that signals that a value was handled by a directive and\n * should not be written to the DOM.\n */\nexport const noChange = {};\n\n/**\n * A sentinel value that signals a NodePart to fully clear its content.\n */\nexport const nothing = {};\n","/**\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\nimport {isDirective} from './directive.js';\nimport {removeNodes} from './dom.js';\nimport {noChange, nothing, Part} from './part.js';\nimport {RenderOptions} from './render-options.js';\nimport {TemplateInstance} from './template-instance.js';\nimport {TemplateResult} from './template-result.js';\nimport {createMarker} from './template.js';\n\n// https://tc39.github.io/ecma262/#sec-typeof-operator\nexport type Primitive = null|undefined|boolean|number|string|symbol|bigint;\nexport const isPrimitive = (value: unknown): value is Primitive => {\n  return (\n      value === null ||\n      !(typeof value === 'object' || typeof value === 'function'));\n};\nexport const isIterable = (value: unknown): value is Iterable<unknown> => {\n  return Array.isArray(value) ||\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      !!(value && (value as any)[Symbol.iterator]);\n};\n\n/**\n * Writes attribute values to the DOM for a group of AttributeParts bound to a\n * single attribute. The value is only set once even if there are multiple parts\n * for an attribute.\n */\nexport class AttributeCommitter {\n  readonly element: Element;\n  readonly name: string;\n  readonly strings: ReadonlyArray<string>;\n  readonly parts: ReadonlyArray<AttributePart>;\n  dirty = true;\n\n  constructor(element: Element, name: string, strings: ReadonlyArray<string>) {\n    this.element = element;\n    this.name = name;\n    this.strings = strings;\n    this.parts = [];\n    for (let i = 0; i < strings.length - 1; i++) {\n      (this.parts as AttributePart[])[i] = this._createPart();\n    }\n  }\n\n  /**\n   * Creates a single part. Override this to create a differnt type of part.\n   */\n  protected _createPart(): AttributePart {\n    return new AttributePart(this);\n  }\n\n  protected _getValue(): unknown {\n    const strings = this.strings;\n    const l = strings.length - 1;\n    const parts = this.parts;\n\n    // If we're assigning an attribute via syntax like:\n    //    attr=\"${foo}\"  or  attr=${foo}\n    // but not\n    //    attr=\"${foo} ${bar}\" or attr=\"${foo} baz\"\n    // then we don't want to coerce the attribute value into one long\n    // string. Instead we want to just return the value itself directly,\n    // so that sanitizeDOMValue can get the actual value rather than\n    // String(value)\n    // The exception is if v is an array, in which case we do want to smash\n    // it together into a string without calling String() on the array.\n    //\n    // This also allows trusted values (when using TrustedTypes) being\n    // assigned to DOM sinks without being stringified in the process.\n    if (l === 1 && strings[0] === '' && strings[1] === '') {\n      const v = parts[0].value;\n      if (typeof v === 'symbol') {\n        return String(v);\n      }\n      if (typeof v === 'string' || !isIterable(v)) {\n        return v;\n      }\n    }\n    let text = '';\n\n    for (let i = 0; i < l; i++) {\n      text += strings[i];\n      const part = parts[i];\n      if (part !== undefined) {\n        const v = part.value;\n        if (isPrimitive(v) || !isIterable(v)) {\n          text += typeof v === 'string' ? v : String(v);\n        } else {\n          for (const t of v) {\n            text += typeof t === 'string' ? t : String(t);\n          }\n        }\n      }\n    }\n\n    text += strings[l];\n    return text;\n  }\n\n  commit(): void {\n    if (this.dirty) {\n      this.dirty = false;\n      this.element.setAttribute(this.name, this._getValue() as string);\n    }\n  }\n}\n\n/**\n * A Part that controls all or part of an attribute value.\n */\nexport class AttributePart implements Part {\n  readonly committer: AttributeCommitter;\n  value: unknown = undefined;\n\n  constructor(committer: AttributeCommitter) {\n    this.committer = committer;\n  }\n\n  setValue(value: unknown): void {\n    if (value !== noChange && (!isPrimitive(value) || value !== this.value)) {\n      this.value = value;\n      // If the value is a not a directive, dirty the committer so that it'll\n      // call setAttribute. If the value is a directive, it'll dirty the\n      // committer if it calls setValue().\n      if (!isDirective(value)) {\n        this.committer.dirty = true;\n      }\n    }\n  }\n\n  commit() {\n    while (isDirective(this.value)) {\n      const directive = this.value;\n      this.value = noChange;\n      directive(this);\n    }\n    if (this.value === noChange) {\n      return;\n    }\n    this.committer.commit();\n  }\n}\n\n/**\n * A Part that controls a location within a Node tree. Like a Range, NodePart\n * has start and end locations and can set and update the Nodes between those\n * locations.\n *\n * NodeParts support several value types: primitives, Nodes, TemplateResults,\n * as well as arrays and iterables of those types.\n */\nexport class NodePart implements Part {\n  readonly options: RenderOptions;\n  startNode!: Node;\n  endNode!: Node;\n  value: unknown = undefined;\n  private __pendingValue: unknown = undefined;\n\n  constructor(options: RenderOptions) {\n    this.options = options;\n  }\n\n  /**\n   * Appends this part into a container.\n   *\n   * This part must be empty, as its contents are not automatically moved.\n   */\n  appendInto(container: Node) {\n    this.startNode = container.appendChild(createMarker());\n    this.endNode = container.appendChild(createMarker());\n  }\n\n  /**\n   * Inserts this part after the `ref` node (between `ref` and `ref`'s next\n   * sibling). Both `ref` and its next sibling must be static, unchanging nodes\n   * such as those that appear in a literal section of a template.\n   *\n   * This part must be empty, as its contents are not automatically moved.\n   */\n  insertAfterNode(ref: Node) {\n    this.startNode = ref;\n    this.endNode = ref.nextSibling!;\n  }\n\n  /**\n   * Appends this part into a parent part.\n   *\n   * This part must be empty, as its contents are not automatically moved.\n   */\n  appendIntoPart(part: NodePart) {\n    part.__insert(this.startNode = createMarker());\n    part.__insert(this.endNode = createMarker());\n  }\n\n  /**\n   * Inserts this part after the `ref` part.\n   *\n   * This part must be empty, as its contents are not automatically moved.\n   */\n  insertAfterPart(ref: NodePart) {\n    ref.__insert(this.startNode = createMarker());\n    this.endNode = ref.endNode;\n    ref.endNode = this.startNode;\n  }\n\n  setValue(value: unknown): void {\n    this.__pendingValue = value;\n  }\n\n  commit() {\n    if (this.startNode.parentNode === null) {\n      return;\n    }\n    while (isDirective(this.__pendingValue)) {\n      const directive = this.__pendingValue;\n      this.__pendingValue = noChange;\n      directive(this);\n    }\n    const value = this.__pendingValue;\n    if (value === noChange) {\n      return;\n    }\n    if (isPrimitive(value)) {\n      if (value !== this.value) {\n        this.__commitText(value);\n      }\n    } else if (value instanceof TemplateResult) {\n      this.__commitTemplateResult(value);\n    } else if (value instanceof Node) {\n      this.__commitNode(value);\n    } else if (isIterable(value)) {\n      this.__commitIterable(value);\n    } else if (value === nothing) {\n      this.value = nothing;\n      this.clear();\n    } else {\n      // Fallback, will render the string representation\n      this.__commitText(value);\n    }\n  }\n\n  private __insert(node: Node) {\n    this.endNode.parentNode!.insertBefore(node, this.endNode);\n  }\n\n  private __commitNode(value: Node): void {\n    if (this.value === value) {\n      return;\n    }\n    this.clear();\n    this.__insert(value);\n    this.value = value;\n  }\n\n  private __commitText(value: unknown): void {\n    const node = this.startNode.nextSibling!;\n    value = value == null ? '' : value;\n    // If `value` isn't already a string, we explicitly convert it here in case\n    // it can't be implicitly converted - i.e. it's a symbol.\n    const valueAsString: string =\n        typeof value === 'string' ? value : String(value);\n    if (node === this.endNode.previousSibling &&\n        node.nodeType === 3 /* Node.TEXT_NODE */) {\n      // If we only have a single text node between the markers, we can just\n      // set its value, rather than replacing it.\n      // TODO(justinfagnani): Can we just check if this.value is primitive?\n      (node as Text).data = valueAsString;\n    } else {\n      this.__commitNode(document.createTextNode(valueAsString));\n    }\n    this.value = value;\n  }\n\n  private __commitTemplateResult(value: TemplateResult): void {\n    const template = this.options.templateFactory(value);\n    if (this.value instanceof TemplateInstance &&\n        this.value.template === template) {\n      this.value.update(value.values);\n    } else {\n      // Make sure we propagate the template processor from the TemplateResult\n      // so that we use its syntax extension, etc. The template factory comes\n      // from the render function options so that it can control template\n      // caching and preprocessing.\n      const instance =\n          new TemplateInstance(template, value.processor, this.options);\n      const fragment = instance._clone();\n      instance.update(value.values);\n      this.__commitNode(fragment);\n      this.value = instance;\n    }\n  }\n\n  private __commitIterable(value: Iterable<unknown>): void {\n    // For an Iterable, we create a new InstancePart per item, then set its\n    // value to the item. This is a little bit of overhead for every item in\n    // an Iterable, but it lets us recurse easily and efficiently update Arrays\n    // of TemplateResults that will be commonly returned from expressions like:\n    // array.map((i) => html`${i}`), by reusing existing TemplateInstances.\n\n    // If _value is an array, then the previous render was of an\n    // iterable and _value will contain the NodeParts from the previous\n    // render. If _value is not an array, clear this part and make a new\n    // array for NodeParts.\n    if (!Array.isArray(this.value)) {\n      this.value = [];\n      this.clear();\n    }\n\n    // Lets us keep track of how many items we stamped so we can clear leftover\n    // items from a previous render\n    const itemParts = this.value as NodePart[];\n    let partIndex = 0;\n    let itemPart: NodePart|undefined;\n\n    for (const item of value) {\n      // Try to reuse an existing part\n      itemPart = itemParts[partIndex];\n\n      // If no existing part, create a new one\n      if (itemPart === undefined) {\n        itemPart = new NodePart(this.options);\n        itemParts.push(itemPart);\n        if (partIndex === 0) {\n          itemPart.appendIntoPart(this);\n        } else {\n          itemPart.insertAfterPart(itemParts[partIndex - 1]);\n        }\n      }\n      itemPart.setValue(item);\n      itemPart.commit();\n      partIndex++;\n    }\n\n    if (partIndex < itemParts.length) {\n      // Truncate the parts array so _value reflects the current state\n      itemParts.length = partIndex;\n      this.clear(itemPart && itemPart.endNode);\n    }\n  }\n\n  clear(startNode: Node = this.startNode) {\n    removeNodes(\n        this.startNode.parentNode!, startNode.nextSibling!, this.endNode);\n  }\n}\n\n/**\n * Implements a boolean attribute, roughly as defined in the HTML\n * specification.\n *\n * If the value is truthy, then the attribute is present with a value of\n * ''. If the value is falsey, the attribute is removed.\n */\nexport class BooleanAttributePart implements Part {\n  readonly element: Element;\n  readonly name: string;\n  readonly strings: readonly string[];\n  value: unknown = undefined;\n  private __pendingValue: unknown = undefined;\n\n  constructor(element: Element, name: string, strings: readonly string[]) {\n    if (strings.length !== 2 || strings[0] !== '' || strings[1] !== '') {\n      throw new Error(\n          'Boolean attributes can only contain a single expression');\n    }\n    this.element = element;\n    this.name = name;\n    this.strings = strings;\n  }\n\n  setValue(value: unknown): void {\n    this.__pendingValue = value;\n  }\n\n  commit() {\n    while (isDirective(this.__pendingValue)) {\n      const directive = this.__pendingValue;\n      this.__pendingValue = noChange;\n      directive(this);\n    }\n    if (this.__pendingValue === noChange) {\n      return;\n    }\n    const value = !!this.__pendingValue;\n    if (this.value !== value) {\n      if (value) {\n        this.element.setAttribute(this.name, '');\n      } else {\n        this.element.removeAttribute(this.name);\n      }\n      this.value = value;\n    }\n    this.__pendingValue = noChange;\n  }\n}\n\n/**\n * Sets attribute values for PropertyParts, so that the value is only set once\n * even if there are multiple parts for a property.\n *\n * If an expression controls the whole property value, then the value is simply\n * assigned to the property under control. If there are string literals or\n * multiple expressions, then the strings are expressions are interpolated into\n * a string first.\n */\nexport class PropertyCommitter extends AttributeCommitter {\n  readonly single: boolean;\n\n  constructor(element: Element, name: string, strings: ReadonlyArray<string>) {\n    super(element, name, strings);\n    this.single =\n        (strings.length === 2 && strings[0] === '' && strings[1] === '');\n  }\n\n  protected _createPart(): PropertyPart {\n    return new PropertyPart(this);\n  }\n\n  protected _getValue() {\n    if (this.single) {\n      return this.parts[0].value;\n    }\n    return super._getValue();\n  }\n\n  commit(): void {\n    if (this.dirty) {\n      this.dirty = false;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (this.element as any)[this.name] = this._getValue();\n    }\n  }\n}\n\nexport class PropertyPart extends AttributePart {}\n\n// Detect event listener options support. If the `capture` property is read\n// from the options object, then options are supported. If not, then the third\n// argument to add/removeEventListener is interpreted as the boolean capture\n// value so we should only pass the `capture` property.\nlet eventOptionsSupported = false;\n\n// Wrap into an IIFE because MS Edge <= v41 does not support having try/catch\n// blocks right into the body of a module\n(() => {\n  try {\n    const options = {\n      get capture() {\n        eventOptionsSupported = true;\n        return false;\n      }\n    };\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    window.addEventListener('test', options as any, options);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    window.removeEventListener('test', options as any, options);\n  } catch (_e) {\n    // event options not supported\n  }\n})();\n\ntype EventHandlerWithOptions =\n    EventListenerOrEventListenerObject&Partial<AddEventListenerOptions>;\nexport class EventPart implements Part {\n  readonly element: Element;\n  readonly eventName: string;\n  readonly eventContext?: EventTarget;\n  value: undefined|EventHandlerWithOptions = undefined;\n  private __options?: AddEventListenerOptions;\n  private __pendingValue: undefined|EventHandlerWithOptions = undefined;\n  private readonly __boundHandleEvent: (event: Event) => void;\n\n  constructor(element: Element, eventName: string, eventContext?: EventTarget) {\n    this.element = element;\n    this.eventName = eventName;\n    this.eventContext = eventContext;\n    this.__boundHandleEvent = (e) => this.handleEvent(e);\n  }\n\n  setValue(value: undefined|EventHandlerWithOptions): void {\n    this.__pendingValue = value;\n  }\n\n  commit() {\n    while (isDirective(this.__pendingValue)) {\n      const directive = this.__pendingValue;\n      this.__pendingValue = noChange as EventHandlerWithOptions;\n      directive(this);\n    }\n    if (this.__pendingValue === noChange) {\n      return;\n    }\n\n    const newListener = this.__pendingValue;\n    const oldListener = this.value;\n    const shouldRemoveListener = newListener == null ||\n        oldListener != null &&\n            (newListener.capture !== oldListener.capture ||\n             newListener.once !== oldListener.once ||\n             newListener.passive !== oldListener.passive);\n    const shouldAddListener =\n        newListener != null && (oldListener == null || shouldRemoveListener);\n\n    if (shouldRemoveListener) {\n      this.element.removeEventListener(\n          this.eventName, this.__boundHandleEvent, this.__options);\n    }\n    if (shouldAddListener) {\n      this.__options = getOptions(newListener);\n      this.element.addEventListener(\n          this.eventName, this.__boundHandleEvent, this.__options);\n    }\n    this.value = newListener;\n    this.__pendingValue = noChange as EventHandlerWithOptions;\n  }\n\n  handleEvent(event: Event) {\n    if (typeof this.value === 'function') {\n      this.value.call(this.eventContext || this.element, event);\n    } else {\n      (this.value as EventListenerObject).handleEvent(event);\n    }\n  }\n}\n\n// We copy options because of the inconsistent behavior of browsers when reading\n// the third argument of add/removeEventListener. IE11 doesn't support options\n// at all. Chrome 41 only reads `capture` if the argument is an object.\nconst getOptions = (o: AddEventListenerOptions|undefined) => o &&\n    (eventOptionsSupported ?\n         {capture: o.capture, passive: o.passive, once: o.once} :\n         o.capture as AddEventListenerOptions);\n","/**\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\nimport {removeNodes} from './dom.js';\nimport {NodePart} from './parts.js';\nimport {RenderOptions} from './render-options.js';\nimport {templateFactory} from './template-factory.js';\n\nexport const parts = new WeakMap<Node, NodePart>();\n\n/**\n * Renders a template result or other value to a container.\n *\n * To update a container with new values, reevaluate the template literal and\n * call `render` with the new result.\n *\n * @param result Any value renderable by NodePart - typically a TemplateResult\n *     created by evaluating a template tag like `html` or `svg`.\n * @param container A DOM parent to render to. The entire contents are either\n *     replaced, or efficiently updated if the same result type was previous\n *     rendered there.\n * @param options RenderOptions for the entire render tree rendered to this\n *     container. Render options must *not* change between renders to the same\n *     container, as those changes will not effect previously rendered DOM.\n */\nexport const render =\n    (result: unknown,\n     container: Element|DocumentFragment,\n     options?: Partial<RenderOptions>) => {\n      let part = parts.get(container);\n      if (part === undefined) {\n        removeNodes(container, container.firstChild);\n        parts.set(container, part = new NodePart({\n                               templateFactory,\n                               ...options,\n                             }));\n        part.appendInto(container);\n      }\n      part.setValue(result);\n      part.commit();\n    };\n","/**\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\nimport {TemplateResult} from './template-result.js';\nimport {marker, Template} from './template.js';\n\n/**\n * A function type that creates a Template from a TemplateResult.\n *\n * This is a hook into the template-creation process for rendering that\n * requires some modification of templates before they're used, like ShadyCSS,\n * which must add classes to elements and remove styles.\n *\n * Templates should be cached as aggressively as possible, so that many\n * TemplateResults produced from the same expression only do the work of\n * creating the Template the first time.\n *\n * Templates are usually cached by TemplateResult.strings and\n * TemplateResult.type, but may be cached by other keys if this function\n * modifies the template.\n *\n * Note that currently TemplateFactories must not add, remove, or reorder\n * expressions, because there is no way to describe such a modification\n * to render() so that values are interpolated to the correct place in the\n * template instances.\n */\nexport type TemplateFactory = (result: TemplateResult) => Template;\n\n/**\n * The default TemplateFactory which caches Templates keyed on\n * result.type and result.strings.\n */\nexport function templateFactory(result: TemplateResult) {\n  let templateCache = templateCaches.get(result.type);\n  if (templateCache === undefined) {\n    templateCache = {\n      stringsArray: new WeakMap<TemplateStringsArray, Template>(),\n      keyString: new Map<string, Template>()\n    };\n    templateCaches.set(result.type, templateCache);\n  }\n\n  let template = templateCache.stringsArray.get(result.strings);\n  if (template !== undefined) {\n    return template;\n  }\n\n  // If the TemplateStringsArray is new, generate a key from the strings\n  // This key is shared between all templates with identical content\n  const key = result.strings.join(marker);\n\n  // Check if we already have a Template for this key\n  template = templateCache.keyString.get(key);\n  if (template === undefined) {\n    // If we have not seen this key before, create a new Template\n    template = new Template(result, result.getTemplateElement());\n    // Cache the Template for this key\n    templateCache.keyString.set(key, template);\n  }\n\n  // Cache all future queries for this TemplateStringsArray\n  templateCache.stringsArray.set(result.strings, template);\n  return template;\n}\n\n/**\n * The first argument to JS template tags retain identity across multiple\n * calls to a tag for the same literal, so we can cache work done per literal\n * in a Map.\n *\n * Safari currently has a bug which occasionally breaks this behavior, so we\n * need to cache the Template at two levels. We first cache the\n * TemplateStringsArray, and if that fails, we cache a key constructed by\n * joining the strings array.\n */\nexport interface TemplateCache {\n  readonly stringsArray: WeakMap<TemplateStringsArray, Template>;\n  readonly keyString: Map<string, Template>;\n}\n\nexport const templateCaches = new Map<string, TemplateCache>();\n","/**\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\nimport {isCEPolyfill} from './dom.js';\nimport {Part} from './part.js';\nimport {RenderOptions} from './render-options.js';\nimport {TemplateProcessor} from './template-processor.js';\nimport {isTemplatePartActive, Template, TemplatePart} from './template.js';\n\n/**\n * An instance of a `Template` that can be attached to the DOM and updated\n * with new values.\n */\nexport class TemplateInstance {\n  private readonly __parts: Array<Part|undefined> = [];\n  readonly processor: TemplateProcessor;\n  readonly options: RenderOptions;\n  readonly template: Template;\n\n  constructor(\n      template: Template, processor: TemplateProcessor,\n      options: RenderOptions) {\n    this.template = template;\n    this.processor = processor;\n    this.options = options;\n  }\n\n  update(values: readonly unknown[]) {\n    let i = 0;\n    for (const part of this.__parts) {\n      if (part !== undefined) {\n        part.setValue(values[i]);\n      }\n      i++;\n    }\n    for (const part of this.__parts) {\n      if (part !== undefined) {\n        part.commit();\n      }\n    }\n  }\n\n  _clone(): DocumentFragment {\n    // There are a number of steps in the lifecycle of a template instance's\n    // DOM fragment:\n    //  1. Clone - create the instance fragment\n    //  2. Adopt - adopt into the main document\n    //  3. Process - find part markers and create parts\n    //  4. Upgrade - upgrade custom elements\n    //  5. Update - set node, attribute, property, etc., values\n    //  6. Connect - connect to the document. Optional and outside of this\n    //     method.\n    //\n    // We have a few constraints on the ordering of these steps:\n    //  * We need to upgrade before updating, so that property values will pass\n    //    through any property setters.\n    //  * We would like to process before upgrading so that we're sure that the\n    //    cloned fragment is inert and not disturbed by self-modifying DOM.\n    //  * We want custom elements to upgrade even in disconnected fragments.\n    //\n    // Given these constraints, with full custom elements support we would\n    // prefer the order: Clone, Process, Adopt, Upgrade, Update, Connect\n    //\n    // But Safari does not implement CustomElementRegistry#upgrade, so we\n    // can not implement that order and still have upgrade-before-update and\n    // upgrade disconnected fragments. So we instead sacrifice the\n    // process-before-upgrade constraint, since in Custom Elements v1 elements\n    // must not modify their light DOM in the constructor. We still have issues\n    // when co-existing with CEv0 elements like Polymer 1, and with polyfills\n    // that don't strictly adhere to the no-modification rule because shadow\n    // DOM, which may be created in the constructor, is emulated by being placed\n    // in the light DOM.\n    //\n    // The resulting order is on native is: Clone, Adopt, Upgrade, Process,\n    // Update, Connect. document.importNode() performs Clone, Adopt, and Upgrade\n    // in one step.\n    //\n    // The Custom Elements v1 polyfill supports upgrade(), so the order when\n    // polyfilled is the more ideal: Clone, Process, Adopt, Upgrade, Update,\n    // Connect.\n\n    const fragment = isCEPolyfill ?\n        this.template.element.content.cloneNode(true) as DocumentFragment :\n        document.importNode(this.template.element.content, true);\n\n    const stack: Node[] = [];\n    const parts = this.template.parts;\n    // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null\n    const walker = document.createTreeWalker(\n        fragment,\n        133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */,\n        null,\n        false);\n    let partIndex = 0;\n    let nodeIndex = 0;\n    let part: TemplatePart;\n    let node = walker.nextNode();\n    // Loop through all the nodes and parts of a template\n    while (partIndex < parts.length) {\n      part = parts[partIndex];\n      if (!isTemplatePartActive(part)) {\n        this.__parts.push(undefined);\n        partIndex++;\n        continue;\n      }\n\n      // Progress the tree walker until we find our next part's node.\n      // Note that multiple parts may share the same node (attribute parts\n      // on a single element), so this loop may not run at all.\n      while (nodeIndex < part.index) {\n        nodeIndex++;\n        if (node!.nodeName === 'TEMPLATE') {\n          stack.push(node!);\n          walker.currentNode = (node as HTMLTemplateElement).content;\n        }\n        if ((node = walker.nextNode()) === null) {\n          // We've exhausted the content inside a nested template element.\n          // Because we still have parts (the outer for-loop), we know:\n          // - There is a template in the stack\n          // - The walker will find a nextNode outside the template\n          walker.currentNode = stack.pop()!;\n          node = walker.nextNode();\n        }\n      }\n\n      // We've arrived at our part's node.\n      if (part.type === 'node') {\n        const part = this.processor.handleTextExpression(this.options);\n        part.insertAfterNode(node!.previousSibling!);\n        this.__parts.push(part);\n      } else {\n        this.__parts.push(...this.processor.handleAttributeExpressions(\n            node as Element, part.name, part.strings, this.options));\n      }\n      partIndex++;\n    }\n\n    if (isCEPolyfill) {\n      document.adoptNode(fragment);\n      customElements.upgrade(fragment);\n    }\n    return fragment;\n  }\n}\n","/**\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/**\n * @module lit-html\n */\n\nimport {reparentNodes} from './dom.js';\nimport {TemplateProcessor} from './template-processor.js';\nimport {boundAttributeSuffix, lastAttributeNameRegex, marker, nodeMarker} from './template.js';\n\ndeclare const trustedTypes: typeof window.trustedTypes;\n/**\n * Our TrustedTypePolicy for HTML which is declared using the html template\n * tag function.\n *\n * That HTML is a developer-authored constant, and is parsed with innerHTML\n * before any untrusted expressions have been mixed in. Therefor it is\n * considered safe by construction.\n */\nconst policy = window.trustedTypes &&\n    trustedTypes!.createPolicy('lit-html', {createHTML: (s) => s});\n\nconst commentMarker = ` ${marker} `;\n\n/**\n * The return type of `html`, which holds a Template and the values from\n * interpolated expressions.\n */\nexport class TemplateResult {\n  readonly strings: TemplateStringsArray;\n  readonly values: readonly unknown[];\n  readonly type: string;\n  readonly processor: TemplateProcessor;\n\n  constructor(\n      strings: TemplateStringsArray, values: readonly unknown[], type: string,\n      processor: TemplateProcessor) {\n    this.strings = strings;\n    this.values = values;\n    this.type = type;\n    this.processor = processor;\n  }\n\n  /**\n   * Returns a string of HTML used to create a `<template>` element.\n   */\n  getHTML(): string {\n    const l = this.strings.length - 1;\n    let html = '';\n    let isCommentBinding = false;\n\n    for (let i = 0; i < l; i++) {\n      const s = this.strings[i];\n      // For each binding we want to determine the kind of marker to insert\n      // into the template source before it's parsed by the browser's HTML\n      // parser. The marker type is based on whether the expression is in an\n      // attribute, text, or comment position.\n      //   * For node-position bindings we insert a comment with the marker\n      //     sentinel as its text content, like <!--{{lit-guid}}-->.\n      //   * For attribute bindings we insert just the marker sentinel for the\n      //     first binding, so that we support unquoted attribute bindings.\n      //     Subsequent bindings can use a comment marker because multi-binding\n      //     attributes must be quoted.\n      //   * For comment bindings we insert just the marker sentinel so we don't\n      //     close the comment.\n      //\n      // The following code scans the template source, but is *not* an HTML\n      // parser. We don't need to track the tree structure of the HTML, only\n      // whether a binding is inside a comment, and if not, if it appears to be\n      // the first binding in an attribute.\n      const commentOpen = s.lastIndexOf('<!--');\n      // We're in comment position if we have a comment open with no following\n      // comment close. Because <-- can appear in an attribute value there can\n      // be false positives.\n      isCommentBinding = (commentOpen > -1 || isCommentBinding) &&\n          s.indexOf('-->', commentOpen + 1) === -1;\n      // Check to see if we have an attribute-like sequence preceding the\n      // expression. This can match \"name=value\" like structures in text,\n      // comments, and attribute values, so there can be false-positives.\n      const attributeMatch = lastAttributeNameRegex.exec(s);\n      if (attributeMatch === null) {\n        // We're only in this branch if we don't have a attribute-like\n        // preceding sequence. For comments, this guards against unusual\n        // attribute values like <div foo=\"<!--${'bar'}\">. Cases like\n        // <!-- foo=${'bar'}--> are handled correctly in the attribute branch\n        // below.\n        html += s + (isCommentBinding ? commentMarker : nodeMarker);\n      } else {\n        // For attributes we use just a marker sentinel, and also append a\n        // $lit$ suffix to the name to opt-out of attribute-specific parsing\n        // that IE and Edge do for style and certain SVG attributes.\n        html += s.substr(0, attributeMatch.index) + attributeMatch[1] +\n            attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] +\n            marker;\n      }\n    }\n    html += this.strings[l];\n    return html;\n  }\n\n  getTemplateElement(): HTMLTemplateElement {\n    const template = document.createElement('template');\n    let value = this.getHTML();\n    if (policy !== undefined) {\n      // this is secure because `this.strings` is a TemplateStringsArray.\n      // TODO: validate this when\n      // https://github.com/tc39/proposal-array-is-template-object is\n      // implemented.\n      value = policy.createHTML(value) as unknown as string;\n    }\n    template.innerHTML = value;\n    return template;\n  }\n}\n\n/**\n * A TemplateResult for SVG fragments.\n *\n * This class wraps HTML in an `<svg>` tag in order to parse its contents in the\n * SVG namespace, then modifies the template to remove the `<svg>` tag so that\n * clones only container the original fragment.\n */\nexport class SVGTemplateResult extends TemplateResult {\n  getHTML(): string {\n    return `<svg>${super.getHTML()}</svg>`;\n  }\n\n  getTemplateElement(): HTMLTemplateElement {\n    const template = super.getTemplateElement();\n    const content = template.content;\n    const svgElement = content.firstChild!;\n    content.removeChild(svgElement);\n    reparentNodes(content, svgElement.firstChild);\n    return template;\n  }\n}\n","/**\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\nimport {TemplateResult} from './template-result.js';\n\n/**\n * An expression marker with embedded unique key to avoid collision with\n * possible text in templates.\n */\nexport const marker = `{{lit-${String(Math.random()).slice(2)}}}`;\n\n/**\n * An expression marker used text-positions, multi-binding attributes, and\n * attributes with markup-like text values.\n */\nexport const nodeMarker = `<!--${marker}-->`;\n\nexport const markerRegex = new RegExp(`${marker}|${nodeMarker}`);\n\n/**\n * Suffix appended to all bound attribute names.\n */\nexport const boundAttributeSuffix = '$lit$';\n\n/**\n * An updatable Template that tracks the location of dynamic parts.\n */\nexport class Template {\n  readonly parts: TemplatePart[] = [];\n  readonly element: HTMLTemplateElement;\n\n  constructor(result: TemplateResult, element: HTMLTemplateElement) {\n    this.element = element;\n\n    const nodesToRemove: Node[] = [];\n    const stack: Node[] = [];\n    // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null\n    const walker = document.createTreeWalker(\n        element.content,\n        133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */,\n        null,\n        false);\n    // Keeps track of the last index associated with a part. We try to delete\n    // unnecessary nodes, but we never want to associate two different parts\n    // to the same index. They must have a constant node between.\n    let lastPartIndex = 0;\n    let index = -1;\n    let partIndex = 0;\n    const {strings, values: {length}} = result;\n    while (partIndex < length) {\n      const node = walker.nextNode() as Element | Comment | Text | null;\n      if (node === null) {\n        // We've exhausted the content inside a nested template element.\n        // Because we still have parts (the outer for-loop), we know:\n        // - There is a template in the stack\n        // - The walker will find a nextNode outside the template\n        walker.currentNode = stack.pop()!;\n        continue;\n      }\n      index++;\n\n      if (node.nodeType === 1 /* Node.ELEMENT_NODE */) {\n        if ((node as Element).hasAttributes()) {\n          const attributes = (node as Element).attributes;\n          const {length} = attributes;\n          // Per\n          // https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap,\n          // attributes are not guaranteed to be returned in document order.\n          // In particular, Edge/IE can return them out of order, so we cannot\n          // assume a correspondence between part index and attribute index.\n          let count = 0;\n          for (let i = 0; i < length; i++) {\n            if (endsWith(attributes[i].name, boundAttributeSuffix)) {\n              count++;\n            }\n          }\n          while (count-- > 0) {\n            // Get the template literal section leading up to the first\n            // expression in this attribute\n            const stringForPart = strings[partIndex];\n            // Find the attribute name\n            const name = lastAttributeNameRegex.exec(stringForPart)![2];\n            // Find the corresponding attribute\n            // All bound attributes have had a suffix added in\n            // TemplateResult#getHTML to opt out of special attribute\n            // handling. To look up the attribute value we also need to add\n            // the suffix.\n            const attributeLookupName =\n                name.toLowerCase() + boundAttributeSuffix;\n            const attributeValue =\n                (node as Element).getAttribute(attributeLookupName)!;\n            (node as Element).removeAttribute(attributeLookupName);\n            const statics = attributeValue.split(markerRegex);\n            this.parts.push({type: 'attribute', index, name, strings: statics});\n            partIndex += statics.length - 1;\n          }\n        }\n        if ((node as Element).tagName === 'TEMPLATE') {\n          stack.push(node);\n          walker.currentNode = (node as HTMLTemplateElement).content;\n        }\n      } else if (node.nodeType === 3 /* Node.TEXT_NODE */) {\n        const data = (node as Text).data;\n        if (data.indexOf(marker) >= 0) {\n          const parent = node.parentNode!;\n          const strings = data.split(markerRegex);\n          const lastIndex = strings.length - 1;\n          // Generate a new text node for each literal section\n          // These nodes are also used as the markers for node parts\n          for (let i = 0; i < lastIndex; i++) {\n            let insert: Node;\n            let s = strings[i];\n            if (s === '') {\n              insert = createMarker();\n            } else {\n              const match = lastAttributeNameRegex.exec(s);\n              if (match !== null && endsWith(match[2], boundAttributeSuffix)) {\n                s = s.slice(0, match.index) + match[1] +\n                    match[2].slice(0, -boundAttributeSuffix.length) + match[3];\n              }\n              insert = document.createTextNode(s);\n            }\n            parent.insertBefore(insert, node);\n            this.parts.push({type: 'node', index: ++index});\n          }\n          // If there's no text, we must insert a comment to mark our place.\n          // Else, we can trust it will stick around after cloning.\n          if (strings[lastIndex] === '') {\n            parent.insertBefore(createMarker(), node);\n            nodesToRemove.push(node);\n          } else {\n            (node as Text).data = strings[lastIndex];\n          }\n          // We have a part for each match found\n          partIndex += lastIndex;\n        }\n      } else if (node.nodeType === 8 /* Node.COMMENT_NODE */) {\n        if ((node as Comment).data === marker) {\n          const parent = node.parentNode!;\n          // Add a new marker node to be the startNode of the Part if any of\n          // the following are true:\n          //  * We don't have a previousSibling\n          //  * The previousSibling is already the start of a previous part\n          if (node.previousSibling === null || index === lastPartIndex) {\n            index++;\n            parent.insertBefore(createMarker(), node);\n          }\n          lastPartIndex = index;\n          this.parts.push({type: 'node', index});\n          // If we don't have a nextSibling, keep this node so we have an end.\n          // Else, we can remove it to save future costs.\n          if (node.nextSibling === null) {\n            (node as Comment).data = '';\n          } else {\n            nodesToRemove.push(node);\n            index--;\n          }\n          partIndex++;\n        } else {\n          let i = -1;\n          while ((i = (node as Comment).data.indexOf(marker, i + 1)) !== -1) {\n            // Comment node has a binding marker inside, make an inactive part\n            // The binding won't work, but subsequent bindings will\n            // TODO (justinfagnani): consider whether it's even worth it to\n            // make bindings in comments work\n            this.parts.push({type: 'node', index: -1});\n            partIndex++;\n          }\n        }\n      }\n    }\n\n    // Remove text binding nodes after the walk to not disturb the TreeWalker\n    for (const n of nodesToRemove) {\n      n.parentNode!.removeChild(n);\n    }\n  }\n}\n\nconst endsWith = (str: string, suffix: string): boolean => {\n  const index = str.length - suffix.length;\n  return index >= 0 && str.slice(index) === suffix;\n};\n\n/**\n * A placeholder for a dynamic expression in an HTML template.\n *\n * There are two built-in part types: AttributePart and NodePart. NodeParts\n * always represent a single dynamic expression, while AttributeParts may\n * represent as many expressions are contained in the attribute.\n *\n * A Template's parts are mutable, so parts can be replaced or modified\n * (possibly to implement different template semantics). The contract is that\n * parts can only be replaced, not removed, added or reordered, and parts must\n * always consume the correct number of values in their `update()` method.\n *\n * TODO(justinfagnani): That requirement is a little fragile. A\n * TemplateInstance could instead be more careful about which values it gives\n * to Part.update().\n */\nexport type TemplatePart = {\n  readonly type: 'node'; index: number;\n}|{\n  readonly type: 'attribute';\n  index: number;\n  readonly name: string;\n  readonly strings: ReadonlyArray<string>;\n};\n\nexport const isTemplatePartActive = (part: TemplatePart) => part.index !== -1;\n\n// Allows `document.createComment('')` to be renamed for a\n// small manual size-savings.\nexport const createMarker = () => document.createComment('');\n\n/**\n * This regex extracts the attribute name preceding an attribute-position\n * expression. It does this by matching the syntax allowed for attributes\n * against the string literal directly preceding the expression, assuming that\n * the expression is in an attribute-value position.\n *\n * See attributes in the HTML spec:\n * https://www.w3.org/TR/html5/syntax.html#elements-attributes\n *\n * \" \\x09\\x0a\\x0c\\x0d\" are HTML space characters:\n * https://www.w3.org/TR/html5/infrastructure.html#space-characters\n *\n * \"\\0-\\x1F\\x7F-\\x9F\" are Unicode control characters, which includes every\n * space character except \" \".\n *\n * So an attribute is:\n *  * The name: any character except a control character, space character, ('),\n *    (\"), \">\", \"=\", or \"/\"\n *  * Followed by zero or more space characters\n *  * Followed by \"=\"\n *  * Followed by zero or more space characters\n *  * Followed by:\n *    * Any character except space, ('), (\"), \"<\", \">\", \"=\", (`), or\n *    * (\") then any non-(\"), or\n *    * (') then any non-(')\n */\nexport const lastAttributeNameRegex =\n    // eslint-disable-next-line no-control-regex\n    /([ \\x09\\x0a\\x0c\\x0d])([^\\0-\\x1F\\x7F-\\x9F \"'>=/]+)([ \\x09\\x0a\\x0c\\x0d]*=[ \\x09\\x0a\\x0c\\x0d]*(?:[^ \\x09\\x0a\\x0c\\x0d\"'`<>=]*|\"[^\"]*|'[^']*))$/;\n","/**\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\nimport {Part} from './part.js';\nimport {AttributeCommitter, BooleanAttributePart, EventPart, NodePart, PropertyCommitter} from './parts.js';\nimport {RenderOptions} from './render-options.js';\nimport {TemplateProcessor} from './template-processor.js';\n\n/**\n * Creates Parts when a template is instantiated.\n */\nexport class DefaultTemplateProcessor implements TemplateProcessor {\n  /**\n   * Create parts for an attribute-position binding, given the event, attribute\n   * name, and string literals.\n   *\n   * @param element The element containing the binding\n   * @param name  The attribute name\n   * @param strings The string literals. There are always at least two strings,\n   *   event for fully-controlled bindings with a single expression.\n   */\n  handleAttributeExpressions(\n      element: Element, name: string, strings: string[],\n      options: RenderOptions): ReadonlyArray<Part> {\n    const prefix = name[0];\n    if (prefix === '.') {\n      const committer = new PropertyCommitter(element, name.slice(1), strings);\n      return committer.parts;\n    }\n    if (prefix === '@') {\n      return [new EventPart(element, name.slice(1), options.eventContext)];\n    }\n    if (prefix === '?') {\n      return [new BooleanAttributePart(element, name.slice(1), strings)];\n    }\n    const committer = new AttributeCommitter(element, name, strings);\n    return committer.parts;\n  }\n  /**\n   * Create parts for a text-position binding.\n   * @param templateFactory\n   */\n  handleTextExpression(options: RenderOptions) {\n    return new NodePart(options);\n  }\n}\n\nexport const defaultTemplateProcessor = new DefaultTemplateProcessor();\n","/**\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/**\n *\n * Main lit-html module.\n *\n * Main exports:\n *\n * -  [[html]]\n * -  [[svg]]\n * -  [[render]]\n *\n * @packageDocumentation\n */\n\n/**\n * Do not remove this comment; it keeps typedoc from misplacing the module\n * docs.\n */\nimport {defaultTemplateProcessor} from './lib/default-template-processor.js';\nimport {SVGTemplateResult, TemplateResult} from './lib/template-result.js';\n\nexport {DefaultTemplateProcessor, defaultTemplateProcessor} from './lib/default-template-processor.js';\nexport {directive, DirectiveFn, isDirective} from './lib/directive.js';\n// TODO(justinfagnani): remove line when we get NodePart moving methods\nexport {removeNodes, reparentNodes} from './lib/dom.js';\nexport {noChange, nothing, Part} from './lib/part.js';\nexport {AttributeCommitter, AttributePart, BooleanAttributePart, EventPart, isIterable, isPrimitive, NodePart, PropertyCommitter, PropertyPart} from './lib/parts.js';\nexport {RenderOptions} from './lib/render-options.js';\nexport {parts, render} from './lib/render.js';\nexport {templateCaches, templateFactory} from './lib/template-factory.js';\nexport {TemplateInstance} from './lib/template-instance.js';\nexport {TemplateProcessor} from './lib/template-processor.js';\nexport {SVGTemplateResult, TemplateResult} from './lib/template-result.js';\nexport {createMarker, isTemplatePartActive, Template} from './lib/template.js';\n\ndeclare global {\n  interface Window {\n    litHtmlVersions: string[];\n  }\n}\n\n// IMPORTANT: do not change the property name or the assignment expression.\n// This line will be used in regexes to search for lit-html usage.\n// TODO(justinfagnani): inject version number at build time\nif (typeof window !== 'undefined') {\n  (window['litHtmlVersions'] || (window['litHtmlVersions'] = [])).push('1.4.1');\n}\n\n/**\n * Interprets a template literal as an HTML template that can efficiently\n * render to and update a container.\n */\nexport const html = (strings: TemplateStringsArray, ...values: unknown[]) =>\n    new TemplateResult(strings, values, 'html', defaultTemplateProcessor);\n\n/**\n * Interprets a template literal as an SVG template that can efficiently\n * render to and update a container.\n */\nexport const svg = (strings: TemplateStringsArray, ...values: unknown[]) =>\n    new SVGTemplateResult(strings, values, 'svg', defaultTemplateProcessor);\n"],"names":["version","stablePrefix","Base","StableSelectorMixinImpl","args","_this","key","value","stableSelector","this","constructor","dataset","autoid","_cleanAndCreateMutationObserver","create","window","requestAnimationFrame","_this2","linkNode","transposeAttributes","linkNodeArg","altAttributesArg","altAttributes","querySelectorAll","forEach","e","anchor","shadowRoot","_e$shadowRoot","querySelector","_this3","_this$shadowRoot","filter","call","attributes","at","test","name","includes","_this3$linkNode","setAttribute","_mutationObserver","disconnect","MutationObserver","mutations","mutation","type","_this4","_this$_mutationObserv","observe","exports","carbonElement","tagName","classOrDescriptor","legacyCustomElement","clazz","customElements","define","error","console","warn","standardCustomElement","descriptor","kind","elements","finisher","standardProperty","options","element","createProperty","Symbol","placement","initializer","legacyProperty","proto","property","protoOrDescriptor","undefined","internalProperty","attribute","hasChanged","state","query","selector","cache","get","renderRoot","enumerable","configurable","prop","legacyQuery","standardQuery","queryAsync","updateComplete","queryAll","Object","defineProperty","standardEventOptions","assign","prototype","legacyEventOptions","eventOptions","ElementProto","Element","legacyMatches","msMatchesSelector","webkitMatchesSelector","queryAssignedNodes","slotName","flatten","slotSelector","slot","nodes","assignedNodes","node","nodeType","Node","ELEMENT_NODE","matches","setHostListener","Clazz","hostListeners","_hostListeners","Error","HostListener","targetOrDescriptor","HostListenerStandard","previousValues","WeakMap","ifDefined","directive","part","previousValue","AttributePart","has","committer","removeAttribute","setValue","set","attributesMapCache","spread","attributesInfo","PropertyPart","parts","length","oldAttributesInfo","keys","is","EVENT_NAME_FORMAT","HostListenerMixinImpl","_defineProperty","Set","connectedCallback","listenerName","tokens","exec","targetName","unprefixedType","target","document","ownerDocument","defaultView","parentRoot","getRootNode","_handles","add","on","_unprefixedType","disconnectedCallback","handle","release","delete","prefix","settings","selectorTabbable","attachEventListeners","elem","callback","handles","propName","eventDescriptor","event","_len","arguments","Array","_key","addEventListener","apply","removeEventListener","booleanSerializer","numberSerializer","String","createReactCustomElementType","nonAttributeProps","descriptorItem","CustomElementType","listener","props","currentTarget","_elem","_eventListenersHandle","_handleEvent","updateProps","prevProps","prevValue","componentDidMount","componentDidUpdate","render","_this$props","children","innerRef","_objectWithoutProperties","mergedRef","mergeRefs","refs","el","ref","current","_handleElemRef","createElement","_objectSpread","convertProps","reduce","acc","converted","convertProp","serialize","Component","forwardRef","module","obj","__esModule","_decorate","decorators","factory","superClass","mixins","api","_getDecoratorsApi","i","r","O","initializeInstanceElements","decorated","decorateClass","newElements","isSameElement","other","find","_isDataDescriptor","_hasDecorators","ReferenceError","_coalesceGetterSetter","push","_coalesceClassElements","d","map","_createElementDescriptor","initializeClassElements","F","runClassFinishers","finishers","elementsDefinitionOrder","defineClassElement","receiver","writable","placements","own","addElementPlacement","elementFinishersExtras","decorateElement","extras","result","decorateConstructor","silent","indexOf","TypeError","splice","elementObject","fromElementDescriptor","elementFinisherExtras","toElementFinisherExtras","newExtras","j","fromClassDescriptor","elementsAndFinisher","toClassDescriptor","k","toStringTag","toElementDescriptors","elementObjects","arr","arrayWithHoles","iterableToArray","unsupportedIterableToArray","nonIterableRest","toElementDescriptor","disallowProperty","toPropertyKey","_optionalCallableProperty","newConstructor","objectType","def","desc","_get","Reflect","bind","base","object","hasOwnProperty","getPrototypeOf","getOwnPropertyDescriptor","_taggedTemplateLiteral","strings","raw","slice","freeze","defineProperties","removeNodesFromTemplate","template","nodesToRemove","content","walker","createTreeWalker","partIndex","nextActiveIndexInTemplateParts","nodeIndex","removeCount","nodesToRemoveInTemplate","currentRemovingNode","nextNode","currentNode","previousSibling","index","n","parentNode","removeChild","countNodes","count","isTemplatePartActive","getTemplateCacheKey","scopeName","compatibleShadyCSSVersion","ShadyCSS","prepareTemplateDom","shadyTemplateFactory","cacheKey","templateCache","templateCaches","stringsArray","keyString","Map","join","marker","getTemplateElement","Template","TEMPLATE_TYPES","shadyRenderSet","prepareTemplateStyles","renderedDOM","templateElement","styles","condensedStyle","style","textContent","templates","from","s","removeStylesFromLitTemplates","refNode","insertCount","walkerIndex","insertBefore","appendChild","insertNodeIntoTemplate","firstChild","nativeShadow","cloneNode","removes","_construct","Parent","Class","isNativeReflectConstruct","construct","a","instance","Function","setPrototypeOf","_wrapNativeSuper","_cache","fn","toString","Wrapper","JSCompiler_renameProperty","_obj","defaultConverter","toAttribute","Boolean","JSON","stringify","fromAttribute","Number","parse","notEqual","old","defaultPropertyDeclaration","converter","reflect","finalized","UpdatingElement","initialize","_updateState","_updatePromise","Promise","res","_enableUpdatingResolver","_changedProperties","_saveInstanceProperties","requestUpdateInternal","_classProperties","_v","p","_instanceProperties","v","enableUpdating","_attributeToProperty","ctor","attr","_attributeNameForProperty","attrValue","_propertyValueToAttribute","_attributeToPropertyMap","getPropertyOptions","_propertyValueFromAttribute","oldValue","shouldRequestUpdate","_valueHasChanged","_reflectingProperties","_hasRequestedUpdate","_enqueueUpdate","performUpdate","_applyInstanceProperties","shouldUpdate","changedProperties","update","_markUpdated","firstUpdated","updated","_getUpdateComplete","getUpdateComplete","size","_propertyToAttribute","finalize","superProperties","_ensureClassProperties","noAccessor","getPropertyDescriptor","superCtor","properties","propKeys","getOwnPropertyNames","getOwnPropertySymbols","toLowerCase","HTMLElement","customElement","supportsAdoptingStyleSheets","ShadowRoot","Document","CSSStyleSheet","constructionToken","CSSResult","cssText","safeToken","_styleSheet","replaceSync","unsafeCSS","css","values","idx","textFromCSSResult","renderNotImplemented","LitElement","_getUniqueStyles","createRenderRoot","adoptStyles","attachShadow","shadowRootOptions","_styles","adoptedStyleSheets","styleSheet","_needsShimAdoptedStyleSheets","ScopingShim","prepareAdoptedCssText","localName","hasUpdated","styleElement","templateResult","eventContext","userStyles","getStyles","isArray","addStyles","reduceRight","unshift","cssRules","rule","container","hasRendered","needsScoping","host","firstScopeRender","renderContainer","createDocumentFragment","litRender","templateFactory","TemplateInstance","removeNodes","mode","ClassList","classes","changed","classList","getAttribute","split","cls","classString","previousClassesCache","classMap","classInfo","previousClasses","remove","commit","directives","f","isDirective","o","isCEPolyfill","polyfillWrapFlushCallback","reparentNodes","start","end","before","nextSibling","noChange","nothing","isPrimitive","isIterable","iterator","AttributeCommitter","dirty","_createPart","l","text","t","_getValue","NodePart","__pendingValue","startNode","createMarker","endNode","__insert","__commitText","TemplateResult","__commitTemplateResult","__commitNode","__commitIterable","clear","valueAsString","data","createTextNode","processor","fragment","_clone","itemPart","itemParts","item","appendIntoPart","insertAfterPart","BooleanAttributePart","PropertyCommitter","single","eventOptionsSupported","capture","_e","EventPart","eventName","__boundHandleEvent","handleEvent","newListener","oldListener","shouldRemoveListener","once","passive","shouldAddListener","__options","getOptions","appendInto","__parts","importNode","stack","nodeName","pop","handleTextExpression","insertAfterNode","handleAttributeExpressions","adoptNode","upgrade","policy","trustedTypes","createPolicy","createHTML","commentMarker","html","isCommentBinding","commentOpen","lastIndexOf","attributeMatch","lastAttributeNameRegex","nodeMarker","substr","boundAttributeSuffix","getHTML","innerHTML","SVGTemplateResult","svgElement","Math","random","markerRegex","RegExp","lastPartIndex","hasAttributes","endsWith","stringForPart","attributeLookupName","attributeValue","statics","parent","lastIndex","insert","match","str","suffix","createComment","defaultTemplateProcessor","svg"],"sourceRoot":""}