@avs/go-react 0.12.71731 → 0.13.71740

package/demo/node_modules/.vite/deps/chunk-PRUGAEYJ.js

@@ -0,0 +1,4871 @@
+import {
+  dedupingMixin
+} from "./chunk-I2HDYNON.js";
+
+// ../../../node_modules/@polymer/polymer/lib/utils/resolve-url.js
+var CSS_URL_RX = /(url\()([^)]*)(\))/g;
+var ABS_URL = /(^\/[^\/])|(^#)|(^[\w-\d]*:)/;
+var workingURL;
+var resolveDoc;
+function resolveUrl(url, baseURI) {
+  if (url && ABS_URL.test(url)) {
+    return url;
+  }
+  if (url === "//") {
+    return url;
+  }
+  if (workingURL === void 0) {
+    workingURL = false;
+    try {
+      const u = new URL("b", "http://a");
+      u.pathname = "c%20d";
+      workingURL = u.href === "http://a/c%20d";
+    } catch (e) {
+    }
+  }
+  if (!baseURI) {
+    baseURI = document.baseURI || window.location.href;
+  }
+  if (workingURL) {
+    try {
+      return new URL(url, baseURI).href;
+    } catch (e) {
+      return url;
+    }
+  }
+  if (!resolveDoc) {
+    resolveDoc = document.implementation.createHTMLDocument("temp");
+    resolveDoc.base = resolveDoc.createElement("base");
+    resolveDoc.head.appendChild(resolveDoc.base);
+    resolveDoc.anchor = resolveDoc.createElement("a");
+    resolveDoc.body.appendChild(resolveDoc.anchor);
+  }
+  resolveDoc.base.href = baseURI;
+  resolveDoc.anchor.href = url;
+  return resolveDoc.anchor.href || url;
+}
+function resolveCss(cssText, baseURI) {
+  return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {
+    return pre + "'" + resolveUrl(url.replace(/["']/g, ""), baseURI) + "'" + post;
+  });
+}
+function pathFromUrl(url) {
+  return url.substring(0, url.lastIndexOf("/") + 1);
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/settings.js
+var useShadow = !window.ShadyDOM || !window.ShadyDOM.inUse;
+var useNativeCSSProperties = Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss);
+var useNativeCustomElements = !window.customElements.polyfillWrapFlushCallback;
+var supportsAdoptingStyleSheets = useShadow && "adoptedStyleSheets" in Document.prototype && "replaceSync" in CSSStyleSheet.prototype && // Since spec may change, feature detect exact API we need
+(() => {
+  try {
+    const sheet = new CSSStyleSheet();
+    sheet.replaceSync("");
+    const host = document.createElement("div");
+    host.attachShadow({ mode: "open" });
+    host.shadowRoot.adoptedStyleSheets = [sheet];
+    return host.shadowRoot.adoptedStyleSheets[0] === sheet;
+  } catch (e) {
+    return false;
+  }
+})();
+var rootPath = window.Polymer && window.Polymer.rootPath || pathFromUrl(document.baseURI || window.location.href);
+var sanitizeDOMValue = window.Polymer && window.Polymer.sanitizeDOMValue || void 0;
+var passiveTouchGestures = window.Polymer && window.Polymer.setPassiveTouchGestures || false;
+var strictTemplatePolicy = window.Polymer && window.Polymer.strictTemplatePolicy || false;
+var allowTemplateFromDomModule = window.Polymer && window.Polymer.allowTemplateFromDomModule || false;
+var legacyOptimizations = window.Polymer && window.Polymer.legacyOptimizations || false;
+var legacyWarnings = window.Polymer && window.Polymer.legacyWarnings || false;
+var syncInitialRender = window.Polymer && window.Polymer.syncInitialRender || false;
+var legacyUndefined = window.Polymer && window.Polymer.legacyUndefined || false;
+var orderedComputed = window.Polymer && window.Polymer.orderedComputed || false;
+var cancelSyntheticClickEvents = true;
+var removeNestedTemplates = window.Polymer && window.Polymer.removeNestedTemplates || false;
+var fastDomIf = window.Polymer && window.Polymer.fastDomIf || false;
+var suppressTemplateNotifications = window.Polymer && window.Polymer.suppressTemplateNotifications || false;
+var legacyNoObservedAttributes = window.Polymer && window.Polymer.legacyNoObservedAttributes || false;
+var useAdoptedStyleSheetsWithBuiltCSS = window.Polymer && window.Polymer.useAdoptedStyleSheetsWithBuiltCSS || false;
+
+// ../../../node_modules/@polymer/polymer/lib/elements/dom-module.js
+var modules = {};
+var lcModules = {};
+function setModule(id, module) {
+  modules[id] = lcModules[id.toLowerCase()] = module;
+}
+function findModule(id) {
+  return modules[id] || lcModules[id.toLowerCase()];
+}
+function styleOutsideTemplateCheck(inst) {
+  if (inst.querySelector("style")) {
+    console.warn("dom-module %s has style outside template", inst.id);
+  }
+}
+var DomModule = class extends HTMLElement {
+  /** @override */
+  static get observedAttributes() {
+    return ["id"];
+  }
+  /**
+   * Retrieves the element specified by the css `selector` in the module
+   * registered by `id`. For example, this.import('foo', 'img');
+   * @param {string} id The id of the dom-module in which to search.
+   * @param {string=} selector The css selector by which to find the element.
+   * @return {Element} Returns the element which matches `selector` in the
+   * module registered at the specified `id`.
+   *
+   * @export
+   * @nocollapse Referred to indirectly in style-gather.js
+   */
+  static import(id, selector) {
+    if (id) {
+      let m = findModule(id);
+      if (m && selector) {
+        return m.querySelector(selector);
+      }
+      return m;
+    }
+    return null;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * @param {string} name Name of attribute.
+   * @param {?string} old Old value of attribute.
+   * @param {?string} value Current value of attribute.
+   * @param {?string} namespace Attribute namespace.
+   * @return {void}
+   * @override
+   */
+  attributeChangedCallback(name, old, value, namespace) {
+    if (old !== value) {
+      this.register();
+    }
+  }
+  /* eslint-enable no-unused-args */
+  /**
+   * The absolute URL of the original location of this `dom-module`.
+   *
+   * This value will differ from this element's `ownerDocument` in the
+   * following ways:
+   * - Takes into account any `assetpath` attribute added during bundling
+   *   to indicate the original location relative to the bundled location
+   * - Uses the HTMLImports polyfill's `importForElement` API to ensure
+   *   the path is relative to the import document's location since
+   *   `ownerDocument` is not currently polyfilled
+   */
+  get assetpath() {
+    if (!this.__assetpath) {
+      const owner = window.HTMLImports && HTMLImports.importForElement ? HTMLImports.importForElement(this) || document : this.ownerDocument;
+      const url = resolveUrl(
+        this.getAttribute("assetpath") || "",
+        owner.baseURI
+      );
+      this.__assetpath = pathFromUrl(url);
+    }
+    return this.__assetpath;
+  }
+  /**
+   * Registers the dom-module at a given id. This method should only be called
+   * when a dom-module is imperatively created. For
+   * example, `document.createElement('dom-module').register('foo')`.
+   * @param {string=} id The id at which to register the dom-module.
+   * @return {void}
+   */
+  register(id) {
+    id = id || this.id;
+    if (id) {
+      if (strictTemplatePolicy && findModule(id) !== void 0) {
+        setModule(id, null);
+        throw new Error(`strictTemplatePolicy: dom-module ${id} re-registered`);
+      }
+      this.id = id;
+      setModule(id, this);
+      styleOutsideTemplateCheck(this);
+    }
+  }
+};
+DomModule.prototype["modules"] = modules;
+customElements.define("dom-module", DomModule);
+
+// ../../../node_modules/@polymer/polymer/lib/utils/style-gather.js
+var MODULE_STYLE_LINK_SELECTOR = "link[rel=import][type~=css]";
+var INCLUDE_ATTR = "include";
+var SHADY_UNSCOPED_ATTR = "shady-unscoped";
+function importModule(moduleId) {
+  return (
+    /** @type {?DomModule} */
+    DomModule.import(moduleId)
+  );
+}
+function styleForImport(importDoc) {
+  let container = importDoc.body ? importDoc.body : importDoc;
+  const importCss = resolveCss(
+    container.textContent,
+    importDoc.baseURI
+  );
+  const style = document.createElement("style");
+  style.textContent = importCss;
+  return style;
+}
+function stylesFromModules(moduleIds) {
+  const modules2 = moduleIds.trim().split(/\s+/);
+  const styles = [];
+  for (let i = 0; i < modules2.length; i++) {
+    styles.push(...stylesFromModule(modules2[i]));
+  }
+  return styles;
+}
+function stylesFromModule(moduleId) {
+  const m = importModule(moduleId);
+  if (!m) {
+    console.warn("Could not find style data in module named", moduleId);
+    return [];
+  }
+  if (m._styles === void 0) {
+    const styles = [];
+    styles.push(..._stylesFromModuleImports(m));
+    const template = (
+      /** @type {?HTMLTemplateElement} */
+      m.querySelector("template")
+    );
+    if (template) {
+      styles.push(...stylesFromTemplate(
+        template,
+        /** @type {templateWithAssetPath} */
+        m.assetpath
+      ));
+    }
+    m._styles = styles;
+  }
+  return m._styles;
+}
+function stylesFromTemplate(template, baseURI) {
+  if (!template._styles) {
+    const styles = [];
+    const e$ = template.content.querySelectorAll("style");
+    for (let i = 0; i < e$.length; i++) {
+      let e = e$[i];
+      let include = e.getAttribute(INCLUDE_ATTR);
+      if (include) {
+        styles.push(...stylesFromModules(include).filter(function(item, index, self) {
+          return self.indexOf(item) === index;
+        }));
+      }
+      if (baseURI) {
+        e.textContent = resolveCss(
+          e.textContent,
+          /** @type {string} */
+          baseURI
+        );
+      }
+      styles.push(e);
+    }
+    template._styles = styles;
+  }
+  return template._styles;
+}
+function stylesFromModuleImports(moduleId) {
+  let m = importModule(moduleId);
+  return m ? _stylesFromModuleImports(m) : [];
+}
+function _stylesFromModuleImports(module) {
+  const styles = [];
+  const p$ = module.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);
+  for (let i = 0; i < p$.length; i++) {
+    let p = p$[i];
+    if (p.import) {
+      const importDoc = p.import;
+      const unscoped = p.hasAttribute(SHADY_UNSCOPED_ATTR);
+      if (unscoped && !importDoc._unscopedStyle) {
+        const style = styleForImport(importDoc);
+        style.setAttribute(SHADY_UNSCOPED_ATTR, "");
+        importDoc._unscopedStyle = style;
+      } else if (!importDoc._style) {
+        importDoc._style = styleForImport(importDoc);
+      }
+      styles.push(unscoped ? importDoc._unscopedStyle : importDoc._style);
+    }
+  }
+  return styles;
+}
+function cssFromModules(moduleIds) {
+  let modules2 = moduleIds.trim().split(/\s+/);
+  let cssText = "";
+  for (let i = 0; i < modules2.length; i++) {
+    cssText += cssFromModule(modules2[i]);
+  }
+  return cssText;
+}
+function cssFromModule(moduleId) {
+  let m = importModule(moduleId);
+  if (m && m._cssText === void 0) {
+    let cssText = _cssFromModuleImports(m);
+    let t = (
+      /** @type {?HTMLTemplateElement} */
+      m.querySelector("template")
+    );
+    if (t) {
+      cssText += cssFromTemplate(
+        t,
+        /** @type {templateWithAssetPath} */
+        m.assetpath
+      );
+    }
+    m._cssText = cssText || null;
+  }
+  if (!m) {
+    console.warn("Could not find style data in module named", moduleId);
+  }
+  return m && m._cssText || "";
+}
+function cssFromTemplate(template, baseURI) {
+  let cssText = "";
+  const e$ = stylesFromTemplate(template, baseURI);
+  for (let i = 0; i < e$.length; i++) {
+    let e = e$[i];
+    if (e.parentNode) {
+      e.parentNode.removeChild(e);
+    }
+    cssText += e.textContent;
+  }
+  return cssText;
+}
+function _cssFromModuleImports(module) {
+  let cssText = "";
+  let styles = _stylesFromModuleImports(module);
+  for (let i = 0; i < styles.length; i++) {
+    cssText += styles[i].textContent;
+  }
+  return cssText;
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/wrap.js
+var wrap = window["ShadyDOM"] && window["ShadyDOM"]["noPatch"] && window["ShadyDOM"]["wrap"] ? window["ShadyDOM"]["wrap"] : window["ShadyDOM"] ? (n) => ShadyDOM["patch"](n) : (n) => n;
+
+// ../../../node_modules/@polymer/polymer/lib/utils/path.js
+function isPath(path) {
+  return path.indexOf(".") >= 0;
+}
+function root(path) {
+  let dotIndex = path.indexOf(".");
+  if (dotIndex === -1) {
+    return path;
+  }
+  return path.slice(0, dotIndex);
+}
+function isAncestor(base, path) {
+  return base.indexOf(path + ".") === 0;
+}
+function isDescendant(base, path) {
+  return path.indexOf(base + ".") === 0;
+}
+function translate(base, newBase, path) {
+  return newBase + path.slice(base.length);
+}
+function matches(base, path) {
+  return base === path || isAncestor(base, path) || isDescendant(base, path);
+}
+function normalize(path) {
+  if (Array.isArray(path)) {
+    let parts = [];
+    for (let i = 0; i < path.length; i++) {
+      let args = path[i].toString().split(".");
+      for (let j = 0; j < args.length; j++) {
+        parts.push(args[j]);
+      }
+    }
+    return parts.join(".");
+  } else {
+    return path;
+  }
+}
+function split(path) {
+  if (Array.isArray(path)) {
+    return normalize(path).split(".");
+  }
+  return path.toString().split(".");
+}
+function get(root2, path, info) {
+  let prop = root2;
+  let parts = split(path);
+  for (let i = 0; i < parts.length; i++) {
+    if (!prop) {
+      return;
+    }
+    let part = parts[i];
+    prop = prop[part];
+  }
+  if (info) {
+    info.path = parts.join(".");
+  }
+  return prop;
+}
+function set(root2, path, value) {
+  let prop = root2;
+  let parts = split(path);
+  let last = parts[parts.length - 1];
+  if (parts.length > 1) {
+    for (let i = 0; i < parts.length - 1; i++) {
+      let part = parts[i];
+      prop = prop[part];
+      if (!prop) {
+        return;
+      }
+    }
+    prop[last] = value;
+  } else {
+    prop[path] = value;
+  }
+  return parts.join(".");
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/case-map.js
+var caseMap = {};
+var DASH_TO_CAMEL = /-[a-z]/g;
+var CAMEL_TO_DASH = /([A-Z])/g;
+function dashToCamelCase(dash) {
+  return caseMap[dash] || (caseMap[dash] = dash.indexOf("-") < 0 ? dash : dash.replace(
+    DASH_TO_CAMEL,
+    (m) => m[1].toUpperCase()
+  ));
+}
+function camelToDashCase(camel) {
+  return caseMap[camel] || (caseMap[camel] = camel.replace(CAMEL_TO_DASH, "-$1").toLowerCase());
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/async.js
+var microtaskCurrHandle = 0;
+var microtaskLastHandle = 0;
+var microtaskCallbacks = [];
+var microtaskNodeContent = 0;
+var microtaskScheduled = false;
+var microtaskNode = document.createTextNode("");
+new window.MutationObserver(microtaskFlush).observe(microtaskNode, { characterData: true });
+function microtaskFlush() {
+  microtaskScheduled = false;
+  const len = microtaskCallbacks.length;
+  for (let i = 0; i < len; i++) {
+    let cb = microtaskCallbacks[i];
+    if (cb) {
+      try {
+        cb();
+      } catch (e) {
+        setTimeout(() => {
+          throw e;
+        });
+      }
+    }
+  }
+  microtaskCallbacks.splice(0, len);
+  microtaskLastHandle += len;
+}
+var timeOut = {
+  /**
+   * Returns a sub-module with the async interface providing the provided
+   * delay.
+   *
+   * @memberof timeOut
+   * @param {number=} delay Time to wait before calling callbacks in ms
+   * @return {!AsyncInterface} An async timeout interface
+   */
+  after(delay) {
+    return {
+      run(fn) {
+        return window.setTimeout(fn, delay);
+      },
+      cancel(handle) {
+        window.clearTimeout(handle);
+      }
+    };
+  },
+  /**
+   * Enqueues a function called in the next task.
+   *
+   * @memberof timeOut
+   * @param {!Function} fn Callback to run
+   * @param {number=} delay Delay in milliseconds
+   * @return {number} Handle used for canceling task
+   */
+  run(fn, delay) {
+    return window.setTimeout(fn, delay);
+  },
+  /**
+   * Cancels a previously enqueued `timeOut` callback.
+   *
+   * @memberof timeOut
+   * @param {number} handle Handle returned from `run` of callback to cancel
+   * @return {void}
+   */
+  cancel(handle) {
+    window.clearTimeout(handle);
+  }
+};
+var microTask = {
+  /**
+   * Enqueues a function called at microtask timing.
+   *
+   * @memberof microTask
+   * @param {!Function=} callback Callback to run
+   * @return {number} Handle used for canceling task
+   */
+  run(callback) {
+    if (!microtaskScheduled) {
+      microtaskScheduled = true;
+      microtaskNode.textContent = microtaskNodeContent++;
+    }
+    microtaskCallbacks.push(callback);
+    return microtaskCurrHandle++;
+  },
+  /**
+   * Cancels a previously enqueued `microTask` callback.
+   *
+   * @memberof microTask
+   * @param {number} handle Handle returned from `run` of callback to cancel
+   * @return {void}
+   */
+  cancel(handle) {
+    const idx = handle - microtaskLastHandle;
+    if (idx >= 0) {
+      if (!microtaskCallbacks[idx]) {
+        throw new Error("invalid async handle: " + handle);
+      }
+      microtaskCallbacks[idx] = null;
+    }
+  }
+};
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/properties-changed.js
+var microtask = microTask;
+var PropertiesChanged = dedupingMixin(
+  /**
+   * @template T
+   * @param {function(new:T)} superClass Class to apply mixin to.
+   * @return {function(new:T)} superClass with mixin applied.
+   */
+  (superClass) => {
+    class PropertiesChanged2 extends superClass {
+      /**
+       * Creates property accessors for the given property names.
+       * @param {!Object} props Object whose keys are names of accessors.
+       * @return {void}
+       * @protected
+       * @nocollapse
+       */
+      static createProperties(props) {
+        const proto2 = this.prototype;
+        for (let prop in props) {
+          if (!(prop in proto2)) {
+            proto2._createPropertyAccessor(prop);
+          }
+        }
+      }
+      /**
+       * Returns an attribute name that corresponds to the given property.
+       * The attribute name is the lowercased property name. Override to
+       * customize this mapping.
+       * @param {string} property Property to convert
+       * @return {string} Attribute name corresponding to the given property.
+       *
+       * @protected
+       * @nocollapse
+       */
+      static attributeNameForProperty(property) {
+        return property.toLowerCase();
+      }
+      /**
+       * Override point to provide a type to which to deserialize a value to
+       * a given property.
+       * @param {string} name Name of property
+       *
+       * @protected
+       * @nocollapse
+       */
+      static typeForProperty(name) {
+      }
+      //eslint-disable-line no-unused-vars
+      /**
+       * Creates a setter/getter pair for the named property with its own
+       * local storage.  The getter returns the value in the local storage,
+       * and the setter calls `_setProperty`, which updates the local storage
+       * for the property and enqueues a `_propertiesChanged` callback.
+       *
+       * This method may be called on a prototype or an instance.  Calling
+       * this method may overwrite a property value that already exists on
+       * the prototype/instance by creating the accessor.
+       *
+       * @param {string} property Name of the property
+       * @param {boolean=} readOnly When true, no setter is created; the
+       *   protected `_setProperty` function must be used to set the property
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _createPropertyAccessor(property, readOnly) {
+        this._addPropertyToAttributeMap(property);
+        if (!this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor", this))) {
+          this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
+        }
+        if (!this.__dataHasAccessor[property]) {
+          this.__dataHasAccessor[property] = true;
+          this._definePropertyAccessor(property, readOnly);
+        }
+      }
+      /**
+       * Adds the given `property` to a map matching attribute names
+       * to property names, using `attributeNameForProperty`. This map is
+       * used when deserializing attribute values to properties.
+       *
+       * @param {string} property Name of the property
+       * @override
+       */
+      _addPropertyToAttributeMap(property) {
+        if (!this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes", this))) {
+          this.__dataAttributes = Object.assign({}, this.__dataAttributes);
+        }
+        let attr = this.__dataAttributes[property];
+        if (!attr) {
+          attr = this.constructor.attributeNameForProperty(property);
+          this.__dataAttributes[attr] = property;
+        }
+        return attr;
+      }
+      /**
+       * Defines a property accessor for the given property.
+       * @param {string} property Name of the property
+       * @param {boolean=} readOnly When true, no setter is created
+       * @return {void}
+       * @override
+       */
+      _definePropertyAccessor(property, readOnly) {
+        Object.defineProperty(this, property, {
+          /* eslint-disable valid-jsdoc */
+          /** @this {PropertiesChanged} */
+          get() {
+            return this.__data[property];
+          },
+          /** @this {PropertiesChanged} */
+          set: readOnly ? function() {
+          } : function(value) {
+            if (this._setPendingProperty(property, value, true)) {
+              this._invalidateProperties();
+            }
+          }
+          /* eslint-enable */
+        });
+      }
+      constructor() {
+        super();
+        this.__dataEnabled = false;
+        this.__dataReady = false;
+        this.__dataInvalid = false;
+        this.__data = {};
+        this.__dataPending = null;
+        this.__dataOld = null;
+        this.__dataInstanceProps = null;
+        this.__dataCounter = 0;
+        this.__serializing = false;
+        this._initializeProperties();
+      }
+      /**
+       * Lifecycle callback called when properties are enabled via
+       * `_enableProperties`.
+       *
+       * Users may override this function to implement behavior that is
+       * dependent on the element having its property data initialized, e.g.
+       * from defaults (initialized from `constructor`, `_initializeProperties`),
+       * `attributeChangedCallback`, or values propagated from host e.g. via
+       * bindings.  `super.ready()` must be called to ensure the data system
+       * becomes enabled.
+       *
+       * @return {void}
+       * @public
+       * @override
+       */
+      ready() {
+        this.__dataReady = true;
+        this._flushProperties();
+      }
+      /**
+       * Initializes the local storage for property accessors.
+       *
+       * Provided as an override point for performing any setup work prior
+       * to initializing the property accessor system.
+       *
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _initializeProperties() {
+        for (let p in this.__dataHasAccessor) {
+          if (this.hasOwnProperty(p)) {
+            this.__dataInstanceProps = this.__dataInstanceProps || {};
+            this.__dataInstanceProps[p] = this[p];
+            delete this[p];
+          }
+        }
+      }
+      /**
+       * Called at ready time with bag of instance properties that overwrote
+       * accessors when the element upgraded.
+       *
+       * The default implementation sets these properties back into the
+       * setter at ready time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param {Object} props Bag of property values that were overwritten
+       *   when creating property accessors.
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _initializeInstanceProperties(props) {
+        Object.assign(this, props);
+      }
+      /**
+       * Updates the local storage for a property (via `_setPendingProperty`)
+       * and enqueues a `_proeprtiesChanged` callback.
+       *
+       * @param {string} property Name of the property
+       * @param {*} value Value to set
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _setProperty(property, value) {
+        if (this._setPendingProperty(property, value)) {
+          this._invalidateProperties();
+        }
+      }
+      /**
+       * Returns the value for the given property.
+       * @param {string} property Name of property
+       * @return {*} Value for the given property
+       * @protected
+       * @override
+       */
+      _getProperty(property) {
+        return this.__data[property];
+      }
+      /* eslint-disable no-unused-vars */
+      /**
+       * Updates the local storage for a property, records the previous value,
+       * and adds it to the set of "pending changes" that will be passed to the
+       * `_propertiesChanged` callback.  This method does not enqueue the
+       * `_propertiesChanged` callback.
+       *
+       * @param {string} property Name of the property
+       * @param {*} value Value to set
+       * @param {boolean=} ext Not used here; affordance for closure
+       * @return {boolean} Returns true if the property changed
+       * @protected
+       * @override
+       */
+      _setPendingProperty(property, value, ext) {
+        let old = this.__data[property];
+        let changed = this._shouldPropertyChange(property, value, old);
+        if (changed) {
+          if (!this.__dataPending) {
+            this.__dataPending = {};
+            this.__dataOld = {};
+          }
+          if (this.__dataOld && !(property in this.__dataOld)) {
+            this.__dataOld[property] = old;
+          }
+          this.__data[property] = value;
+          this.__dataPending[property] = value;
+        }
+        return changed;
+      }
+      /* eslint-enable */
+      /**
+       * @param {string} property Name of the property
+       * @return {boolean} Returns true if the property is pending.
+       */
+      _isPropertyPending(property) {
+        return !!(this.__dataPending && this.__dataPending.hasOwnProperty(property));
+      }
+      /**
+       * Marks the properties as invalid, and enqueues an async
+       * `_propertiesChanged` callback.
+       *
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _invalidateProperties() {
+        if (!this.__dataInvalid && this.__dataReady) {
+          this.__dataInvalid = true;
+          microtask.run(() => {
+            if (this.__dataInvalid) {
+              this.__dataInvalid = false;
+              this._flushProperties();
+            }
+          });
+        }
+      }
+      /**
+       * Call to enable property accessor processing. Before this method is
+       * called accessor values will be set but side effects are
+       * queued. When called, any pending side effects occur immediately.
+       * For elements, generally `connectedCallback` is a normal spot to do so.
+       * It is safe to call this method multiple times as it only turns on
+       * property accessors once.
+       *
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _enableProperties() {
+        if (!this.__dataEnabled) {
+          this.__dataEnabled = true;
+          if (this.__dataInstanceProps) {
+            this._initializeInstanceProperties(this.__dataInstanceProps);
+            this.__dataInstanceProps = null;
+          }
+          this.ready();
+        }
+      }
+      /**
+       * Calls the `_propertiesChanged` callback with the current set of
+       * pending changes (and old values recorded when pending changes were
+       * set), and resets the pending set of changes. Generally, this method
+       * should not be called in user code.
+       *
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _flushProperties() {
+        this.__dataCounter++;
+        const props = this.__data;
+        const changedProps = this.__dataPending;
+        const old = this.__dataOld;
+        if (this._shouldPropertiesChange(props, changedProps, old)) {
+          this.__dataPending = null;
+          this.__dataOld = null;
+          this._propertiesChanged(props, changedProps, old);
+        }
+        this.__dataCounter--;
+      }
+      /**
+       * Called in `_flushProperties` to determine if `_propertiesChanged`
+       * should be called. The default implementation returns true if
+       * properties are pending. Override to customize when
+       * `_propertiesChanged` is called.
+       * @param {!Object} currentProps Bag of all current accessor values
+       * @param {?Object} changedProps Bag of properties changed since the last
+       *   call to `_propertiesChanged`
+       * @param {?Object} oldProps Bag of previous values for each property
+       *   in `changedProps`
+       * @return {boolean} true if changedProps is truthy
+       * @override
+       */
+      _shouldPropertiesChange(currentProps, changedProps, oldProps) {
+        return Boolean(changedProps);
+      }
+      /**
+       * Callback called when any properties with accessors created via
+       * `_createPropertyAccessor` have been set.
+       *
+       * @param {!Object} currentProps Bag of all current accessor values
+       * @param {?Object} changedProps Bag of properties changed since the last
+       *   call to `_propertiesChanged`
+       * @param {?Object} oldProps Bag of previous values for each property
+       *   in `changedProps`
+       * @return {void}
+       * @protected
+       * @override
+       */
+      _propertiesChanged(currentProps, changedProps, oldProps) {
+      }
+      /**
+       * Method called to determine whether a property value should be
+       * considered as a change and cause the `_propertiesChanged` callback
+       * to be enqueued.
+       *
+       * The default implementation returns `true` if a strict equality
+       * check fails. The method always returns false for `NaN`.
+       *
+       * Override this method to e.g. provide stricter checking for
+       * Objects/Arrays when using immutable patterns.
+       *
+       * @param {string} property Property name
+       * @param {*} value New property value
+       * @param {*} old Previous property value
+       * @return {boolean} Whether the property should be considered a change
+       *   and enqueue a `_proeprtiesChanged` callback
+       * @protected
+       * @override
+       */
+      _shouldPropertyChange(property, value, old) {
+        return (
+          // Strict equality check
+          old !== value && // This ensures (old==NaN, value==NaN) always returns false
+          (old === old || value === value)
+        );
+      }
+      /**
+       * Implements native Custom Elements `attributeChangedCallback` to
+       * set an attribute value to a property via `_attributeToProperty`.
+       *
+       * @param {string} name Name of attribute that changed
+       * @param {?string} old Old attribute value
+       * @param {?string} value New attribute value
+       * @param {?string} namespace Attribute namespace.
+       * @return {void}
+       * @suppress {missingProperties} Super may or may not implement the callback
+       * @override
+       */
+      attributeChangedCallback(name, old, value, namespace) {
+        if (old !== value) {
+          this._attributeToProperty(name, value);
+        }
+        if (super.attributeChangedCallback) {
+          super.attributeChangedCallback(name, old, value, namespace);
+        }
+      }
+      /**
+       * Deserializes an attribute to its associated property.
+       *
+       * This method calls the `_deserializeValue` method to convert the string to
+       * a typed value.
+       *
+       * @param {string} attribute Name of attribute to deserialize.
+       * @param {?string} value of the attribute.
+       * @param {*=} type type to deserialize to, defaults to the value
+       * returned from `typeForProperty`
+       * @return {void}
+       * @override
+       */
+      _attributeToProperty(attribute, value, type) {
+        if (!this.__serializing) {
+          const map = this.__dataAttributes;
+          const property = map && map[attribute] || attribute;
+          this[property] = this._deserializeValue(value, type || this.constructor.typeForProperty(property));
+        }
+      }
+      /**
+       * Serializes a property to its associated attribute.
+       *
+       * @suppress {invalidCasts} Closure can't figure out `this` is an element.
+       *
+       * @param {string} property Property name to reflect.
+       * @param {string=} attribute Attribute name to reflect to.
+       * @param {*=} value Property value to refect.
+       * @return {void}
+       * @override
+       */
+      _propertyToAttribute(property, attribute, value) {
+        this.__serializing = true;
+        value = arguments.length < 3 ? this[property] : value;
+        this._valueToNodeAttribute(
+          /** @type {!HTMLElement} */
+          this,
+          value,
+          attribute || this.constructor.attributeNameForProperty(property)
+        );
+        this.__serializing = false;
+      }
+      /**
+       * Sets a typed value to an HTML attribute on a node.
+       *
+       * This method calls the `_serializeValue` method to convert the typed
+       * value to a string.  If the `_serializeValue` method returns `undefined`,
+       * the attribute will be removed (this is the default for boolean
+       * type `false`).
+       *
+       * @param {Element} node Element to set attribute to.
+       * @param {*} value Value to serialize.
+       * @param {string} attribute Attribute name to serialize to.
+       * @return {void}
+       * @override
+       */
+      _valueToNodeAttribute(node, value, attribute) {
+        const str = this._serializeValue(value);
+        if (attribute === "class" || attribute === "name" || attribute === "slot") {
+          node = /** @type {?Element} */
+          wrap(node);
+        }
+        if (str === void 0) {
+          node.removeAttribute(attribute);
+        } else {
+          node.setAttribute(
+            attribute,
+            // Closure's type for `setAttribute`'s second parameter incorrectly
+            // excludes `TrustedScript`.
+            str === "" && window.trustedTypes ? (
+              /** @type {?} */
+              window.trustedTypes.emptyScript
+            ) : str
+          );
+        }
+      }
+      /**
+       * Converts a typed JavaScript value to a string.
+       *
+       * This method is called when setting JS property values to
+       * HTML attributes.  Users may override this method to provide
+       * serialization for custom types.
+       *
+       * @param {*} value Property value to serialize.
+       * @return {string | undefined} String serialized from the provided
+       * property  value.
+       * @override
+       */
+      _serializeValue(value) {
+        switch (typeof value) {
+          case "boolean":
+            return value ? "" : void 0;
+          default:
+            return value != null ? value.toString() : void 0;
+        }
+      }
+      /**
+       * Converts a string to a typed JavaScript value.
+       *
+       * This method is called when reading HTML attribute values to
+       * JS properties.  Users may override this method to provide
+       * deserialization for custom `type`s. Types for `Boolean`, `String`,
+       * and `Number` convert attributes to the expected types.
+       *
+       * @param {?string} value Value to deserialize.
+       * @param {*=} type Type to deserialize the string to.
+       * @return {*} Typed value deserialized from the provided string.
+       * @override
+       */
+      _deserializeValue(value, type) {
+        switch (type) {
+          case Boolean:
+            return value !== null;
+          case Number:
+            return Number(value);
+          default:
+            return value;
+        }
+      }
+    }
+    return PropertiesChanged2;
+  }
+);
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/property-accessors.js
+var nativeProperties = {};
+var proto = HTMLElement.prototype;
+while (proto) {
+  let props = Object.getOwnPropertyNames(proto);
+  for (let i = 0; i < props.length; i++) {
+    nativeProperties[props[i]] = true;
+  }
+  proto = Object.getPrototypeOf(proto);
+}
+var isTrustedType = (() => {
+  if (!window.trustedTypes) {
+    return () => false;
+  }
+  return (val) => trustedTypes.isHTML(val) || trustedTypes.isScript(val) || trustedTypes.isScriptURL(val);
+})();
+function saveAccessorValue(model, property) {
+  if (!nativeProperties[property]) {
+    let value = model[property];
+    if (value !== void 0) {
+      if (model.__data) {
+        model._setPendingProperty(property, value);
+      } else {
+        if (!model.__dataProto) {
+          model.__dataProto = {};
+        } else if (!model.hasOwnProperty(JSCompiler_renameProperty("__dataProto", model))) {
+          model.__dataProto = Object.create(model.__dataProto);
+        }
+        model.__dataProto[property] = value;
+      }
+    }
+  }
+}
+var PropertyAccessors = dedupingMixin((superClass) => {
+  const base = PropertiesChanged(superClass);
+  class PropertyAccessors2 extends base {
+    /**
+     * Generates property accessors for all attributes in the standard
+     * static `observedAttributes` array.
+     *
+     * Attribute names are mapped to property names using the `dash-case` to
+     * `camelCase` convention
+     *
+     * @return {void}
+     * @nocollapse
+     */
+    static createPropertiesForAttributes() {
+      let a$ = (
+        /** @type {?} */
+        this.observedAttributes
+      );
+      for (let i = 0; i < a$.length; i++) {
+        this.prototype._createPropertyAccessor(dashToCamelCase(a$[i]));
+      }
+    }
+    /**
+     * Returns an attribute name that corresponds to the given property.
+     * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.
+     * @param {string} property Property to convert
+     * @return {string} Attribute name corresponding to the given property.
+     *
+     * @protected
+     * @nocollapse
+     */
+    static attributeNameForProperty(property) {
+      return camelToDashCase(property);
+    }
+    /**
+     * Overrides PropertiesChanged implementation to initialize values for
+     * accessors created for values that already existed on the element
+     * prototype.
+     *
+     * @return {void}
+     * @protected
+     * @override
+     */
+    _initializeProperties() {
+      if (this.__dataProto) {
+        this._initializeProtoProperties(this.__dataProto);
+        this.__dataProto = null;
+      }
+      super._initializeProperties();
+    }
+    /**
+     * Called at instance time with bag of properties that were overwritten
+     * by accessors on the prototype when accessors were created.
+     *
+     * The default implementation sets these properties back into the
+     * setter at instance time.  This method is provided as an override
+     * point for customizing or providing more efficient initialization.
+     *
+     * @param {Object} props Bag of property values that were overwritten
+     *   when creating property accessors.
+     * @return {void}
+     * @protected
+     * @override
+     */
+    _initializeProtoProperties(props) {
+      for (let p in props) {
+        this._setProperty(p, props[p]);
+      }
+    }
+    /**
+     * Ensures the element has the given attribute. If it does not,
+     * assigns the given value to the attribute.
+     *
+     * @suppress {invalidCasts} Closure can't figure out `this` is infact an
+     *     element
+     *
+     * @param {string} attribute Name of attribute to ensure is set.
+     * @param {string} value of the attribute.
+     * @return {void}
+     * @override
+     */
+    _ensureAttribute(attribute, value) {
+      const el = (
+        /** @type {!HTMLElement} */
+        this
+      );
+      if (!el.hasAttribute(attribute)) {
+        this._valueToNodeAttribute(el, value, attribute);
+      }
+    }
+    /**
+     * Overrides PropertiesChanged implemention to serialize objects as JSON.
+     *
+     * @param {*} value Property value to serialize.
+     * @return {string | undefined} String serialized from the provided property
+     *     value.
+     * @override
+     */
+    _serializeValue(value) {
+      switch (typeof value) {
+        case "object":
+          if (value instanceof Date) {
+            return value.toString();
+          } else if (value) {
+            if (isTrustedType(value)) {
+              return (
+                /** @type {?} */
+                value
+              );
+            }
+            try {
+              return JSON.stringify(value);
+            } catch (x) {
+              return "";
+            }
+          }
+        default:
+          return super._serializeValue(value);
+      }
+    }
+    /**
+     * Converts a string to a typed JavaScript value.
+     *
+     * This method is called by Polymer when reading HTML attribute values to
+     * JS properties.  Users may override this method on Polymer element
+     * prototypes to provide deserialization for custom `type`s.  Note,
+     * the `type` argument is the value of the `type` field provided in the
+     * `properties` configuration object for a given property, and is
+     * by convention the constructor for the type to deserialize.
+     *
+     *
+     * @param {?string} value Attribute value to deserialize.
+     * @param {*=} type Type to deserialize the string to.
+     * @return {*} Typed value deserialized from the provided string.
+     * @override
+     */
+    _deserializeValue(value, type) {
+      let outValue;
+      switch (type) {
+        case Object:
+          try {
+            outValue = JSON.parse(
+              /** @type {string} */
+              value
+            );
+          } catch (x) {
+            outValue = value;
+          }
+          break;
+        case Array:
+          try {
+            outValue = JSON.parse(
+              /** @type {string} */
+              value
+            );
+          } catch (x) {
+            outValue = null;
+            console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);
+          }
+          break;
+        case Date:
+          outValue = isNaN(value) ? String(value) : Number(value);
+          outValue = new Date(outValue);
+          break;
+        default:
+          outValue = super._deserializeValue(value, type);
+          break;
+      }
+      return outValue;
+    }
+    /* eslint-enable no-fallthrough */
+    /**
+     * Overrides PropertiesChanged implementation to save existing prototype
+     * property value so that it can be reset.
+     * @param {string} property Name of the property
+     * @param {boolean=} readOnly When true, no setter is created
+     *
+     * When calling on a prototype, any overwritten values are saved in
+     * `__dataProto`, and it is up to the subclasser to decide how/when
+     * to set those properties back into the accessor.  When calling on an
+     * instance, the overwritten value is set via `_setPendingProperty`,
+     * and the user should call `_invalidateProperties` or `_flushProperties`
+     * for the values to take effect.
+     * @protected
+     * @return {void}
+     * @override
+     */
+    _definePropertyAccessor(property, readOnly) {
+      saveAccessorValue(this, property);
+      super._definePropertyAccessor(property, readOnly);
+    }
+    /**
+     * Returns true if this library created an accessor for the given property.
+     *
+     * @param {string} property Property name
+     * @return {boolean} True if an accessor was created
+     * @override
+     */
+    _hasAccessor(property) {
+      return this.__dataHasAccessor && this.__dataHasAccessor[property];
+    }
+    /**
+     * Returns true if the specified property has a pending change.
+     *
+     * @param {string} prop Property name
+     * @return {boolean} True if property has a pending change
+     * @protected
+     * @override
+     */
+    _isPropertyPending(prop) {
+      return Boolean(this.__dataPending && prop in this.__dataPending);
+    }
+  }
+  return PropertyAccessors2;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/template-stamp.js
+var templateExtensions = {
+  "dom-if": true,
+  "dom-repeat": true
+};
+var placeholderBugDetect = false;
+var placeholderBug = false;
+function hasPlaceholderBug() {
+  if (!placeholderBugDetect) {
+    placeholderBugDetect = true;
+    const t = document.createElement("textarea");
+    t.placeholder = "a";
+    placeholderBug = t.placeholder === t.textContent;
+  }
+  return placeholderBug;
+}
+function fixPlaceholder(node) {
+  if (hasPlaceholderBug() && node.localName === "textarea" && node.placeholder && node.placeholder === node.textContent) {
+    node.textContent = null;
+  }
+}
+var copyAttributeWithTemplateEventPolicy = (() => {
+  const polymerTemplateEventAttributePolicy = window.trustedTypes && window.trustedTypes.createPolicy(
+    "polymer-template-event-attribute-policy",
+    {
+      createScript: (x) => x
+    }
+  );
+  return (dest, src, name) => {
+    const value = src.getAttribute(name);
+    if (polymerTemplateEventAttributePolicy && name.startsWith("on-")) {
+      dest.setAttribute(
+        name,
+        polymerTemplateEventAttributePolicy.createScript(value, name)
+      );
+      return;
+    }
+    dest.setAttribute(name, value);
+  };
+})();
+function wrapTemplateExtension(node) {
+  let is = node.getAttribute("is");
+  if (is && templateExtensions[is]) {
+    let t = node;
+    t.removeAttribute("is");
+    node = t.ownerDocument.createElement(is);
+    t.parentNode.replaceChild(node, t);
+    node.appendChild(t);
+    while (t.attributes.length) {
+      const { name } = t.attributes[0];
+      copyAttributeWithTemplateEventPolicy(node, t, name);
+      t.removeAttribute(name);
+    }
+  }
+  return node;
+}
+function findTemplateNode(root2, nodeInfo) {
+  let parent = nodeInfo.parentInfo && findTemplateNode(root2, nodeInfo.parentInfo);
+  if (parent) {
+    for (let n = parent.firstChild, i = 0; n; n = n.nextSibling) {
+      if (nodeInfo.parentIndex === i++) {
+        return n;
+      }
+    }
+  } else {
+    return root2;
+  }
+}
+function applyIdToMap(inst, map, node, nodeInfo) {
+  if (nodeInfo.id) {
+    map[nodeInfo.id] = node;
+  }
+}
+function applyEventListener(inst, node, nodeInfo) {
+  if (nodeInfo.events && nodeInfo.events.length) {
+    for (let j = 0, e$ = nodeInfo.events, e; j < e$.length && (e = e$[j]); j++) {
+      inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
+    }
+  }
+}
+function applyTemplateInfo(inst, node, nodeInfo, parentTemplateInfo) {
+  if (nodeInfo.templateInfo) {
+    node._templateInfo = nodeInfo.templateInfo;
+    node._parentTemplateInfo = parentTemplateInfo;
+  }
+}
+function createNodeEventHandler(context, eventName, methodName) {
+  context = context._methodHost || context;
+  let handler = function(e) {
+    if (context[methodName]) {
+      context[methodName](e, e.detail);
+    } else {
+      console.warn("listener method `" + methodName + "` not defined");
+    }
+  };
+  return handler;
+}
+var TemplateStamp = dedupingMixin(
+  /**
+   * @template T
+   * @param {function(new:T)} superClass Class to apply mixin to.
+   * @return {function(new:T)} superClass with mixin applied.
+   */
+  (superClass) => {
+    class TemplateStamp2 extends superClass {
+      /**
+       * Scans a template to produce template metadata.
+       *
+       * Template-specific metadata are stored in the object returned, and node-
+       * specific metadata are stored in objects in its flattened `nodeInfoList`
+       * array.  Only nodes in the template that were parsed as nodes of
+       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
+       * contains an `index` (`childNodes` index in parent) and optionally
+       * `parent`, which points to node info of its parent (including its index).
+       *
+       * The template metadata object returned from this method has the following
+       * structure (many fields optional):
+       *
+       * ```js
+       *   {
+       *     // Flattened list of node metadata (for nodes that generated metadata)
+       *     nodeInfoList: [
+       *       {
+       *         // `id` attribute for any nodes with id's for generating `$` map
+       *         id: {string},
+       *         // `on-event="handler"` metadata
+       *         events: [
+       *           {
+       *             name: {string},   // event name
+       *             value: {string},  // handler method name
+       *           }, ...
+       *         ],
+       *         // Notes when the template contained a `<slot>` for shady DOM
+       *         // optimization purposes
+       *         hasInsertionPoint: {boolean},
+       *         // For nested `<template>`` nodes, nested template metadata
+       *         templateInfo: {object}, // nested template metadata
+       *         // Metadata to allow efficient retrieval of instanced node
+       *         // corresponding to this metadata
+       *         parentInfo: {number},   // reference to parent nodeInfo>
+       *         parentIndex: {number},  // index in parent's `childNodes` collection
+       *         infoIndex: {number},    // index of this `nodeInfo` in `templateInfo.nodeInfoList`
+       *       },
+       *       ...
+       *     ],
+       *     // When true, the template had the `strip-whitespace` attribute
+       *     // or was nested in a template with that setting
+       *     stripWhitespace: {boolean},
+       *     // For nested templates, nested template content is moved into
+       *     // a document fragment stored here; this is an optimization to
+       *     // avoid the cost of nested template cloning
+       *     content: {DocumentFragment}
+       *   }
+       * ```
+       *
+       * This method kicks off a recursive treewalk as follows:
+       *
+       * ```
+       *    _parseTemplate <---------------------+
+       *      _parseTemplateContent              |
+       *        _parseTemplateNode  <------------|--+
+       *          _parseTemplateNestedTemplate --+  |
+       *          _parseTemplateChildNodes ---------+
+       *          _parseTemplateNodeAttributes
+       *            _parseTemplateNodeAttribute
+       *
+       * ```
+       *
+       * These methods may be overridden to add custom metadata about templates
+       * to either `templateInfo` or `nodeInfo`.
+       *
+       * Note that this method may be destructive to the template, in that
+       * e.g. event annotations may be removed after being noted in the
+       * template metadata.
+       *
+       * @param {!HTMLTemplateElement} template Template to parse
+       * @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer
+       *   template, for parsing nested templates
+       * @return {!TemplateInfo} Parsed template metadata
+       * @nocollapse
+       */
+      static _parseTemplate(template, outerTemplateInfo) {
+        if (!template._templateInfo) {
+          let templateInfo = template._templateInfo = {};
+          templateInfo.nodeInfoList = [];
+          templateInfo.nestedTemplate = Boolean(outerTemplateInfo);
+          templateInfo.stripWhiteSpace = outerTemplateInfo && outerTemplateInfo.stripWhiteSpace || template.hasAttribute && template.hasAttribute("strip-whitespace");
+          this._parseTemplateContent(
+            template,
+            templateInfo,
+            /** @type {?} */
+            { parent: null }
+          );
+        }
+        return template._templateInfo;
+      }
+      /**
+       * See docs for _parseTemplateNode.
+       *
+       * @param {!HTMLTemplateElement} template .
+       * @param {!TemplateInfo} templateInfo .
+       * @param {!NodeInfo} nodeInfo .
+       * @return {boolean} .
+       * @nocollapse
+       */
+      static _parseTemplateContent(template, templateInfo, nodeInfo) {
+        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
+      }
+      /**
+       * Parses template node and adds template and node metadata based on
+       * the current node, and its `childNodes` and `attributes`.
+       *
+       * This method may be overridden to add custom node or template specific
+       * metadata based on this node.
+       *
+       * @param {Node} node Node to parse
+       * @param {!TemplateInfo} templateInfo Template metadata for current template
+       * @param {!NodeInfo} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @nocollapse
+       */
+      static _parseTemplateNode(node, templateInfo, nodeInfo) {
+        let noted = false;
+        let element = (
+          /** @type {!HTMLTemplateElement} */
+          node
+        );
+        if (element.localName == "template" && !element.hasAttribute("preserve-content")) {
+          noted = this._parseTemplateNestedTemplate(element, templateInfo, nodeInfo) || noted;
+        } else if (element.localName === "slot") {
+          templateInfo.hasInsertionPoint = true;
+        }
+        fixPlaceholder(element);
+        if (element.firstChild) {
+          this._parseTemplateChildNodes(element, templateInfo, nodeInfo);
+        }
+        if (element.hasAttributes && element.hasAttributes()) {
+          noted = this._parseTemplateNodeAttributes(element, templateInfo, nodeInfo) || noted;
+        }
+        return noted || nodeInfo.noted;
+      }
+      /**
+       * Parses template child nodes for the given root node.
+       *
+       * This method also wraps whitelisted legacy template extensions
+       * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
+       * wrappers, collapses text nodes, and strips whitespace from the template
+       * if the `templateInfo.stripWhitespace` setting was provided.
+       *
+       * @param {Node} root Root node whose `childNodes` will be parsed
+       * @param {!TemplateInfo} templateInfo Template metadata for current template
+       * @param {!NodeInfo} nodeInfo Node metadata for current template.
+       * @return {void}
+       */
+      static _parseTemplateChildNodes(root2, templateInfo, nodeInfo) {
+        if (root2.localName === "script" || root2.localName === "style") {
+          return;
+        }
+        for (let node = root2.firstChild, parentIndex = 0, next; node; node = next) {
+          if (node.localName == "template") {
+            node = wrapTemplateExtension(node);
+          }
+          next = node.nextSibling;
+          if (node.nodeType === Node.TEXT_NODE) {
+            let n = next;
+            while (n && n.nodeType === Node.TEXT_NODE) {
+              node.textContent += n.textContent;
+              next = n.nextSibling;
+              root2.removeChild(n);
+              n = next;
+            }
+            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
+              root2.removeChild(node);
+              continue;
+            }
+          }
+          let childInfo = (
+            /** @type {!NodeInfo} */
+            { parentIndex, parentInfo: nodeInfo }
+          );
+          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
+            childInfo.infoIndex = templateInfo.nodeInfoList.push(childInfo) - 1;
+          }
+          if (node.parentNode) {
+            parentIndex++;
+          }
+        }
+      }
+      /**
+       * Parses template content for the given nested `<template>`.
+       *
+       * Nested template info is stored as `templateInfo` in the current node's
+       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
+       * It will then be the responsibility of the host to set it back to the
+       * template and for users stamping nested templates to use the
+       * `_contentForTemplate` method to retrieve the content for this template
+       * (an optimization to avoid the cost of cloning nested template content).
+       *
+       * @param {HTMLTemplateElement} node Node to parse (a <template>)
+       * @param {TemplateInfo} outerTemplateInfo Template metadata for current template
+       *   that includes the template `node`
+       * @param {!NodeInfo} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @nocollapse
+       */
+      static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {
+        let element = (
+          /** @type {!HTMLTemplateElement} */
+          node
+        );
+        let templateInfo = this._parseTemplate(element, outerTemplateInfo);
+        let content = templateInfo.content = element.content.ownerDocument.createDocumentFragment();
+        content.appendChild(element.content);
+        nodeInfo.templateInfo = templateInfo;
+        return true;
+      }
+      /**
+       * Parses template node attributes and adds node metadata to `nodeInfo`
+       * for nodes of interest.
+       *
+       * @param {Element} node Node to parse
+       * @param {!TemplateInfo} templateInfo Template metadata for current
+       *     template
+       * @param {!NodeInfo} nodeInfo Node metadata for current template.
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @nocollapse
+       */
+      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
+        let noted = false;
+        let attrs = Array.from(node.attributes);
+        for (let i = attrs.length - 1, a; a = attrs[i]; i--) {
+          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
+        }
+        return noted;
+      }
+      /**
+       * Parses a single template node attribute and adds node metadata to
+       * `nodeInfo` for attributes of interest.
+       *
+       * This implementation adds metadata for `on-event="handler"` attributes
+       * and `id` attributes.
+       *
+       * @param {Element} node Node to parse
+       * @param {!TemplateInfo} templateInfo Template metadata for current template
+       * @param {!NodeInfo} nodeInfo Node metadata for current template.
+       * @param {string} name Attribute name
+       * @param {string} value Attribute value
+       * @return {boolean} `true` if the visited node added node-specific
+       *   metadata to `nodeInfo`
+       * @nocollapse
+       */
+      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+        if (name.slice(0, 3) === "on-") {
+          node.removeAttribute(name);
+          nodeInfo.events = nodeInfo.events || [];
+          nodeInfo.events.push({
+            name: name.slice(3),
+            value
+          });
+          return true;
+        } else if (name === "id") {
+          nodeInfo.id = value;
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Returns the `content` document fragment for a given template.
+       *
+       * For nested templates, Polymer performs an optimization to cache nested
+       * template content to avoid the cost of cloning deeply nested templates.
+       * This method retrieves the cached content for a given template.
+       *
+       * @param {HTMLTemplateElement} template Template to retrieve `content` for
+       * @return {DocumentFragment} Content fragment
+       * @nocollapse
+       */
+      static _contentForTemplate(template) {
+        let templateInfo = (
+          /** @type {HTMLTemplateElementWithInfo} */
+          template._templateInfo
+        );
+        return templateInfo && templateInfo.content || template.content;
+      }
+      /**
+       * Clones the provided template content and returns a document fragment
+       * containing the cloned dom.
+       *
+       * The template is parsed (once and memoized) using this library's
+       * template parsing features, and provides the following value-added
+       * features:
+       * * Adds declarative event listeners for `on-event="handler"` attributes
+       * * Generates an "id map" for all nodes with id's under `$` on returned
+       *   document fragment
+       * * Passes template info including `content` back to templates as
+       *   `_templateInfo` (a performance optimization to avoid deep template
+       *   cloning)
+       *
+       * Note that the memoized template parsing process is destructive to the
+       * template: attributes for bindings and declarative event listeners are
+       * removed after being noted in notes, and any nested `<template>.content`
+       * is removed and stored in notes as well.
+       *
+       * @param {!HTMLTemplateElement} template Template to stamp
+       * @param {TemplateInfo=} templateInfo Optional template info associated
+       *   with the template to be stamped; if omitted the template will be
+       *   automatically parsed.
+       * @return {!StampedTemplate} Cloned template content
+       * @override
+       */
+      _stampTemplate(template, templateInfo) {
+        if (template && !template.content && window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
+          HTMLTemplateElement.decorate(template);
+        }
+        templateInfo = templateInfo || this.constructor._parseTemplate(template);
+        let nodeInfo = templateInfo.nodeInfoList;
+        let content = templateInfo.content || template.content;
+        let dom = (
+          /** @type {DocumentFragment} */
+          document.importNode(content, true)
+        );
+        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
+        let nodes = dom.nodeList = new Array(nodeInfo.length);
+        dom.$ = {};
+        for (let i = 0, l = nodeInfo.length, info; i < l && (info = nodeInfo[i]); i++) {
+          let node = nodes[i] = findTemplateNode(dom, info);
+          applyIdToMap(this, dom.$, node, info);
+          applyTemplateInfo(this, node, info, templateInfo);
+          applyEventListener(this, node, info);
+        }
+        dom = /** @type {!StampedTemplate} */
+        dom;
+        return dom;
+      }
+      /**
+       * Adds an event listener by method name for the event provided.
+       *
+       * This method generates a handler function that looks up the method
+       * name at handling time.
+       *
+       * @param {!EventTarget} node Node to add listener on
+       * @param {string} eventName Name of event
+       * @param {string} methodName Name of method
+       * @param {*=} context Context the method will be called on (defaults
+       *   to `node`)
+       * @return {Function} Generated handler function
+       * @override
+       */
+      _addMethodEventListenerToNode(node, eventName, methodName, context) {
+        context = context || node;
+        let handler = createNodeEventHandler(context, eventName, methodName);
+        this._addEventListenerToNode(node, eventName, handler);
+        return handler;
+      }
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param {!EventTarget} node Node to add event listener to
+       * @param {string} eventName Name of event
+       * @param {function(!Event):void} handler Listener function to add
+       * @return {void}
+       * @override
+       */
+      _addEventListenerToNode(node, eventName, handler) {
+        node.addEventListener(eventName, handler);
+      }
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param {!EventTarget} node Node to remove event listener from
+       * @param {string} eventName Name of event
+       * @param {function(!Event):void} handler Listener function to remove
+       * @return {void}
+       * @override
+       */
+      _removeEventListenerFromNode(node, eventName, handler) {
+        node.removeEventListener(eventName, handler);
+      }
+    }
+    return TemplateStamp2;
+  }
+);
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/property-effects.js
+var dedupeId = 0;
+var NOOP = [];
+var TYPES = {
+  COMPUTE: "__computeEffects",
+  REFLECT: "__reflectEffects",
+  NOTIFY: "__notifyEffects",
+  PROPAGATE: "__propagateEffects",
+  OBSERVE: "__observeEffects",
+  READ_ONLY: "__readOnly"
+};
+var COMPUTE_INFO = "__computeInfo";
+var capitalAttributeRegex = /[A-Z]/;
+function ensureOwnEffectMap(model, type, cloneArrays) {
+  let effects = model[type];
+  if (!effects) {
+    effects = model[type] = {};
+  } else if (!model.hasOwnProperty(type)) {
+    effects = model[type] = Object.create(model[type]);
+    if (cloneArrays) {
+      for (let p in effects) {
+        let protoFx = effects[p];
+        let instFx = effects[p] = Array(protoFx.length);
+        for (let i = 0; i < protoFx.length; i++) {
+          instFx[i] = protoFx[i];
+        }
+      }
+    }
+  }
+  return effects;
+}
+function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {
+  if (effects) {
+    let ran = false;
+    const id = dedupeId++;
+    for (let prop in props) {
+      let rootProperty = hasPaths ? root(prop) : prop;
+      let fxs = effects[rootProperty];
+      if (fxs) {
+        for (let i = 0, l = fxs.length, fx; i < l && (fx = fxs[i]); i++) {
+          if ((!fx.info || fx.info.lastRun !== id) && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
+            if (fx.info) {
+              fx.info.lastRun = id;
+            }
+            fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
+            ran = true;
+          }
+        }
+      }
+    }
+    return ran;
+  }
+  return false;
+}
+function runEffectsForProperty(inst, effects, dedupeId2, prop, props, oldProps, hasPaths, extraArgs) {
+  let ran = false;
+  let rootProperty = hasPaths ? root(prop) : prop;
+  let fxs = effects[rootProperty];
+  if (fxs) {
+    for (let i = 0, l = fxs.length, fx; i < l && (fx = fxs[i]); i++) {
+      if ((!fx.info || fx.info.lastRun !== dedupeId2) && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
+        if (fx.info) {
+          fx.info.lastRun = dedupeId2;
+        }
+        fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
+        ran = true;
+      }
+    }
+  }
+  return ran;
+}
+function pathMatchesTrigger(path, trigger) {
+  if (trigger) {
+    let triggerPath = (
+      /** @type {string} */
+      trigger.name
+    );
+    return triggerPath == path || !!(trigger.structured && isAncestor(triggerPath, path)) || !!(trigger.wildcard && isDescendant(triggerPath, path));
+  } else {
+    return true;
+  }
+}
+function runObserverEffect(inst, property, props, oldProps, info) {
+  let fn = typeof info.method === "string" ? inst[info.method] : info.method;
+  let changedProp = info.property;
+  if (fn) {
+    fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);
+  } else if (!info.dynamicFn) {
+    console.warn("observer method `" + info.method + "` not defined");
+  }
+}
+function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {
+  let fxs = inst[TYPES.NOTIFY];
+  let notified;
+  let id = dedupeId++;
+  for (let prop in notifyProps) {
+    if (notifyProps[prop]) {
+      if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {
+        notified = true;
+      } else if (hasPaths && notifyPath(inst, prop, props)) {
+        notified = true;
+      }
+    }
+  }
+  let host;
+  if (notified && (host = inst.__dataHost) && host._invalidateProperties) {
+    host._invalidateProperties();
+  }
+}
+function notifyPath(inst, path, props) {
+  let rootProperty = root(path);
+  if (rootProperty !== path) {
+    let eventName = camelToDashCase(rootProperty) + "-changed";
+    dispatchNotifyEvent(inst, eventName, props[path], path);
+    return true;
+  }
+  return false;
+}
+function dispatchNotifyEvent(inst, eventName, value, path) {
+  let detail = {
+    value,
+    queueProperty: true
+  };
+  if (path) {
+    detail.path = path;
+  }
+  wrap(
+    /** @type {!HTMLElement} */
+    inst
+  ).dispatchEvent(new CustomEvent(eventName, { detail }));
+}
+function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {
+  let rootProperty = hasPaths ? root(property) : property;
+  let path = rootProperty != property ? property : null;
+  let value = path ? get(inst, path) : inst.__data[property];
+  if (path && value === void 0) {
+    value = props[property];
+  }
+  dispatchNotifyEvent(inst, info.eventName, value, path);
+}
+function handleNotification(event, inst, fromProp, toPath, negate) {
+  let value;
+  let detail = (
+    /** @type {Object} */
+    event.detail
+  );
+  let fromPath = detail && detail.path;
+  if (fromPath) {
+    toPath = translate(fromProp, toPath, fromPath);
+    value = detail && detail.value;
+  } else {
+    value = event.currentTarget[fromProp];
+  }
+  value = negate ? !value : value;
+  if (!inst[TYPES.READ_ONLY] || !inst[TYPES.READ_ONLY][toPath]) {
+    if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath)) && (!detail || !detail.queueProperty)) {
+      inst._invalidateProperties();
+    }
+  }
+}
+function runReflectEffect(inst, property, props, oldProps, info) {
+  let value = inst.__data[property];
+  if (sanitizeDOMValue) {
+    value = sanitizeDOMValue(
+      value,
+      info.attrName,
+      "attribute",
+      /** @type {Node} */
+      inst
+    );
+  }
+  inst._propertyToAttribute(property, info.attrName, value);
+}
+function runComputedEffects(inst, changedProps, oldProps, hasPaths) {
+  let computeEffects = inst[TYPES.COMPUTE];
+  if (computeEffects) {
+    if (orderedComputed) {
+      dedupeId++;
+      const order = getComputedOrder(inst);
+      const queue = [];
+      for (let p in changedProps) {
+        enqueueEffectsFor(p, computeEffects, queue, order, hasPaths);
+      }
+      let info;
+      while (info = queue.shift()) {
+        if (runComputedEffect(inst, "", changedProps, oldProps, info)) {
+          enqueueEffectsFor(info.methodInfo, computeEffects, queue, order, hasPaths);
+        }
+      }
+      Object.assign(
+        /** @type {!Object} */
+        oldProps,
+        inst.__dataOld
+      );
+      Object.assign(
+        /** @type {!Object} */
+        changedProps,
+        inst.__dataPending
+      );
+      inst.__dataPending = null;
+    } else {
+      let inputProps = changedProps;
+      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {
+        Object.assign(
+          /** @type {!Object} */
+          oldProps,
+          inst.__dataOld
+        );
+        Object.assign(
+          /** @type {!Object} */
+          changedProps,
+          inst.__dataPending
+        );
+        inputProps = inst.__dataPending;
+        inst.__dataPending = null;
+      }
+    }
+  }
+}
+var insertEffect = (info, queue, order) => {
+  let start = 0;
+  let end = queue.length - 1;
+  let idx = -1;
+  while (start <= end) {
+    const mid = start + end >> 1;
+    const cmp = order.get(queue[mid].methodInfo) - order.get(info.methodInfo);
+    if (cmp < 0) {
+      start = mid + 1;
+    } else if (cmp > 0) {
+      end = mid - 1;
+    } else {
+      idx = mid;
+      break;
+    }
+  }
+  if (idx < 0) {
+    idx = end + 1;
+  }
+  queue.splice(idx, 0, info);
+};
+var enqueueEffectsFor = (prop, computeEffects, queue, order, hasPaths) => {
+  const rootProperty = hasPaths ? root(prop) : prop;
+  const fxs = computeEffects[rootProperty];
+  if (fxs) {
+    for (let i = 0; i < fxs.length; i++) {
+      const fx = fxs[i];
+      if (fx.info.lastRun !== dedupeId && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
+        fx.info.lastRun = dedupeId;
+        insertEffect(fx.info, queue, order);
+      }
+    }
+  }
+};
+function getComputedOrder(inst) {
+  let ordered = inst.constructor.__orderedComputedDeps;
+  if (!ordered) {
+    ordered = /* @__PURE__ */ new Map();
+    const effects = inst[TYPES.COMPUTE];
+    let { counts, ready, total } = dependencyCounts(inst);
+    let curr;
+    while (curr = ready.shift()) {
+      ordered.set(curr, ordered.size);
+      const computedByCurr = effects[curr];
+      if (computedByCurr) {
+        computedByCurr.forEach((fx) => {
+          const computedProp = fx.info.methodInfo;
+          --total;
+          if (--counts[computedProp] === 0) {
+            ready.push(computedProp);
+          }
+        });
+      }
+    }
+    if (total !== 0) {
+      const el = (
+        /** @type {HTMLElement} */
+        inst
+      );
+      console.warn(`Computed graph for ${el.localName} incomplete; circular?`);
+    }
+    inst.constructor.__orderedComputedDeps = ordered;
+  }
+  return ordered;
+}
+function dependencyCounts(inst) {
+  const infoForComputed = inst[COMPUTE_INFO];
+  const counts = {};
+  const computedDeps = inst[TYPES.COMPUTE];
+  const ready = [];
+  let total = 0;
+  for (let p in infoForComputed) {
+    const info = infoForComputed[p];
+    total += counts[p] = info.args.filter((a) => !a.literal).length + (info.dynamicFn ? 1 : 0);
+  }
+  for (let p in computedDeps) {
+    if (!infoForComputed[p]) {
+      ready.push(p);
+    }
+  }
+  return { counts, ready, total };
+}
+function runComputedEffect(inst, property, changedProps, oldProps, info) {
+  let result = runMethodEffect(inst, property, changedProps, oldProps, info);
+  if (result === NOOP) {
+    return false;
+  }
+  let computedProp = info.methodInfo;
+  if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {
+    return inst._setPendingProperty(computedProp, result, true);
+  } else {
+    inst[computedProp] = result;
+    return false;
+  }
+}
+function computeLinkedPaths(inst, path, value) {
+  let links = inst.__dataLinkedPaths;
+  if (links) {
+    let link;
+    for (let a in links) {
+      let b = links[a];
+      if (isDescendant(a, path)) {
+        link = translate(a, b, path);
+        inst._setPendingPropertyOrPath(link, value, true, true);
+      } else if (isDescendant(b, path)) {
+        link = translate(b, a, path);
+        inst._setPendingPropertyOrPath(link, value, true, true);
+      }
+    }
+  }
+}
+function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
+  nodeInfo.bindings = nodeInfo.bindings || [];
+  let binding = { kind, target, parts, literal, isCompound: parts.length !== 1 };
+  nodeInfo.bindings.push(binding);
+  if (shouldAddListener(binding)) {
+    let { event, negate } = binding.parts[0];
+    binding.listenerEvent = event || camelToDashCase(target) + "-changed";
+    binding.listenerNegate = negate;
+  }
+  let index = templateInfo.nodeInfoList.length;
+  for (let i = 0; i < binding.parts.length; i++) {
+    let part = binding.parts[i];
+    part.compoundIndex = i;
+    addEffectForBindingPart(constructor, templateInfo, binding, part, index);
+  }
+}
+function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
+  if (!part.literal) {
+    if (binding.kind === "attribute" && binding.target[0] === "-") {
+      console.warn("Cannot set attribute " + binding.target + ' because "-" is not a valid attribute starting character');
+    } else {
+      let dependencies = part.dependencies;
+      let info = { index, binding, part, evaluator: constructor };
+      for (let j = 0; j < dependencies.length; j++) {
+        let trigger = dependencies[j];
+        if (typeof trigger == "string") {
+          trigger = parseArg(trigger);
+          trigger.wildcard = true;
+        }
+        constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
+          fn: runBindingEffect,
+          info,
+          trigger
+        });
+      }
+    }
+  }
+}
+function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {
+  let node = nodeList[info.index];
+  let binding = info.binding;
+  let part = info.part;
+  if (hasPaths && part.source && path.length > part.source.length && binding.kind == "property" && !binding.isCompound && node.__isPropertyEffectsClient && node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {
+    let value = props[path];
+    path = translate(part.source, binding.target, path);
+    if (node._setPendingPropertyOrPath(path, value, false, true)) {
+      inst._enqueueClient(node);
+    }
+  } else {
+    let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);
+    if (value !== NOOP) {
+      applyBindingValue(inst, node, binding, part, value);
+    }
+  }
+}
+function applyBindingValue(inst, node, binding, part, value) {
+  value = computeBindingValue(node, value, binding, part);
+  if (sanitizeDOMValue) {
+    value = sanitizeDOMValue(value, binding.target, binding.kind, node);
+  }
+  if (binding.kind == "attribute") {
+    inst._valueToNodeAttribute(
+      /** @type {Element} */
+      node,
+      value,
+      binding.target
+    );
+  } else {
+    let prop = binding.target;
+    if (node.__isPropertyEffectsClient && node.__dataHasAccessor && node.__dataHasAccessor[prop]) {
+      if (!node[TYPES.READ_ONLY] || !node[TYPES.READ_ONLY][prop]) {
+        if (node._setPendingProperty(prop, value)) {
+          inst._enqueueClient(node);
+        }
+      }
+    } else {
+      inst._setUnmanagedPropertyToNode(node, prop, value);
+    }
+  }
+}
+function computeBindingValue(node, value, binding, part) {
+  if (binding.isCompound) {
+    let storage = node.__dataCompoundStorage[binding.target];
+    storage[part.compoundIndex] = value;
+    value = storage.join("");
+  }
+  if (binding.kind !== "attribute") {
+    if (binding.target === "textContent" || binding.target === "value" && (node.localName === "input" || node.localName === "textarea")) {
+      value = value == void 0 ? "" : value;
+    }
+  }
+  return value;
+}
+function shouldAddListener(binding) {
+  return Boolean(binding.target) && binding.kind != "attribute" && binding.kind != "text" && !binding.isCompound && binding.parts[0].mode === "{";
+}
+function setupBindings(inst, templateInfo) {
+  let { nodeList, nodeInfoList } = templateInfo;
+  if (nodeInfoList.length) {
+    for (let i = 0; i < nodeInfoList.length; i++) {
+      let info = nodeInfoList[i];
+      let node = nodeList[i];
+      let bindings = info.bindings;
+      if (bindings) {
+        for (let i2 = 0; i2 < bindings.length; i2++) {
+          let binding = bindings[i2];
+          setupCompoundStorage(node, binding);
+          addNotifyListener(node, inst, binding);
+        }
+      }
+      node.__dataHost = inst;
+    }
+  }
+}
+function setupCompoundStorage(node, binding) {
+  if (binding.isCompound) {
+    let storage = node.__dataCompoundStorage || (node.__dataCompoundStorage = {});
+    let parts = binding.parts;
+    let literals = new Array(parts.length);
+    for (let j = 0; j < parts.length; j++) {
+      literals[j] = parts[j].literal;
+    }
+    let target = binding.target;
+    storage[target] = literals;
+    if (binding.literal && binding.kind == "property") {
+      if (target === "className") {
+        node = wrap(node);
+      }
+      node[target] = binding.literal;
+    }
+  }
+}
+function addNotifyListener(node, inst, binding) {
+  if (binding.listenerEvent) {
+    let part = binding.parts[0];
+    node.addEventListener(binding.listenerEvent, function(e) {
+      handleNotification(e, inst, binding.target, part.source, part.negate);
+    });
+  }
+}
+function createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFn) {
+  dynamicFn = sig.static || dynamicFn && (typeof dynamicFn !== "object" || dynamicFn[sig.methodName]);
+  let info = {
+    methodName: sig.methodName,
+    args: sig.args,
+    methodInfo,
+    dynamicFn
+  };
+  for (let i = 0, arg; i < sig.args.length && (arg = sig.args[i]); i++) {
+    if (!arg.literal) {
+      model._addPropertyEffect(arg.rootProperty, type, {
+        fn: effectFn,
+        info,
+        trigger: arg
+      });
+    }
+  }
+  if (dynamicFn) {
+    model._addPropertyEffect(sig.methodName, type, {
+      fn: effectFn,
+      info
+    });
+  }
+  return info;
+}
+function runMethodEffect(inst, property, props, oldProps, info) {
+  let context = inst._methodHost || inst;
+  let fn = context[info.methodName];
+  if (fn) {
+    let args = inst._marshalArgs(info.args, property, props);
+    return args === NOOP ? NOOP : fn.apply(context, args);
+  } else if (!info.dynamicFn) {
+    console.warn("method `" + info.methodName + "` not defined");
+  }
+}
+var emptyArray = [];
+var IDENT = "(?:[a-zA-Z_$][\\w.:$\\-*]*)";
+var NUMBER = "(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)";
+var SQUOTE_STRING = "(?:'(?:[^'\\\\]|\\\\.)*')";
+var DQUOTE_STRING = '(?:"(?:[^"\\\\]|\\\\.)*")';
+var STRING = "(?:" + SQUOTE_STRING + "|" + DQUOTE_STRING + ")";
+var ARGUMENT = "(?:(" + IDENT + "|" + NUMBER + "|" + STRING + ")\\s*)";
+var ARGUMENTS = "(?:" + ARGUMENT + "(?:,\\s*" + ARGUMENT + ")*)";
+var ARGUMENT_LIST = "(?:\\(\\s*(?:" + ARGUMENTS + "?)\\)\\s*)";
+var BINDING = "(" + IDENT + "\\s*" + ARGUMENT_LIST + "?)";
+var OPEN_BRACKET = "(\\[\\[|{{)\\s*";
+var CLOSE_BRACKET = "(?:]]|}})";
+var NEGATE = "(?:(!)\\s*)?";
+var EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+var bindingRegex = new RegExp(EXPRESSION, "g");
+function literalFromParts(parts) {
+  let s = "";
+  for (let i = 0; i < parts.length; i++) {
+    let literal = parts[i].literal;
+    s += literal || "";
+  }
+  return s;
+}
+function parseMethod(expression) {
+  let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
+  if (m) {
+    let methodName = m[1];
+    let sig = { methodName, static: true, args: emptyArray };
+    if (m[2].trim()) {
+      let args = m[2].replace(/\\,/g, "&comma;").split(",");
+      return parseArgs(args, sig);
+    } else {
+      return sig;
+    }
+  }
+  return null;
+}
+function parseArgs(argList, sig) {
+  sig.args = argList.map(function(rawArg) {
+    let arg = parseArg(rawArg);
+    if (!arg.literal) {
+      sig.static = false;
+    }
+    return arg;
+  }, this);
+  return sig;
+}
+function parseArg(rawArg) {
+  let arg = rawArg.trim().replace(/&comma;/g, ",").replace(/\\(.)/g, "$1");
+  let a = {
+    name: arg,
+    value: "",
+    literal: false
+  };
+  let fc = arg[0];
+  if (fc === "-") {
+    fc = arg[1];
+  }
+  if (fc >= "0" && fc <= "9") {
+    fc = "#";
+  }
+  switch (fc) {
+    case "'":
+    case '"':
+      a.value = arg.slice(1, -1);
+      a.literal = true;
+      break;
+    case "#":
+      a.value = Number(arg);
+      a.literal = true;
+      break;
+  }
+  if (!a.literal) {
+    a.rootProperty = root(arg);
+    a.structured = isPath(arg);
+    if (a.structured) {
+      a.wildcard = arg.slice(-2) == ".*";
+      if (a.wildcard) {
+        a.name = arg.slice(0, -2);
+      }
+    }
+  }
+  return a;
+}
+function getArgValue(data, props, path) {
+  let value = get(data, path);
+  if (value === void 0) {
+    value = props[path];
+  }
+  return value;
+}
+function notifySplices(inst, array, path, splices) {
+  const splicesData = { indexSplices: splices };
+  if (legacyUndefined && !inst._overrideLegacyUndefined) {
+    array.splices = splicesData;
+  }
+  inst.notifyPath(path + ".splices", splicesData);
+  inst.notifyPath(path + ".length", array.length);
+  if (legacyUndefined && !inst._overrideLegacyUndefined) {
+    splicesData.indexSplices = [];
+  }
+}
+function notifySplice(inst, array, path, index, addedCount, removed) {
+  notifySplices(inst, array, path, [{
+    index,
+    addedCount,
+    removed,
+    object: array,
+    type: "splice"
+  }]);
+}
+function upper(name) {
+  return name[0].toUpperCase() + name.substring(1);
+}
+var PropertyEffects = dedupingMixin((superClass) => {
+  const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
+  class PropertyEffects2 extends propertyEffectsBase {
+    constructor() {
+      super();
+      this.__isPropertyEffectsClient = true;
+      this.__dataClientsReady;
+      this.__dataPendingClients;
+      this.__dataToNotify;
+      this.__dataLinkedPaths;
+      this.__dataHasPaths;
+      this.__dataCompoundStorage;
+      this.__dataHost;
+      this.__dataTemp;
+      this.__dataClientsInitialized;
+      this.__data;
+      this.__dataPending;
+      this.__dataOld;
+      this.__computeEffects;
+      this.__computeInfo;
+      this.__reflectEffects;
+      this.__notifyEffects;
+      this.__propagateEffects;
+      this.__observeEffects;
+      this.__readOnly;
+      this.__templateInfo;
+      this._overrideLegacyUndefined;
+    }
+    get PROPERTY_EFFECT_TYPES() {
+      return TYPES;
+    }
+    /**
+     * @override
+     * @return {void}
+     */
+    _initializeProperties() {
+      super._initializeProperties();
+      this._registerHost();
+      this.__dataClientsReady = false;
+      this.__dataPendingClients = null;
+      this.__dataToNotify = null;
+      this.__dataLinkedPaths = null;
+      this.__dataHasPaths = false;
+      this.__dataCompoundStorage = this.__dataCompoundStorage || null;
+      this.__dataHost = this.__dataHost || null;
+      this.__dataTemp = {};
+      this.__dataClientsInitialized = false;
+    }
+    _registerHost() {
+      if (hostStack.length) {
+        let host = hostStack[hostStack.length - 1];
+        host._enqueueClient(this);
+        this.__dataHost = host;
+      }
+    }
+    /**
+     * Overrides `PropertyAccessors` implementation to provide a
+     * more efficient implementation of initializing properties from
+     * the prototype on the instance.
+     *
+     * @override
+     * @param {Object} props Properties to initialize on the prototype
+     * @return {void}
+     */
+    _initializeProtoProperties(props) {
+      this.__data = Object.create(props);
+      this.__dataPending = Object.create(props);
+      this.__dataOld = {};
+    }
+    /**
+     * Overrides `PropertyAccessors` implementation to avoid setting
+     * `_setProperty`'s `shouldNotify: true`.
+     *
+     * @override
+     * @param {Object} props Properties to initialize on the instance
+     * @return {void}
+     */
+    _initializeInstanceProperties(props) {
+      let readOnly = this[TYPES.READ_ONLY];
+      for (let prop in props) {
+        if (!readOnly || !readOnly[prop]) {
+          this.__dataPending = this.__dataPending || {};
+          this.__dataOld = this.__dataOld || {};
+          this.__data[prop] = this.__dataPending[prop] = props[prop];
+        }
+      }
+    }
+    // Prototype setup ----------------------------------------
+    /**
+     * Equivalent to static `addPropertyEffect` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Property that should trigger the effect
+     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+     * @param {Object=} effect Effect metadata object
+     * @return {void}
+     * @protected
+     */
+    _addPropertyEffect(property, type, effect) {
+      this._createPropertyAccessor(property, type == TYPES.READ_ONLY);
+      let effects = ensureOwnEffectMap(this, type, true)[property];
+      if (!effects) {
+        effects = this[type][property] = [];
+      }
+      effects.push(effect);
+    }
+    /**
+     * Removes the given property effect.
+     *
+     * @override
+     * @param {string} property Property the effect was associated with
+     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+     * @param {Object=} effect Effect metadata object to remove
+     * @return {void}
+     */
+    _removePropertyEffect(property, type, effect) {
+      let effects = ensureOwnEffectMap(this, type, true)[property];
+      let idx = effects.indexOf(effect);
+      if (idx >= 0) {
+        effects.splice(idx, 1);
+      }
+    }
+    /**
+     * Returns whether the current prototype/instance has a property effect
+     * of a certain type.
+     *
+     * @override
+     * @param {string} property Property name
+     * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
+     * @return {boolean} True if the prototype/instance has an effect of this
+     *     type
+     * @protected
+     */
+    _hasPropertyEffect(property, type) {
+      let effects = this[type];
+      return Boolean(effects && effects[property]);
+    }
+    /**
+     * Returns whether the current prototype/instance has a "read only"
+     * accessor for the given property.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {boolean} True if the prototype/instance has an effect of this
+     *     type
+     * @protected
+     */
+    _hasReadOnlyEffect(property) {
+      return this._hasPropertyEffect(property, TYPES.READ_ONLY);
+    }
+    /**
+     * Returns whether the current prototype/instance has a "notify"
+     * property effect for the given property.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {boolean} True if the prototype/instance has an effect of this
+     *     type
+     * @protected
+     */
+    _hasNotifyEffect(property) {
+      return this._hasPropertyEffect(property, TYPES.NOTIFY);
+    }
+    /**
+     * Returns whether the current prototype/instance has a "reflect to
+     * attribute" property effect for the given property.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {boolean} True if the prototype/instance has an effect of this
+     *     type
+     * @protected
+     */
+    _hasReflectEffect(property) {
+      return this._hasPropertyEffect(property, TYPES.REFLECT);
+    }
+    /**
+     * Returns whether the current prototype/instance has a "computed"
+     * property effect for the given property.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {boolean} True if the prototype/instance has an effect of this
+     *     type
+     * @protected
+     */
+    _hasComputedEffect(property) {
+      return this._hasPropertyEffect(property, TYPES.COMPUTE);
+    }
+    // Runtime ----------------------------------------
+    /**
+     * Sets a pending property or path.  If the root property of the path in
+     * question had no accessor, the path is set, otherwise it is enqueued
+     * via `_setPendingProperty`.
+     *
+     * This function isolates relatively expensive functionality necessary
+     * for the public API (`set`, `setProperties`, `notifyPath`, and property
+     * change listeners via {{...}} bindings), such that it is only done
+     * when paths enter the system, and not at every propagation step.  It
+     * also sets a `__dataHasPaths` flag on the instance which is used to
+     * fast-path slower path-matching code in the property effects host paths.
+     *
+     * `path` can be a path string or array of path parts as accepted by the
+     * public API.
+     *
+     * @override
+     * @param {string | !Array<number|string>} path Path to set
+     * @param {*} value Value to set
+     * @param {boolean=} shouldNotify Set to true if this change should
+     *  cause a property notification event dispatch
+     * @param {boolean=} isPathNotification If the path being set is a path
+     *   notification of an already changed value, as opposed to a request
+     *   to set and notify the change.  In the latter `false` case, a dirty
+     *   check is performed and then the value is set to the path before
+     *   enqueuing the pending property change.
+     * @return {boolean} Returns true if the property/path was enqueued in
+     *   the pending changes bag.
+     * @protected
+     */
+    _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
+      if (isPathNotification || root(Array.isArray(path) ? path[0] : path) !== path) {
+        if (!isPathNotification) {
+          let old = get(this, path);
+          path = /** @type {string} */
+          set(this, path, value);
+          if (!path || !super._shouldPropertyChange(path, value, old)) {
+            return false;
+          }
+        }
+        this.__dataHasPaths = true;
+        if (this._setPendingProperty(
+          /**@type{string}*/
+          path,
+          value,
+          shouldNotify
+        )) {
+          computeLinkedPaths(
+            this,
+            /**@type{string}*/
+            path,
+            value
+          );
+          return true;
+        }
+      } else {
+        if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {
+          return this._setPendingProperty(
+            /**@type{string}*/
+            path,
+            value,
+            shouldNotify
+          );
+        } else {
+          this[path] = value;
+        }
+      }
+      return false;
+    }
+    /**
+     * Applies a value to a non-Polymer element/node's property.
+     *
+     * The implementation makes a best-effort at binding interop:
+     * Some native element properties have side-effects when
+     * re-setting the same value (e.g. setting `<input>.value` resets the
+     * cursor position), so we do a dirty-check before setting the value.
+     * However, for better interop with non-Polymer custom elements that
+     * accept objects, we explicitly re-set object changes coming from the
+     * Polymer world (which may include deep object changes without the
+     * top reference changing), erring on the side of providing more
+     * information.
+     *
+     * Users may override this method to provide alternate approaches.
+     *
+     * @override
+     * @param {!Node} node The node to set a property on
+     * @param {string} prop The property to set
+     * @param {*} value The value to set
+     * @return {void}
+     * @protected
+     */
+    _setUnmanagedPropertyToNode(node, prop, value) {
+      if (value !== node[prop] || typeof value == "object") {
+        if (prop === "className") {
+          node = /** @type {!Node} */
+          wrap(node);
+        }
+        node[prop] = value;
+      }
+    }
+    /**
+     * Overrides the `PropertiesChanged` implementation to introduce special
+     * dirty check logic depending on the property & value being set:
+     *
+     * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
+     *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
+     * 2. Object set to simple property (e.g. 'prop': {...})
+     *    Stored in `__dataTemp` and `__data`, dirty checked against
+     *    `__dataTemp` by default implementation of `_shouldPropertyChange`
+     * 3. Primitive value set to simple property (e.g. 'prop': 42)
+     *    Stored in `__data`, dirty checked against `__data`
+     *
+     * The dirty-check is important to prevent cycles due to two-way
+     * notification, but paths and objects are only dirty checked against any
+     * previous value set during this turn via a "temporary cache" that is
+     * cleared when the last `_propertiesChanged` exits. This is so:
+     * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
+     *    due to array mutations like shift/unshift/splice; this is fine
+     *    since path changes are dirty-checked at user entry points like `set`
+     * b. dirty-checking for objects only lasts one turn to allow the user
+     *    to mutate the object in-place and re-set it with the same identity
+     *    and have all sub-properties re-propagated in a subsequent turn.
+     *
+     * The temp cache is not necessarily sufficient to prevent invalid array
+     * paths, since a splice can happen during the same turn (with pathological
+     * user code); we could introduce a "fixup" for temporarily cached array
+     * paths if needed: https://github.com/Polymer/polymer/issues/4227
+     *
+     * @override
+     * @param {string} property Name of the property
+     * @param {*} value Value to set
+     * @param {boolean=} shouldNotify True if property should fire notification
+     *   event (applies only for `notify: true` properties)
+     * @return {boolean} Returns true if the property changed
+     */
+    _setPendingProperty(property, value, shouldNotify) {
+      let propIsPath = this.__dataHasPaths && isPath(property);
+      let prevProps = propIsPath ? this.__dataTemp : this.__data;
+      if (this._shouldPropertyChange(property, value, prevProps[property])) {
+        if (!this.__dataPending) {
+          this.__dataPending = {};
+          this.__dataOld = {};
+        }
+        if (!(property in this.__dataOld)) {
+          this.__dataOld[property] = this.__data[property];
+        }
+        if (propIsPath) {
+          this.__dataTemp[property] = value;
+        } else {
+          this.__data[property] = value;
+        }
+        this.__dataPending[property] = value;
+        if (propIsPath || this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property]) {
+          this.__dataToNotify = this.__dataToNotify || {};
+          this.__dataToNotify[property] = shouldNotify;
+        }
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Overrides base implementation to ensure all accessors set `shouldNotify`
+     * to true, for per-property notification tracking.
+     *
+     * @override
+     * @param {string} property Name of the property
+     * @param {*} value Value to set
+     * @return {void}
+     */
+    _setProperty(property, value) {
+      if (this._setPendingProperty(property, value, true)) {
+        this._invalidateProperties();
+      }
+    }
+    /**
+     * Overrides `PropertyAccessor`'s default async queuing of
+     * `_propertiesChanged`: if `__dataReady` is false (has not yet been
+     * manually flushed), the function no-ops; otherwise flushes
+     * `_propertiesChanged` synchronously.
+     *
+     * @override
+     * @return {void}
+     */
+    _invalidateProperties() {
+      if (this.__dataReady) {
+        this._flushProperties();
+      }
+    }
+    /**
+     * Enqueues the given client on a list of pending clients, whose
+     * pending property changes can later be flushed via a call to
+     * `_flushClients`.
+     *
+     * @override
+     * @param {Object} client PropertyEffects client to enqueue
+     * @return {void}
+     * @protected
+     */
+    _enqueueClient(client) {
+      this.__dataPendingClients = this.__dataPendingClients || [];
+      if (client !== this) {
+        this.__dataPendingClients.push(client);
+      }
+    }
+    /**
+     * Flushes any clients previously enqueued via `_enqueueClient`, causing
+     * their `_flushProperties` method to run.
+     *
+     * @override
+     * @return {void}
+     * @protected
+     */
+    _flushClients() {
+      if (!this.__dataClientsReady) {
+        this.__dataClientsReady = true;
+        this._readyClients();
+        this.__dataReady = true;
+      } else {
+        this.__enableOrFlushClients();
+      }
+    }
+    // NOTE: We ensure clients either enable or flush as appropriate. This
+    // handles two corner cases:
+    // (1) clients flush properly when connected/enabled before the host
+    // enables; e.g.
+    //   (a) Templatize stamps with no properties and does not flush and
+    //   (b) the instance is inserted into dom and
+    //   (c) then the instance flushes.
+    // (2) clients enable properly when not connected/enabled when the host
+    // flushes; e.g.
+    //   (a) a template is runtime stamped and not yet connected/enabled
+    //   (b) a host sets a property, causing stamped dom to flush
+    //   (c) the stamped dom enables.
+    __enableOrFlushClients() {
+      let clients = this.__dataPendingClients;
+      if (clients) {
+        this.__dataPendingClients = null;
+        for (let i = 0; i < clients.length; i++) {
+          let client = clients[i];
+          if (!client.__dataEnabled) {
+            client._enableProperties();
+          } else if (client.__dataPending) {
+            client._flushProperties();
+          }
+        }
+      }
+    }
+    /**
+     * Perform any initial setup on client dom. Called before the first
+     * `_flushProperties` call on client dom and before any element
+     * observers are called.
+     *
+     * @override
+     * @return {void}
+     * @protected
+     */
+    _readyClients() {
+      this.__enableOrFlushClients();
+    }
+    /**
+     * Sets a bag of property changes to this instance, and
+     * synchronously processes all effects of the properties as a batch.
+     *
+     * Property names must be simple properties, not paths.  Batched
+     * path propagation is not supported.
+     *
+     * @override
+     * @param {Object} props Bag of one or more key-value pairs whose key is
+     *   a property and value is the new value to set for that property.
+     * @param {boolean=} setReadOnly When true, any private values set in
+     *   `props` will be set. By default, `setProperties` will not set
+     *   `readOnly: true` root properties.
+     * @return {void}
+     * @public
+     */
+    setProperties(props, setReadOnly) {
+      for (let path in props) {
+        if (setReadOnly || !this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][path]) {
+          this._setPendingPropertyOrPath(path, props[path], true);
+        }
+      }
+      this._invalidateProperties();
+    }
+    /**
+     * Overrides `PropertyAccessors` so that property accessor
+     * side effects are not enabled until after client dom is fully ready.
+     * Also calls `_flushClients` callback to ensure client dom is enabled
+     * that was not enabled as a result of flushing properties.
+     *
+     * @override
+     * @return {void}
+     */
+    ready() {
+      this._flushProperties();
+      if (!this.__dataClientsReady) {
+        this._flushClients();
+      }
+      if (this.__dataPending) {
+        this._flushProperties();
+      }
+    }
+    /**
+     * Implements `PropertyAccessors`'s properties changed callback.
+     *
+     * Runs each class of effects for the batch of changed properties in
+     * a specific order (compute, propagate, reflect, observe, notify).
+     *
+     * @override
+     * @param {!Object} currentProps Bag of all current accessor values
+     * @param {?Object} changedProps Bag of properties changed since the last
+     *   call to `_propertiesChanged`
+     * @param {?Object} oldProps Bag of previous values for each property
+     *   in `changedProps`
+     * @return {void}
+     */
+    _propertiesChanged(currentProps, changedProps, oldProps) {
+      let hasPaths = this.__dataHasPaths;
+      this.__dataHasPaths = false;
+      let notifyProps;
+      runComputedEffects(this, changedProps, oldProps, hasPaths);
+      notifyProps = this.__dataToNotify;
+      this.__dataToNotify = null;
+      this._propagatePropertyChanges(changedProps, oldProps, hasPaths);
+      this._flushClients();
+      runEffects(this, this[TYPES.REFLECT], changedProps, oldProps, hasPaths);
+      runEffects(this, this[TYPES.OBSERVE], changedProps, oldProps, hasPaths);
+      if (notifyProps) {
+        runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);
+      }
+      if (this.__dataCounter == 1) {
+        this.__dataTemp = {};
+      }
+    }
+    /**
+     * Called to propagate any property changes to stamped template nodes
+     * managed by this element.
+     *
+     * @override
+     * @param {Object} changedProps Bag of changed properties
+     * @param {Object} oldProps Bag of previous values for changed properties
+     * @param {boolean} hasPaths True with `props` contains one or more paths
+     * @return {void}
+     * @protected
+     */
+    _propagatePropertyChanges(changedProps, oldProps, hasPaths) {
+      if (this[TYPES.PROPAGATE]) {
+        runEffects(this, this[TYPES.PROPAGATE], changedProps, oldProps, hasPaths);
+      }
+      if (this.__templateInfo) {
+        this._runEffectsForTemplate(this.__templateInfo, changedProps, oldProps, hasPaths);
+      }
+    }
+    _runEffectsForTemplate(templateInfo, changedProps, oldProps, hasPaths) {
+      const baseRunEffects = (changedProps2, hasPaths2) => {
+        runEffects(
+          this,
+          templateInfo.propertyEffects,
+          changedProps2,
+          oldProps,
+          hasPaths2,
+          templateInfo.nodeList
+        );
+        for (let info = templateInfo.firstChild; info; info = info.nextSibling) {
+          this._runEffectsForTemplate(info, changedProps2, oldProps, hasPaths2);
+        }
+      };
+      if (templateInfo.runEffects) {
+        templateInfo.runEffects(baseRunEffects, changedProps, hasPaths);
+      } else {
+        baseRunEffects(changedProps, hasPaths);
+      }
+    }
+    /**
+     * Aliases one data path as another, such that path notifications from one
+     * are routed to the other.
+     *
+     * @override
+     * @param {string | !Array<string|number>} to Target path to link.
+     * @param {string | !Array<string|number>} from Source path to link.
+     * @return {void}
+     * @public
+     */
+    linkPaths(to, from) {
+      to = normalize(to);
+      from = normalize(from);
+      this.__dataLinkedPaths = this.__dataLinkedPaths || {};
+      this.__dataLinkedPaths[to] = from;
+    }
+    /**
+     * Removes a data path alias previously established with `_linkPaths`.
+     *
+     * Note, the path to unlink should be the target (`to`) used when
+     * linking the paths.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Target path to unlink.
+     * @return {void}
+     * @public
+     */
+    unlinkPaths(path) {
+      path = normalize(path);
+      if (this.__dataLinkedPaths) {
+        delete this.__dataLinkedPaths[path];
+      }
+    }
+    /**
+     * Notify that an array has changed.
+     *
+     * Example:
+     *
+     *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
+     *     ...
+     *     this.items.splice(1, 1, {name: 'Sam'});
+     *     this.items.push({name: 'Bob'});
+     *     this.notifySplices('items', [
+     *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1,
+     *         object: this.items, type: 'splice' },
+     *       { index: 3, removed: [], addedCount: 1,
+     *         object: this.items, type: 'splice'}
+     *     ]);
+     *
+     * @param {string} path Path that should be notified.
+     * @param {Array} splices Array of splice records indicating ordered
+     *   changes that occurred to the array. Each record should have the
+     *   following fields:
+     *    * index: index at which the change occurred
+     *    * removed: array of items that were removed from this index
+     *    * addedCount: number of new items added at this index
+     *    * object: a reference to the array in question
+     *    * type: the string literal 'splice'
+     *
+     *   Note that splice records _must_ be normalized such that they are
+     *   reported in index order (raw results from `Object.observe` are not
+     *   ordered and must be normalized/merged before notifying).
+     *
+     * @override
+     * @return {void}
+     * @public
+     */
+    notifySplices(path, splices) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array} */
+        get(this, path, info)
+      );
+      notifySplices(this, array, info.path, splices);
+    }
+    /**
+     * Convenience method for reading a value from a path.
+     *
+     * Note, if any part in the path is undefined, this method returns
+     * `undefined` (this method does not throw when dereferencing undefined
+     * paths).
+     *
+     * @override
+     * @param {(string|!Array<(string|number)>)} path Path to the value
+     *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
+     *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+     *   bracketed expressions are not supported; string-based path parts
+     *   *must* be separated by dots.  Note that when dereferencing array
+     *   indices, the index may be used as a dotted part directly
+     *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+     * @param {Object=} root Root object from which the path is evaluated.
+     * @return {*} Value at the path, or `undefined` if any part of the path
+     *   is undefined.
+     * @public
+     */
+    get(path, root2) {
+      return get(root2 || this, path);
+    }
+    /**
+     * Convenience method for setting a value to a path and notifying any
+     * elements bound to the same path.
+     *
+     * Note, if any part in the path except for the last is undefined,
+     * this method does nothing (this method does not throw when
+     * dereferencing undefined paths).
+     *
+     * @override
+     * @param {(string|!Array<(string|number)>)} path Path to the value
+     *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
+     *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+     *   bracketed expressions are not supported; string-based path parts
+     *   *must* be separated by dots.  Note that when dereferencing array
+     *   indices, the index may be used as a dotted part directly
+     *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
+     * @param {*} value Value to set at the specified path.
+     * @param {Object=} root Root object from which the path is evaluated.
+     *   When specified, no notification will occur.
+     * @return {void}
+     * @public
+     */
+    set(path, value, root2) {
+      if (root2) {
+        set(root2, path, value);
+      } else {
+        if (!this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][
+          /** @type {string} */
+          path
+        ]) {
+          if (this._setPendingPropertyOrPath(path, value, true)) {
+            this._invalidateProperties();
+          }
+        }
+      }
+    }
+    /**
+     * Adds items onto the end of the array at the path specified.
+     *
+     * The arguments after `path` and return value match that of
+     * `Array.prototype.push`.
+     *
+     * This method notifies other paths to the same array that a
+     * splice occurred to the array.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Path to array.
+     * @param {...*} items Items to push onto array
+     * @return {number} New length of the array.
+     * @public
+     */
+    push(path, ...items) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array}*/
+        get(this, path, info)
+      );
+      let len = array.length;
+      let ret = array.push(...items);
+      if (items.length) {
+        notifySplice(this, array, info.path, len, items.length, []);
+      }
+      return ret;
+    }
+    /**
+     * Removes an item from the end of array at the path specified.
+     *
+     * The arguments after `path` and return value match that of
+     * `Array.prototype.pop`.
+     *
+     * This method notifies other paths to the same array that a
+     * splice occurred to the array.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Path to array.
+     * @return {*} Item that was removed.
+     * @public
+     */
+    pop(path) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array} */
+        get(this, path, info)
+      );
+      let hadLength = Boolean(array.length);
+      let ret = array.pop();
+      if (hadLength) {
+        notifySplice(this, array, info.path, array.length, 0, [ret]);
+      }
+      return ret;
+    }
+    /**
+     * Starting from the start index specified, removes 0 or more items
+     * from the array and inserts 0 or more new items in their place.
+     *
+     * The arguments after `path` and return value match that of
+     * `Array.prototype.splice`.
+     *
+     * This method notifies other paths to the same array that a
+     * splice occurred to the array.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Path to array.
+     * @param {number} start Index from which to start removing/inserting.
+     * @param {number=} deleteCount Number of items to remove.
+     * @param {...*} items Items to insert into array.
+     * @return {!Array} Array of removed items.
+     * @public
+     */
+    splice(path, start, deleteCount, ...items) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array} */
+        get(this, path, info)
+      );
+      if (start < 0) {
+        start = array.length - Math.floor(-start);
+      } else if (start) {
+        start = Math.floor(start);
+      }
+      let ret;
+      if (arguments.length === 2) {
+        ret = array.splice(start);
+      } else {
+        ret = array.splice(start, deleteCount, ...items);
+      }
+      if (items.length || ret.length) {
+        notifySplice(this, array, info.path, start, items.length, ret);
+      }
+      return ret;
+    }
+    /**
+     * Removes an item from the beginning of array at the path specified.
+     *
+     * The arguments after `path` and return value match that of
+     * `Array.prototype.pop`.
+     *
+     * This method notifies other paths to the same array that a
+     * splice occurred to the array.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Path to array.
+     * @return {*} Item that was removed.
+     * @public
+     */
+    shift(path) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array} */
+        get(this, path, info)
+      );
+      let hadLength = Boolean(array.length);
+      let ret = array.shift();
+      if (hadLength) {
+        notifySplice(this, array, info.path, 0, 0, [ret]);
+      }
+      return ret;
+    }
+    /**
+     * Adds items onto the beginning of the array at the path specified.
+     *
+     * The arguments after `path` and return value match that of
+     * `Array.prototype.push`.
+     *
+     * This method notifies other paths to the same array that a
+     * splice occurred to the array.
+     *
+     * @override
+     * @param {string | !Array<string|number>} path Path to array.
+     * @param {...*} items Items to insert info array
+     * @return {number} New length of the array.
+     * @public
+     */
+    unshift(path, ...items) {
+      let info = { path: "" };
+      let array = (
+        /** @type {Array} */
+        get(this, path, info)
+      );
+      let ret = array.unshift(...items);
+      if (items.length) {
+        notifySplice(this, array, info.path, 0, items.length, []);
+      }
+      return ret;
+    }
+    /**
+     * Notify that a path has changed.
+     *
+     * Example:
+     *
+     *     this.item.user.name = 'Bob';
+     *     this.notifyPath('item.user.name');
+     *
+     * @override
+     * @param {string} path Path that should be notified.
+     * @param {*=} value Value at the path (optional).
+     * @return {void}
+     * @public
+     */
+    notifyPath(path, value) {
+      let propPath;
+      if (arguments.length == 1) {
+        let info = { path: "" };
+        value = get(this, path, info);
+        propPath = info.path;
+      } else if (Array.isArray(path)) {
+        propPath = normalize(path);
+      } else {
+        propPath = /** @type{string} */
+        path;
+      }
+      if (this._setPendingPropertyOrPath(propPath, value, true, true)) {
+        this._invalidateProperties();
+      }
+    }
+    /**
+     * Equivalent to static `createReadOnlyProperty` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Property name
+     * @param {boolean=} protectedSetter Creates a custom protected setter
+     *   when `true`.
+     * @return {void}
+     * @protected
+     */
+    _createReadOnlyProperty(property, protectedSetter) {
+      this._addPropertyEffect(property, TYPES.READ_ONLY);
+      if (protectedSetter) {
+        this["_set" + upper(property)] = /** @this {PropertyEffects} */
+        function(value) {
+          this._setProperty(property, value);
+        };
+      }
+    }
+    /**
+     * Equivalent to static `createPropertyObserver` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Property name
+     * @param {string|function(*,*)} method Function or name of observer method
+     *     to call
+     * @param {boolean=} dynamicFn Whether the method name should be included as
+     *   a dependency to the effect.
+     * @return {void}
+     * @protected
+     */
+    _createPropertyObserver(property, method, dynamicFn) {
+      let info = { property, method, dynamicFn: Boolean(dynamicFn) };
+      this._addPropertyEffect(property, TYPES.OBSERVE, {
+        fn: runObserverEffect,
+        info,
+        trigger: { name: property }
+      });
+      if (dynamicFn) {
+        this._addPropertyEffect(
+          /** @type {string} */
+          method,
+          TYPES.OBSERVE,
+          {
+            fn: runObserverEffect,
+            info,
+            trigger: { name: method }
+          }
+        );
+      }
+    }
+    /**
+     * Equivalent to static `createMethodObserver` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} expression Method expression
+     * @param {boolean|Object=} dynamicFn Boolean or object map indicating
+     *   whether method names should be included as a dependency to the effect.
+     * @return {void}
+     * @protected
+     */
+    _createMethodObserver(expression, dynamicFn) {
+      let sig = parseMethod(expression);
+      if (!sig) {
+        throw new Error("Malformed observer expression '" + expression + "'");
+      }
+      createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFn);
+    }
+    /**
+     * Equivalent to static `createNotifyingProperty` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {void}
+     * @protected
+     */
+    _createNotifyingProperty(property) {
+      this._addPropertyEffect(property, TYPES.NOTIFY, {
+        fn: runNotifyEffect,
+        info: {
+          eventName: camelToDashCase(property) + "-changed",
+          property
+        }
+      });
+    }
+    /**
+     * Equivalent to static `createReflectedProperty` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Property name
+     * @return {void}
+     * @protected
+     * @suppress {missingProperties} go/missingfnprops
+     */
+    _createReflectedProperty(property) {
+      let attr = this.constructor.attributeNameForProperty(property);
+      if (attr[0] === "-") {
+        console.warn("Property " + property + " cannot be reflected to attribute " + attr + ' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.');
+      } else {
+        this._addPropertyEffect(property, TYPES.REFLECT, {
+          fn: runReflectEffect,
+          info: {
+            attrName: attr
+          }
+        });
+      }
+    }
+    /**
+     * Equivalent to static `createComputedProperty` API but can be called on
+     * an instance to add effects at runtime.  See that method for
+     * full API docs.
+     *
+     * @override
+     * @param {string} property Name of computed property to set
+     * @param {string} expression Method expression
+     * @param {boolean|Object=} dynamicFn Boolean or object map indicating
+     *   whether method names should be included as a dependency to the effect.
+     * @return {void}
+     * @protected
+     */
+    _createComputedProperty(property, expression, dynamicFn) {
+      let sig = parseMethod(expression);
+      if (!sig) {
+        throw new Error("Malformed computed expression '" + expression + "'");
+      }
+      const info = createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFn);
+      ensureOwnEffectMap(this, COMPUTE_INFO)[property] = info;
+    }
+    /**
+     * Gather the argument values for a method specified in the provided array
+     * of argument metadata.
+     *
+     * The `path` and `value` arguments are used to fill in wildcard descriptor
+     * when the method is being called as a result of a path notification.
+     *
+     * @param {!Array<!MethodArg>} args Array of argument metadata
+     * @param {string} path Property/path name that triggered the method effect
+     * @param {Object} props Bag of current property changes
+     * @return {!Array<*>} Array of argument values
+     * @private
+     */
+    _marshalArgs(args, path, props) {
+      const data = this.__data;
+      const values = [];
+      for (let i = 0, l = args.length; i < l; i++) {
+        let { name, structured, wildcard, value, literal } = args[i];
+        if (!literal) {
+          if (wildcard) {
+            const matches2 = isDescendant(name, path);
+            const pathValue = getArgValue(data, props, matches2 ? path : name);
+            value = {
+              path: matches2 ? path : name,
+              value: pathValue,
+              base: matches2 ? get(data, name) : pathValue
+            };
+          } else {
+            value = structured ? getArgValue(data, props, name) : data[name];
+          }
+        }
+        if (legacyUndefined && !this._overrideLegacyUndefined && value === void 0 && args.length > 1) {
+          return NOOP;
+        }
+        values[i] = value;
+      }
+      return values;
+    }
+    // -- static class methods ------------
+    /**
+     * Ensures an accessor exists for the specified property, and adds
+     * to a list of "property effects" that will run when the accessor for
+     * the specified property is set.  Effects are grouped by "type", which
+     * roughly corresponds to a phase in effect processing.  The effect
+     * metadata should be in the following form:
+     *
+     *     {
+     *       fn: effectFunction, // Reference to function to call to perform effect
+     *       info: { ... }       // Effect metadata passed to function
+     *       trigger: {          // Optional triggering metadata; if not provided
+     *         name: string      // the property is treated as a wildcard
+     *         structured: boolean
+     *         wildcard: boolean
+     *       }
+     *     }
+     *
+     * Effects are called from `_propertiesChanged` in the following order by
+     * type:
+     *
+     * 1. COMPUTE
+     * 2. PROPAGATE
+     * 3. REFLECT
+     * 4. OBSERVE
+     * 5. NOTIFY
+     *
+     * Effect functions are called with the following signature:
+     *
+     *     effectFunction(inst, path, props, oldProps, info, hasPaths)
+     *
+     * @param {string} property Property that should trigger the effect
+     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+     * @param {Object=} effect Effect metadata object
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static addPropertyEffect(property, type, effect) {
+      this.prototype._addPropertyEffect(property, type, effect);
+    }
+    /**
+     * Creates a single-property observer for the given property.
+     *
+     * @param {string} property Property name
+     * @param {string|function(*,*)} method Function or name of observer method to call
+     * @param {boolean=} dynamicFn Whether the method name should be included as
+     *   a dependency to the effect.
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createPropertyObserver(property, method, dynamicFn) {
+      this.prototype._createPropertyObserver(property, method, dynamicFn);
+    }
+    /**
+     * Creates a multi-property "method observer" based on the provided
+     * expression, which should be a string in the form of a normal JavaScript
+     * function signature: `'methodName(arg1, [..., argn])'`.  Each argument
+     * should correspond to a property or path in the context of this
+     * prototype (or instance), or may be a literal string or number.
+     *
+     * @param {string} expression Method expression
+     * @param {boolean|Object=} dynamicFn Boolean or object map indicating
+     * @return {void}
+     *   whether method names should be included as a dependency to the effect.
+     * @protected
+     * @nocollapse
+     */
+    static createMethodObserver(expression, dynamicFn) {
+      this.prototype._createMethodObserver(expression, dynamicFn);
+    }
+    /**
+     * Causes the setter for the given property to dispatch `<property>-changed`
+     * events to notify of changes to the property.
+     *
+     * @param {string} property Property name
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createNotifyingProperty(property) {
+      this.prototype._createNotifyingProperty(property);
+    }
+    /**
+     * Creates a read-only accessor for the given property.
+     *
+     * To set the property, use the protected `_setProperty` API.
+     * To create a custom protected setter (e.g. `_setMyProp()` for
+     * property `myProp`), pass `true` for `protectedSetter`.
+     *
+     * Note, if the property will have other property effects, this method
+     * should be called first, before adding other effects.
+     *
+     * @param {string} property Property name
+     * @param {boolean=} protectedSetter Creates a custom protected setter
+     *   when `true`.
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createReadOnlyProperty(property, protectedSetter) {
+      this.prototype._createReadOnlyProperty(property, protectedSetter);
+    }
+    /**
+     * Causes the setter for the given property to reflect the property value
+     * to a (dash-cased) attribute of the same name.
+     *
+     * @param {string} property Property name
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createReflectedProperty(property) {
+      this.prototype._createReflectedProperty(property);
+    }
+    /**
+     * Creates a computed property whose value is set to the result of the
+     * method described by the given `expression` each time one or more
+     * arguments to the method changes.  The expression should be a string
+     * in the form of a normal JavaScript function signature:
+     * `'methodName(arg1, [..., argn])'`
+     *
+     * @param {string} property Name of computed property to set
+     * @param {string} expression Method expression
+     * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether
+     *   method names should be included as a dependency to the effect.
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createComputedProperty(property, expression, dynamicFn) {
+      this.prototype._createComputedProperty(property, expression, dynamicFn);
+    }
+    /**
+     * Parses the provided template to ensure binding effects are created
+     * for them, and then ensures property accessors are created for any
+     * dependent properties in the template.  Binding effects for bound
+     * templates are stored in a linked list on the instance so that
+     * templates can be efficiently stamped and unstamped.
+     *
+     * @param {!HTMLTemplateElement} template Template containing binding
+     *   bindings
+     * @return {!TemplateInfo} Template metadata object
+     * @protected
+     * @nocollapse
+     */
+    static bindTemplate(template) {
+      return this.prototype._bindTemplate(template);
+    }
+    // -- binding ----------------------------------------------
+    /*
+     * Overview of binding flow:
+     *
+     * During finalization (`instanceBinding==false`, `wasPreBound==false`):
+     *  `_bindTemplate(t, false)` called directly during finalization - parses
+     *  the template (for the first time), and then assigns that _prototypical_
+     *  template info to `__preboundTemplateInfo` _on the prototype_; note in
+     *  this case `wasPreBound` is false; this is the first time we're binding
+     *  it, thus we create accessors.
+     *
+     * During first stamping (`instanceBinding==true`, `wasPreBound==true`):
+     *   `_stampTemplate` calls `_bindTemplate(t, true)`: the `templateInfo`
+     *   returned matches the prebound one, and so this is `wasPreBound == true`
+     *   state; thus we _skip_ creating accessors, but _do_ create an instance
+     *   of the template info to serve as the start of our linked list (needs to
+     *   be an instance, not the prototypical one, so that we can add `nodeList`
+     *   to it to contain the `nodeInfo`-ordered list of instance nodes for
+     *   bindings, and so we can chain runtime-stamped template infos off of
+     *   it). At this point, the call to `_stampTemplate` calls
+     *   `applyTemplateInfo` for each nested `<template>` found during parsing
+     *   to hand prototypical `_templateInfo` to them; we also pass the _parent_
+     *   `templateInfo` to the `<template>` so that we have the instance-time
+     *   parent to link the `templateInfo` under in the case it was
+     *   runtime-stamped.
+     *
+     * During subsequent runtime stamping (`instanceBinding==true`,
+     *   `wasPreBound==false`): `_stampTemplate` calls `_bindTemplate(t, true)`
+     *   - here `templateInfo` is guaranteed to _not_ match the prebound one,
+     *   because it was either a different template altogether, or even if it
+     *   was the same template, the step above created a instance of the info;
+     *   in this case `wasPreBound == false`, so we _do_ create accessors, _and_
+     *   link a instance into the linked list.
+     */
+    /**
+     * Equivalent to static `bindTemplate` API but can be called on an instance
+     * to add effects at runtime.  See that method for full API docs.
+     *
+     * This method may be called on the prototype (for prototypical template
+     * binding, to avoid creating accessors every instance) once per prototype,
+     * and will be called with `runtimeBinding: true` by `_stampTemplate` to
+     * create and link an instance of the template metadata associated with a
+     * particular stamping.
+     *
+     * @override
+     * @param {!HTMLTemplateElement} template Template containing binding
+     * bindings
+     * @param {boolean=} instanceBinding When false (default), performs
+     * "prototypical" binding of the template and overwrites any previously
+     * bound template for the class. When true (as passed from
+     * `_stampTemplate`), the template info is instanced and linked into the
+     * list of bound templates.
+     * @return {!TemplateInfo} Template metadata object; for `runtimeBinding`,
+     * this is an instance of the prototypical template info
+     * @protected
+     * @suppress {missingProperties} go/missingfnprops
+     */
+    _bindTemplate(template, instanceBinding) {
+      let templateInfo = this.constructor._parseTemplate(template);
+      let wasPreBound = this.__preBoundTemplateInfo == templateInfo;
+      if (!wasPreBound) {
+        for (let prop in templateInfo.propertyEffects) {
+          this._createPropertyAccessor(prop);
+        }
+      }
+      if (instanceBinding) {
+        templateInfo = /** @type {!TemplateInfo} */
+        Object.create(templateInfo);
+        templateInfo.wasPreBound = wasPreBound;
+        if (!this.__templateInfo) {
+          this.__templateInfo = templateInfo;
+        } else {
+          const parent = template._parentTemplateInfo || this.__templateInfo;
+          const previous = parent.lastChild;
+          templateInfo.parent = parent;
+          parent.lastChild = templateInfo;
+          templateInfo.previousSibling = previous;
+          if (previous) {
+            previous.nextSibling = templateInfo;
+          } else {
+            parent.firstChild = templateInfo;
+          }
+        }
+      } else {
+        this.__preBoundTemplateInfo = templateInfo;
+      }
+      return templateInfo;
+    }
+    /**
+     * Adds a property effect to the given template metadata, which is run
+     * at the "propagate" stage of `_propertiesChanged` when the template
+     * has been bound to the element via `_bindTemplate`.
+     *
+     * The `effect` object should match the format in `_addPropertyEffect`.
+     *
+     * @param {Object} templateInfo Template metadata to add effect to
+     * @param {string} prop Property that should trigger the effect
+     * @param {Object=} effect Effect metadata object
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static _addTemplatePropertyEffect(templateInfo, prop, effect) {
+      let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
+      hostProps[prop] = true;
+      let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};
+      let propEffects = effects[prop] = effects[prop] || [];
+      propEffects.push(effect);
+    }
+    /**
+     * Stamps the provided template and performs instance-time setup for
+     * Polymer template features, including data bindings, declarative event
+     * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
+     * is returned containing the stamped DOM, ready for insertion into the
+     * DOM.
+     *
+     * This method may be called more than once; however note that due to
+     * `shadycss` polyfill limitations, only styles from templates prepared
+     * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
+     * to the shadow root and support CSS custom properties), and note that
+     * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
+     * any styles required by in runtime-stamped templates must be included
+     * in the main element template.
+     *
+     * @param {!HTMLTemplateElement} template Template to stamp
+     * @param {TemplateInfo=} templateInfo Optional bound template info associated
+     *   with the template to be stamped; if omitted the template will be
+     *   automatically bound.
+     * @return {!StampedTemplate} Cloned template content
+     * @override
+     * @protected
+     */
+    _stampTemplate(template, templateInfo) {
+      templateInfo = templateInfo || /** @type {!TemplateInfo} */
+      this._bindTemplate(template, true);
+      hostStack.push(this);
+      let dom = super._stampTemplate(template, templateInfo);
+      hostStack.pop();
+      templateInfo.nodeList = dom.nodeList;
+      if (!templateInfo.wasPreBound) {
+        let nodes = templateInfo.childNodes = [];
+        for (let n = dom.firstChild; n; n = n.nextSibling) {
+          nodes.push(n);
+        }
+      }
+      dom.templateInfo = templateInfo;
+      setupBindings(this, templateInfo);
+      if (this.__dataClientsReady) {
+        this._runEffectsForTemplate(templateInfo, this.__data, null, false);
+        this._flushClients();
+      }
+      return dom;
+    }
+    /**
+     * Removes and unbinds the nodes previously contained in the provided
+     * DocumentFragment returned from `_stampTemplate`.
+     *
+     * @override
+     * @param {!StampedTemplate} dom DocumentFragment previously returned
+     *   from `_stampTemplate` associated with the nodes to be removed
+     * @return {void}
+     * @protected
+     */
+    _removeBoundDom(dom) {
+      const templateInfo = dom.templateInfo;
+      const { previousSibling, nextSibling, parent } = templateInfo;
+      if (previousSibling) {
+        previousSibling.nextSibling = nextSibling;
+      } else if (parent) {
+        parent.firstChild = nextSibling;
+      }
+      if (nextSibling) {
+        nextSibling.previousSibling = previousSibling;
+      } else if (parent) {
+        parent.lastChild = previousSibling;
+      }
+      templateInfo.nextSibling = templateInfo.previousSibling = null;
+      let nodes = templateInfo.childNodes;
+      for (let i = 0; i < nodes.length; i++) {
+        let node = nodes[i];
+        wrap(wrap(node).parentNode).removeChild(node);
+      }
+    }
+    /**
+     * Overrides default `TemplateStamp` implementation to add support for
+     * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`
+     * array is added to `nodeInfo` and populated with binding metadata
+     * with information capturing the binding target, and a `parts` array
+     * with one or more metadata objects capturing the source(s) of the
+     * binding.
+     *
+     * @param {Node} node Node to parse
+     * @param {TemplateInfo} templateInfo Template metadata for current template
+     * @param {NodeInfo} nodeInfo Node metadata for current template node
+     * @return {boolean} `true` if the visited node added node-specific
+     *   metadata to `nodeInfo`
+     * @protected
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _parseTemplateNode(node, templateInfo, nodeInfo) {
+      let noted = propertyEffectsBase._parseTemplateNode.call(
+        this,
+        node,
+        templateInfo,
+        nodeInfo
+      );
+      if (node.nodeType === Node.TEXT_NODE) {
+        let parts = this._parseBindings(node.textContent, templateInfo);
+        if (parts) {
+          node.textContent = literalFromParts(parts) || " ";
+          addBinding(this, templateInfo, nodeInfo, "text", "textContent", parts);
+          noted = true;
+        }
+      }
+      return noted;
+    }
+    /**
+     * Overrides default `TemplateStamp` implementation to add support for
+     * parsing bindings from attributes.  A `bindings`
+     * array is added to `nodeInfo` and populated with binding metadata
+     * with information capturing the binding target, and a `parts` array
+     * with one or more metadata objects capturing the source(s) of the
+     * binding.
+     *
+     * @param {Element} node Node to parse
+     * @param {TemplateInfo} templateInfo Template metadata for current template
+     * @param {NodeInfo} nodeInfo Node metadata for current template node
+     * @param {string} name Attribute name
+     * @param {string} value Attribute value
+     * @return {boolean} `true` if the visited node added node-specific
+     *   metadata to `nodeInfo`
+     * @protected
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
+      let parts = this._parseBindings(value, templateInfo);
+      if (parts) {
+        let origName = name;
+        let kind = "property";
+        if (capitalAttributeRegex.test(name)) {
+          kind = "attribute";
+        } else if (name[name.length - 1] == "$") {
+          name = name.slice(0, -1);
+          kind = "attribute";
+        }
+        let literal = literalFromParts(parts);
+        if (literal && kind == "attribute") {
+          if (name == "class" && node.hasAttribute("class")) {
+            literal += " " + node.getAttribute(name);
+          }
+          node.setAttribute(name, literal);
+        }
+        if (kind == "attribute" && origName == "disable-upgrade$") {
+          node.setAttribute(name, "");
+        }
+        if (node.localName === "input" && origName === "value") {
+          node.setAttribute(origName, "");
+        }
+        node.removeAttribute(origName);
+        if (kind === "property") {
+          name = dashToCamelCase(name);
+        }
+        addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
+        return true;
+      } else {
+        return propertyEffectsBase._parseTemplateNodeAttribute.call(
+          this,
+          node,
+          templateInfo,
+          nodeInfo,
+          name,
+          value
+        );
+      }
+    }
+    /**
+     * Overrides default `TemplateStamp` implementation to add support for
+     * binding the properties that a nested template depends on to the template
+     * as `_host_<property>`.
+     *
+     * @param {Node} node Node to parse
+     * @param {TemplateInfo} templateInfo Template metadata for current template
+     * @param {NodeInfo} nodeInfo Node metadata for current template node
+     * @return {boolean} `true` if the visited node added node-specific
+     *   metadata to `nodeInfo`
+     * @protected
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {
+      let noted = propertyEffectsBase._parseTemplateNestedTemplate.call(
+        this,
+        node,
+        templateInfo,
+        nodeInfo
+      );
+      const parent = node.parentNode;
+      const nestedTemplateInfo = nodeInfo.templateInfo;
+      const isDomIf = parent.localName === "dom-if";
+      const isDomRepeat = parent.localName === "dom-repeat";
+      if (removeNestedTemplates && (isDomIf || isDomRepeat)) {
+        parent.removeChild(node);
+        nodeInfo = nodeInfo.parentInfo;
+        nodeInfo.templateInfo = nestedTemplateInfo;
+        nodeInfo.noted = true;
+        noted = false;
+      }
+      let hostProps = nestedTemplateInfo.hostProps;
+      if (fastDomIf && isDomIf) {
+        if (hostProps) {
+          templateInfo.hostProps = Object.assign(templateInfo.hostProps || {}, hostProps);
+          if (!removeNestedTemplates) {
+            nodeInfo.parentInfo.noted = true;
+          }
+        }
+      } else {
+        let mode = "{";
+        for (let source in hostProps) {
+          let parts = [{ mode, source, dependencies: [source], hostProp: true }];
+          addBinding(this, templateInfo, nodeInfo, "property", "_host_" + source, parts);
+        }
+      }
+      return noted;
+    }
+    /**
+     * Called to parse text in a template (either attribute values or
+     * textContent) into binding metadata.
+     *
+     * Any overrides of this method should return an array of binding part
+     * metadata  representing one or more bindings found in the provided text
+     * and any "literal" text in between.  Any non-literal parts will be passed
+     * to `_evaluateBinding` when any dependencies change.  The only required
+     * fields of each "part" in the returned array are as follows:
+     *
+     * - `dependencies` - Array containing trigger metadata for each property
+     *   that should trigger the binding to update
+     * - `literal` - String containing text if the part represents a literal;
+     *   in this case no `dependencies` are needed
+     *
+     * Additional metadata for use by `_evaluateBinding` may be provided in
+     * each part object as needed.
+     *
+     * The default implementation handles the following types of bindings
+     * (one or more may be intermixed with literal strings):
+     * - Property binding: `[[prop]]`
+     * - Path binding: `[[object.prop]]`
+     * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+     * - Two-way property or path bindings (supports negation):
+     *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+     * - Inline computed method (supports negation):
+     *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+     *
+     * The default implementation uses a regular expression for best
+     * performance. However, the regular expression uses a white-list of
+     * allowed characters in a data-binding, which causes problems for
+     * data-bindings that do use characters not in this white-list.
+     *
+     * Instead of updating the white-list with all allowed characters,
+     * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
+     * that uses a state machine instead. This state machine is able to handle
+     * all characters. However, it is slightly less performant, therefore we
+     * extracted it into a separate optional mixin.
+     *
+     * @param {string} text Text to parse from attribute or textContent
+     * @param {Object} templateInfo Current template metadata
+     * @return {Array<!BindingPart>} Array of binding part metadata
+     * @protected
+     * @nocollapse
+     */
+    static _parseBindings(text, templateInfo) {
+      let parts = [];
+      let lastIndex = 0;
+      let m;
+      while ((m = bindingRegex.exec(text)) !== null) {
+        if (m.index > lastIndex) {
+          parts.push({ literal: text.slice(lastIndex, m.index) });
+        }
+        let mode = m[1][0];
+        let negate = Boolean(m[2]);
+        let source = m[3].trim();
+        let customEvent = false, notifyEvent = "", colon = -1;
+        if (mode == "{" && (colon = source.indexOf("::")) > 0) {
+          notifyEvent = source.substring(colon + 2);
+          source = source.substring(0, colon);
+          customEvent = true;
+        }
+        let signature = parseMethod(source);
+        let dependencies = [];
+        if (signature) {
+          let { args, methodName } = signature;
+          for (let i = 0; i < args.length; i++) {
+            let arg = args[i];
+            if (!arg.literal) {
+              dependencies.push(arg);
+            }
+          }
+          let dynamicFns = templateInfo.dynamicFns;
+          if (dynamicFns && dynamicFns[methodName] || signature.static) {
+            dependencies.push(methodName);
+            signature.dynamicFn = true;
+          }
+        } else {
+          dependencies.push(source);
+        }
+        parts.push({
+          source,
+          mode,
+          negate,
+          customEvent,
+          signature,
+          dependencies,
+          event: notifyEvent
+        });
+        lastIndex = bindingRegex.lastIndex;
+      }
+      if (lastIndex && lastIndex < text.length) {
+        let literal = text.substring(lastIndex);
+        if (literal) {
+          parts.push({
+            literal
+          });
+        }
+      }
+      if (parts.length) {
+        return parts;
+      } else {
+        return null;
+      }
+    }
+    /**
+     * Called to evaluate a previously parsed binding part based on a set of
+     * one or more changed dependencies.
+     *
+     * @param {!Polymer_PropertyEffects} inst Element that should be used as
+     *     scope for binding dependencies
+     * @param {BindingPart} part Binding part metadata
+     * @param {string} path Property/path that triggered this effect
+     * @param {Object} props Bag of current property changes
+     * @param {Object} oldProps Bag of previous values for changed properties
+     * @param {boolean} hasPaths True with `props` contains one or more paths
+     * @return {*} Value the binding part evaluated to
+     * @protected
+     * @nocollapse
+     */
+    static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {
+      let value;
+      if (part.signature) {
+        value = runMethodEffect(inst, path, props, oldProps, part.signature);
+      } else if (path != part.source) {
+        value = get(inst, part.source);
+      } else {
+        if (hasPaths && isPath(path)) {
+          value = get(inst, path);
+        } else {
+          value = inst.__data[path];
+        }
+      }
+      if (part.negate) {
+        value = !value;
+      }
+      return value;
+    }
+  }
+  return PropertyEffects2;
+});
+var hostStack = [];
+
+// ../../../node_modules/@polymer/polymer/lib/utils/telemetry.js
+var instanceCount = 0;
+function incrementInstanceCount() {
+  instanceCount++;
+}
+var registrations = [];
+function register(prototype) {
+  registrations.push(prototype);
+}
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/properties-mixin.js
+function normalizeProperties(props) {
+  const output = {};
+  for (let p in props) {
+    const o = props[p];
+    output[p] = typeof o === "function" ? { type: o } : o;
+  }
+  return output;
+}
+var PropertiesMixin = dedupingMixin((superClass) => {
+  const base = PropertiesChanged(superClass);
+  function superPropertiesClass(constructor) {
+    const superCtor = Object.getPrototypeOf(constructor);
+    return superCtor.prototype instanceof PropertiesMixin2 ? (
+      /** @type {!PropertiesMixinConstructor} */
+      superCtor
+    ) : null;
+  }
+  function ownProperties(constructor) {
+    if (!constructor.hasOwnProperty(JSCompiler_renameProperty("__ownProperties", constructor))) {
+      let props = null;
+      if (constructor.hasOwnProperty(JSCompiler_renameProperty("properties", constructor))) {
+        const properties = constructor.properties;
+        if (properties) {
+          props = normalizeProperties(properties);
+        }
+      }
+      constructor.__ownProperties = props;
+    }
+    return constructor.__ownProperties;
+  }
+  class PropertiesMixin2 extends base {
+    /**
+     * Implements standard custom elements getter to observes the attributes
+     * listed in `properties`.
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static get observedAttributes() {
+      if (!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes", this))) {
+        register(this.prototype);
+        const props = this._properties;
+        this.__observedAttributes = props ? Object.keys(props).map((p) => this.prototype._addPropertyToAttributeMap(p)) : [];
+      }
+      return this.__observedAttributes;
+    }
+    /**
+     * Finalizes an element definition, including ensuring any super classes
+     * are also finalized. This includes ensuring property
+     * accessors exist on the element prototype. This method calls
+     * `_finalizeClass` to finalize each constructor in the prototype chain.
+     * @return {void}
+     * @nocollapse
+     */
+    static finalize() {
+      if (!this.hasOwnProperty(JSCompiler_renameProperty("__finalized", this))) {
+        const superCtor = superPropertiesClass(
+          /** @type {!PropertiesMixinConstructor} */
+          this
+        );
+        if (superCtor) {
+          superCtor.finalize();
+        }
+        this.__finalized = true;
+        this._finalizeClass();
+      }
+    }
+    /**
+     * Finalize an element class. This includes ensuring property
+     * accessors exist on the element prototype. This method is called by
+     * `finalize` and finalizes the class constructor.
+     *
+     * @protected
+     * @nocollapse
+     */
+    static _finalizeClass() {
+      const props = ownProperties(
+        /** @type {!PropertiesMixinConstructor} */
+        this
+      );
+      if (props) {
+        this.createProperties(props);
+      }
+    }
+    /**
+     * Returns a memoized version of all properties, including those inherited
+     * from super classes. Properties not in object format are converted to
+     * at least {type}.
+     *
+     * @return {Object} Object containing properties for this class
+     * @protected
+     * @nocollapse
+     */
+    static get _properties() {
+      if (!this.hasOwnProperty(
+        JSCompiler_renameProperty("__properties", this)
+      )) {
+        const superCtor = superPropertiesClass(
+          /** @type {!PropertiesMixinConstructor} */
+          this
+        );
+        this.__properties = Object.assign(
+          {},
+          superCtor && superCtor._properties,
+          ownProperties(
+            /** @type {PropertiesMixinConstructor} */
+            this
+          )
+        );
+      }
+      return this.__properties;
+    }
+    /**
+     * Overrides `PropertiesChanged` method to return type specified in the
+     * static `properties` object for the given property.
+     * @param {string} name Name of property
+     * @return {*} Type to which to deserialize attribute
+     *
+     * @protected
+     * @nocollapse
+     */
+    static typeForProperty(name) {
+      const info = this._properties[name];
+      return info && info.type;
+    }
+    /**
+     * Overrides `PropertiesChanged` method and adds a call to
+     * `finalize` which lazily configures the element's property accessors.
+     * @override
+     * @return {void}
+     */
+    _initializeProperties() {
+      incrementInstanceCount();
+      this.constructor.finalize();
+      super._initializeProperties();
+    }
+    /**
+     * Called when the element is added to a document.
+     * Calls `_enableProperties` to turn on property system from
+     * `PropertiesChanged`.
+     * @suppress {missingProperties} Super may or may not implement the callback
+     * @return {void}
+     * @override
+     */
+    connectedCallback() {
+      if (super.connectedCallback) {
+        super.connectedCallback();
+      }
+      this._enableProperties();
+    }
+    /**
+     * Called when the element is removed from a document
+     * @suppress {missingProperties} Super may or may not implement the callback
+     * @return {void}
+     * @override
+     */
+    disconnectedCallback() {
+      if (super.disconnectedCallback) {
+        super.disconnectedCallback();
+      }
+    }
+  }
+  return PropertiesMixin2;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/element-mixin.js
+var version = "3.5.2";
+var builtCSS = window.ShadyCSS && window.ShadyCSS["cssBuild"];
+var ElementMixin = dedupingMixin((base) => {
+  const polymerElementBase = PropertiesMixin(PropertyEffects(base));
+  function propertyDefaults(constructor) {
+    if (!constructor.hasOwnProperty(
+      JSCompiler_renameProperty("__propertyDefaults", constructor)
+    )) {
+      constructor.__propertyDefaults = null;
+      let props = constructor._properties;
+      for (let p in props) {
+        let info = props[p];
+        if ("value" in info) {
+          constructor.__propertyDefaults = constructor.__propertyDefaults || {};
+          constructor.__propertyDefaults[p] = info;
+        }
+      }
+    }
+    return constructor.__propertyDefaults;
+  }
+  function ownObservers(constructor) {
+    if (!constructor.hasOwnProperty(
+      JSCompiler_renameProperty("__ownObservers", constructor)
+    )) {
+      constructor.__ownObservers = constructor.hasOwnProperty(
+        JSCompiler_renameProperty("observers", constructor)
+      ) ? (
+        /** @type {PolymerElementConstructor} */
+        constructor.observers
+      ) : null;
+    }
+    return constructor.__ownObservers;
+  }
+  function createPropertyFromConfig(proto2, name, info, allProps) {
+    if (info.computed) {
+      info.readOnly = true;
+    }
+    if (info.computed) {
+      if (proto2._hasReadOnlyEffect(name)) {
+        console.warn(`Cannot redefine computed property '${name}'.`);
+      } else {
+        proto2._createComputedProperty(name, info.computed, allProps);
+      }
+    }
+    if (info.readOnly && !proto2._hasReadOnlyEffect(name)) {
+      proto2._createReadOnlyProperty(name, !info.computed);
+    } else if (info.readOnly === false && proto2._hasReadOnlyEffect(name)) {
+      console.warn(`Cannot make readOnly property '${name}' non-readOnly.`);
+    }
+    if (info.reflectToAttribute && !proto2._hasReflectEffect(name)) {
+      proto2._createReflectedProperty(name);
+    } else if (info.reflectToAttribute === false && proto2._hasReflectEffect(name)) {
+      console.warn(`Cannot make reflected property '${name}' non-reflected.`);
+    }
+    if (info.notify && !proto2._hasNotifyEffect(name)) {
+      proto2._createNotifyingProperty(name);
+    } else if (info.notify === false && proto2._hasNotifyEffect(name)) {
+      console.warn(`Cannot make notify property '${name}' non-notify.`);
+    }
+    if (info.observer) {
+      proto2._createPropertyObserver(name, info.observer, allProps[info.observer]);
+    }
+    proto2._addPropertyToAttributeMap(name);
+  }
+  function processElementStyles(klass, template, is, baseURI) {
+    if (!builtCSS) {
+      const templateStyles = template.content.querySelectorAll("style");
+      const stylesWithImports = stylesFromTemplate(template);
+      const linkedStyles = stylesFromModuleImports(is);
+      const firstTemplateChild = template.content.firstElementChild;
+      for (let idx = 0; idx < linkedStyles.length; idx++) {
+        let s = linkedStyles[idx];
+        s.textContent = klass._processStyleText(s.textContent, baseURI);
+        template.content.insertBefore(s, firstTemplateChild);
+      }
+      let templateStyleIndex = 0;
+      for (let i = 0; i < stylesWithImports.length; i++) {
+        let s = stylesWithImports[i];
+        let templateStyle = templateStyles[templateStyleIndex];
+        if (templateStyle !== s) {
+          s = s.cloneNode(true);
+          templateStyle.parentNode.insertBefore(s, templateStyle);
+        } else {
+          templateStyleIndex++;
+        }
+        s.textContent = klass._processStyleText(s.textContent, baseURI);
+      }
+    }
+    if (window.ShadyCSS) {
+      window.ShadyCSS.prepareTemplate(template, is);
+    }
+    if (useAdoptedStyleSheetsWithBuiltCSS && builtCSS && supportsAdoptingStyleSheets) {
+      const styles = template.content.querySelectorAll("style");
+      if (styles) {
+        let css = "";
+        Array.from(styles).forEach((s) => {
+          css += s.textContent;
+          s.parentNode.removeChild(s);
+        });
+        klass._styleSheet = new CSSStyleSheet();
+        klass._styleSheet.replaceSync(css);
+      }
+    }
+  }
+  function getTemplateFromDomModule(is) {
+    let template = null;
+    if (is && (!strictTemplatePolicy || allowTemplateFromDomModule)) {
+      template = /** @type {?HTMLTemplateElement} */
+      DomModule.import(is, "template");
+      if (strictTemplatePolicy && !template) {
+        throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${is}`);
+      }
+    }
+    return template;
+  }
+  class PolymerElement extends polymerElementBase {
+    /**
+     * Current Polymer version in Semver notation.
+     * @type {string} Semver notation of the current version of Polymer.
+     * @nocollapse
+     */
+    static get polymerElementVersion() {
+      return version;
+    }
+    /**
+     * Override of PropertiesMixin _finalizeClass to create observers and
+     * find the template.
+     * @return {void}
+     * @protected
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _finalizeClass() {
+      polymerElementBase._finalizeClass.call(this);
+      const observers = ownObservers(this);
+      if (observers) {
+        this.createObservers(observers, this._properties);
+      }
+      this._prepareTemplate();
+    }
+    /** @nocollapse */
+    static _prepareTemplate() {
+      let template = (
+        /** @type {PolymerElementConstructor} */
+        this.template
+      );
+      if (template) {
+        if (typeof template === "string") {
+          console.error("template getter must return HTMLTemplateElement");
+          template = null;
+        } else if (!legacyOptimizations) {
+          template = template.cloneNode(true);
+        }
+      }
+      this.prototype._template = template;
+    }
+    /**
+     * Override of PropertiesChanged createProperties to create accessors
+     * and property effects for all of the properties.
+     * @param {!Object} props .
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createProperties(props) {
+      for (let p in props) {
+        createPropertyFromConfig(
+          /** @type {?} */
+          this.prototype,
+          p,
+          props[p],
+          props
+        );
+      }
+    }
+    /**
+     * Creates observers for the given `observers` array.
+     * Leverages `PropertyEffects` to create observers.
+     * @param {Object} observers Array of observer descriptors for
+     *   this class
+     * @param {Object} dynamicFns Object containing keys for any properties
+     *   that are functions and should trigger the effect when the function
+     *   reference is changed
+     * @return {void}
+     * @protected
+     * @nocollapse
+     */
+    static createObservers(observers, dynamicFns) {
+      const proto2 = this.prototype;
+      for (let i = 0; i < observers.length; i++) {
+        proto2._createMethodObserver(observers[i], dynamicFns);
+      }
+    }
+    /**
+     * Returns the template that will be stamped into this element's shadow root.
+     *
+     * If a `static get is()` getter is defined, the default implementation will
+     * return the first `<template>` in a `dom-module` whose `id` matches this
+     * element's `is` (note that a `_template` property on the class prototype
+     * takes precedence over the `dom-module` template, to maintain legacy
+     * element semantics; a subclass will subsequently fall back to its super
+     * class template if neither a `prototype._template` or a `dom-module` for
+     * the class's `is` was found).
+     *
+     * Users may override this getter to return an arbitrary template
+     * (in which case the `is` getter is unnecessary). The template returned
+     * must be an `HTMLTemplateElement`.
+     *
+     * Note that when subclassing, if the super class overrode the default
+     * implementation and the subclass would like to provide an alternate
+     * template via a `dom-module`, it should override this getter and
+     * return `DomModule.import(this.is, 'template')`.
+     *
+     * If a subclass would like to modify the super class template, it should
+     * clone it rather than modify it in place.  If the getter does expensive
+     * work such as cloning/modifying a template, it should memoize the
+     * template for maximum performance:
+     *
+     *   let memoizedTemplate;
+     *   class MySubClass extends MySuperClass {
+     *     static get template() {
+     *       if (!memoizedTemplate) {
+     *         memoizedTemplate = super.template.cloneNode(true);
+     *         let subContent = document.createElement('div');
+     *         subContent.textContent = 'This came from MySubClass';
+     *         memoizedTemplate.content.appendChild(subContent);
+     *       }
+     *       return memoizedTemplate;
+     *     }
+     *   }
+     *
+     * @return {!HTMLTemplateElement|string} Template to be stamped
+     * @nocollapse
+     */
+    static get template() {
+      if (!this.hasOwnProperty(JSCompiler_renameProperty("_template", this))) {
+        let protoTemplate = this.prototype.hasOwnProperty(
+          JSCompiler_renameProperty("_template", this.prototype)
+        ) ? this.prototype._template : void 0;
+        if (typeof protoTemplate === "function") {
+          protoTemplate = protoTemplate();
+        }
+        this._template = // If user has put template on prototype (e.g. in legacy via registered
+        // callback or info object), prefer that first. Note that `null` is
+        // used as a sentinel to indicate "no template" and can be used to
+        // override a super template, whereas `undefined` is used as a
+        // sentinel to mean "fall-back to default template lookup" via
+        // dom-module and/or super.template.
+        protoTemplate !== void 0 ? protoTemplate : (
+          // Look in dom-module associated with this element's is
+          this.hasOwnProperty(JSCompiler_renameProperty("is", this)) && getTemplateFromDomModule(
+            /** @type {PolymerElementConstructor}*/
+            this.is
+          ) || // Next look for superclass template (call the super impl this
+          // way so that `this` points to the superclass)
+          Object.getPrototypeOf(
+            /** @type {PolymerElementConstructor}*/
+            this.prototype
+          ).constructor.template
+        );
+      }
+      return this._template;
+    }
+    /**
+     * Set the template.
+     *
+     * @param {!HTMLTemplateElement|string} value Template to set.
+     * @nocollapse
+     */
+    static set template(value) {
+      this._template = value;
+    }
+    /**
+     * Path matching the url from which the element was imported.
+     *
+     * This path is used to resolve url's in template style cssText.
+     * The `importPath` property is also set on element instances and can be
+     * used to create bindings relative to the import path.
+     *
+     * For elements defined in ES modules, users should implement
+     * `static get importMeta() { return import.meta; }`, and the default
+     * implementation of `importPath` will  return `import.meta.url`'s path.
+     * For elements defined in HTML imports, this getter will return the path
+     * to the document containing a `dom-module` element matching this
+     * element's static `is` property.
+     *
+     * Note, this path should contain a trailing `/`.
+     *
+     * @return {string} The import path for this element class
+     * @suppress {missingProperties}
+     * @nocollapse
+     */
+    static get importPath() {
+      if (!this.hasOwnProperty(JSCompiler_renameProperty("_importPath", this))) {
+        const meta = this.importMeta;
+        if (meta) {
+          this._importPath = pathFromUrl(meta.url);
+        } else {
+          const module = DomModule.import(
+            /** @type {PolymerElementConstructor} */
+            this.is
+          );
+          this._importPath = module && module.assetpath || Object.getPrototypeOf(
+            /** @type {PolymerElementConstructor}*/
+            this.prototype
+          ).constructor.importPath;
+        }
+      }
+      return this._importPath;
+    }
+    constructor() {
+      super();
+      this._template;
+      this._importPath;
+      this.rootPath;
+      this.importPath;
+      this.root;
+      this.$;
+    }
+    /**
+     * Overrides the default `PropertyAccessors` to ensure class
+     * metaprogramming related to property accessors and effects has
+     * completed (calls `finalize`).
+     *
+     * It also initializes any property defaults provided via `value` in
+     * `properties` metadata.
+     *
+     * @return {void}
+     * @override
+     * @suppress {invalidCasts,missingProperties} go/missingfnprops
+     */
+    _initializeProperties() {
+      this.constructor.finalize();
+      this.constructor._finalizeTemplate(
+        /** @type {!HTMLElement} */
+        this.localName
+      );
+      super._initializeProperties();
+      this.rootPath = rootPath;
+      this.importPath = this.constructor.importPath;
+      let p$ = propertyDefaults(this.constructor);
+      if (!p$) {
+        return;
+      }
+      for (let p in p$) {
+        let info = p$[p];
+        if (this._canApplyPropertyDefault(p)) {
+          let value = typeof info.value == "function" ? info.value.call(this) : info.value;
+          if (this._hasAccessor(p)) {
+            this._setPendingProperty(p, value, true);
+          } else {
+            this[p] = value;
+          }
+        }
+      }
+    }
+    /**
+     * Determines if a property dfeault can be applied. For example, this
+     * prevents a default from being applied when a property that has no
+     * accessor is overridden by its host before upgrade (e.g. via a binding).
+     * @override
+     * @param {string} property Name of the property
+     * @return {boolean} Returns true if the property default can be applied.
+     */
+    _canApplyPropertyDefault(property) {
+      return !this.hasOwnProperty(property);
+    }
+    /**
+     * Gather style text for a style element in the template.
+     *
+     * @param {string} cssText Text containing styling to process
+     * @param {string} baseURI Base URI to rebase CSS paths against
+     * @return {string} The processed CSS text
+     * @protected
+     * @nocollapse
+     */
+    static _processStyleText(cssText, baseURI) {
+      return resolveCss(cssText, baseURI);
+    }
+    /**
+    * Configures an element `proto` to function with a given `template`.
+    * The element name `is` and extends `ext` must be specified for ShadyCSS
+    * style scoping.
+    *
+    * @param {string} is Tag name (or type extension name) for this element
+    * @return {void}
+    * @protected
+    * @nocollapse
+    */
+    static _finalizeTemplate(is) {
+      const template = this.prototype._template;
+      if (template && !template.__polymerFinalized) {
+        template.__polymerFinalized = true;
+        const importPath = this.importPath;
+        const baseURI = importPath ? resolveUrl(importPath) : "";
+        processElementStyles(this, template, is, baseURI);
+        this.prototype._bindTemplate(template);
+      }
+    }
+    /**
+     * Provides a default implementation of the standard Custom Elements
+     * `connectedCallback`.
+     *
+     * The default implementation enables the property effects system and
+     * flushes any pending properties, and updates shimmed CSS properties
+     * when using the ShadyCSS scoping/custom properties polyfill.
+     *
+     * @override
+     * @suppress {missingProperties, invalidCasts} Super may or may not
+     *     implement the callback
+     * @return {void}
+     */
+    connectedCallback() {
+      if (window.ShadyCSS && this._template) {
+        window.ShadyCSS.styleElement(
+          /** @type {!HTMLElement} */
+          this
+        );
+      }
+      super.connectedCallback();
+    }
+    /**
+     * Stamps the element template.
+     *
+     * @return {void}
+     * @override
+     */
+    ready() {
+      if (this._template) {
+        this.root = this._stampTemplate(this._template);
+        this.$ = this.root.$;
+      }
+      super.ready();
+    }
+    /**
+     * Implements `PropertyEffects`'s `_readyClients` call. Attaches
+     * element dom by calling `_attachDom` with the dom stamped from the
+     * element's template via `_stampTemplate`. Note that this allows
+     * client dom to be attached to the element prior to any observers
+     * running.
+     *
+     * @return {void}
+     * @override
+     */
+    _readyClients() {
+      if (this._template) {
+        this.root = this._attachDom(
+          /** @type {StampedTemplate} */
+          this.root
+        );
+      }
+      super._readyClients();
+    }
+    /**
+     * Attaches an element's stamped dom to itself. By default,
+     * this method creates a `shadowRoot` and adds the dom to it.
+     * However, this method may be overridden to allow an element
+     * to put its dom in another location.
+     *
+     * @override
+     * @throws {Error}
+     * @suppress {missingReturn}
+     * @param {StampedTemplate} dom to attach to the element.
+     * @return {ShadowRoot} node to which the dom has been attached.
+     */
+    _attachDom(dom) {
+      const n = wrap(this);
+      if (n.attachShadow) {
+        if (dom) {
+          if (!n.shadowRoot) {
+            n.attachShadow({ mode: "open", shadyUpgradeFragment: dom });
+            n.shadowRoot.appendChild(dom);
+            if (this.constructor._styleSheet) {
+              n.shadowRoot.adoptedStyleSheets = [this.constructor._styleSheet];
+            }
+          }
+          if (syncInitialRender && window.ShadyDOM) {
+            window.ShadyDOM.flushInitial(n.shadowRoot);
+          }
+          return n.shadowRoot;
+        }
+        return null;
+      } else {
+        throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.");
+      }
+    }
+    /**
+     * When using the ShadyCSS scoping and custom property shim, causes all
+     * shimmed styles in this element (and its subtree) to be updated
+     * based on current custom property values.
+     *
+     * The optional parameter overrides inline custom property styles with an
+     * object of properties where the keys are CSS properties, and the values
+     * are strings.
+     *
+     * Example: `this.updateStyles({'--color': 'blue'})`
+     *
+     * These properties are retained unless a value of `null` is set.
+     *
+     * Note: This function does not support updating CSS mixins.
+     * You can not dynamically change the value of an `@apply`.
+     *
+     * @override
+     * @param {Object=} properties Bag of custom property key/values to
+     *   apply to this element.
+     * @return {void}
+     * @suppress {invalidCasts}
+     */
+    updateStyles(properties) {
+      if (window.ShadyCSS) {
+        window.ShadyCSS.styleSubtree(
+          /** @type {!HTMLElement} */
+          this,
+          properties
+        );
+      }
+    }
+    /**
+     * Rewrites a given URL relative to a base URL. The base URL defaults to
+     * the original location of the document containing the `dom-module` for
+     * this element. This method will return the same URL before and after
+     * bundling.
+     *
+     * Note that this function performs no resolution for URLs that start
+     * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose
+     * URL resolution, use `window.URL`.
+     *
+     * @override
+     * @param {string} url URL to resolve.
+     * @param {string=} base Optional base URL to resolve against, defaults
+     * to the element's `importPath`
+     * @return {string} Rewritten URL relative to base
+     */
+    resolveUrl(url, base2) {
+      if (!base2 && this.importPath) {
+        base2 = resolveUrl(this.importPath);
+      }
+      return resolveUrl(url, base2);
+    }
+    /**
+     * Overrides `PropertyEffects` to add map of dynamic functions on
+     * template info, for consumption by `PropertyEffects` template binding
+     * code. This map determines which method templates should have accessors
+     * created for them.
+     *
+     * @param {!HTMLTemplateElement} template Template
+     * @param {!TemplateInfo} templateInfo Template metadata for current template
+     * @param {!NodeInfo} nodeInfo Node metadata for current template.
+     * @return {boolean} .
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _parseTemplateContent(template, templateInfo, nodeInfo) {
+      templateInfo.dynamicFns = templateInfo.dynamicFns || this._properties;
+      return polymerElementBase._parseTemplateContent.call(
+        this,
+        template,
+        templateInfo,
+        nodeInfo
+      );
+    }
+    /**
+     * Overrides `PropertyEffects` to warn on use of undeclared properties in
+     * template.
+     *
+     * @param {Object} templateInfo Template metadata to add effect to
+     * @param {string} prop Property that should trigger the effect
+     * @param {Object=} effect Effect metadata object
+     * @return {void}
+     * @protected
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _addTemplatePropertyEffect(templateInfo, prop, effect) {
+      if (legacyWarnings && !(prop in this._properties) && // Methods used in templates with no dependencies (or only literal
+      // dependencies) become accessors with template effects; ignore these
+      !(effect.info.part.signature && effect.info.part.signature.static) && // Warnings for bindings added to nested templates are handled by
+      // templatizer so ignore both the host-to-template bindings
+      // (`hostProp`) and TemplateInstance-to-child bindings
+      // (`nestedTemplate`)
+      !effect.info.part.hostProp && !templateInfo.nestedTemplate) {
+        console.warn(`Property '${prop}' used in template but not declared in 'properties'; attribute will not be observed.`);
+      }
+      return polymerElementBase._addTemplatePropertyEffect.call(
+        this,
+        templateInfo,
+        prop,
+        effect
+      );
+    }
+  }
+  return PolymerElement;
+});
+
+export {
+  useShadow,
+  passiveTouchGestures,
+  strictTemplatePolicy,
+  legacyOptimizations,
+  legacyWarnings,
+  cancelSyntheticClickEvents,
+  fastDomIf,
+  suppressTemplateNotifications,
+  legacyNoObservedAttributes,
+  cssFromModules,
+  wrap,
+  root,
+  translate,
+  matches,
+  get,
+  timeOut,
+  microTask,
+  PropertyAccessors,
+  PropertyEffects,
+  register,
+  version,
+  builtCSS,
+  ElementMixin
+};
+//# sourceMappingURL=chunk-PRUGAEYJ.js.map