@avs/go-react 0.12.71731 → 0.12.71739

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

@@ -0,0 +1,4597 @@
+import {
+  ElementMixin,
+  PropertyAccessors,
+  builtCSS,
+  cancelSyntheticClickEvents,
+  get,
+  legacyNoObservedAttributes,
+  legacyOptimizations,
+  microTask,
+  passiveTouchGestures,
+  register,
+  timeOut,
+  wrap
+} from "./chunk-PRUGAEYJ.js";
+import {
+  dedupingMixin
+} from "./chunk-I2HDYNON.js";
+
+// ../../../node_modules/@webcomponents/shadycss/src/style-settings.js
+var nativeShadow = !(window["ShadyDOM"] && window["ShadyDOM"]["inUse"]);
+var nativeCssVariables_;
+function calcCssVariables(settings) {
+  if (settings && settings["shimcssproperties"]) {
+    nativeCssVariables_ = false;
+  } else {
+    nativeCssVariables_ = nativeShadow || Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/) && window.CSS && CSS.supports && CSS.supports("box-shadow", "0 0 0 var(--foo)"));
+  }
+}
+var cssBuild;
+if (window.ShadyCSS && window.ShadyCSS.cssBuild !== void 0) {
+  cssBuild = window.ShadyCSS.cssBuild;
+}
+var disableRuntime = Boolean(window.ShadyCSS && window.ShadyCSS.disableRuntime);
+if (window.ShadyCSS && window.ShadyCSS.nativeCss !== void 0) {
+  nativeCssVariables_ = window.ShadyCSS.nativeCss;
+} else if (window.ShadyCSS) {
+  calcCssVariables(window.ShadyCSS);
+  window.ShadyCSS = void 0;
+} else {
+  calcCssVariables(window["WebComponents"] && window["WebComponents"]["flags"]);
+}
+var nativeCssVariables = (
+  /** @type {boolean} */
+  nativeCssVariables_
+);
+
+// ../../../node_modules/@webcomponents/shadycss/src/css-parse.js
+var StyleNode = class {
+  constructor() {
+    this["start"] = 0;
+    this["end"] = 0;
+    this["previous"] = null;
+    this["parent"] = null;
+    this["rules"] = null;
+    this["parsedCssText"] = "";
+    this["cssText"] = "";
+    this["atRule"] = false;
+    this["type"] = 0;
+    this["keyframesName"] = "";
+    this["selector"] = "";
+    this["parsedSelector"] = "";
+  }
+};
+function parse(text) {
+  text = clean(text);
+  return parseCss(lex(text), text);
+}
+function clean(cssText) {
+  return cssText.replace(RX.comments, "").replace(RX.port, "");
+}
+function lex(text) {
+  let root = new StyleNode();
+  root["start"] = 0;
+  root["end"] = text.length;
+  let n = root;
+  for (let i = 0, l = text.length; i < l; i++) {
+    if (text[i] === OPEN_BRACE) {
+      if (!n["rules"]) {
+        n["rules"] = [];
+      }
+      let p2 = n;
+      let previous = p2["rules"][p2["rules"].length - 1] || null;
+      n = new StyleNode();
+      n["start"] = i + 1;
+      n["parent"] = p2;
+      n["previous"] = previous;
+      p2["rules"].push(n);
+    } else if (text[i] === CLOSE_BRACE) {
+      n["end"] = i + 1;
+      n = n["parent"] || root;
+    }
+  }
+  return root;
+}
+function parseCss(node, text) {
+  let t = text.substring(node["start"], node["end"] - 1);
+  node["parsedCssText"] = node["cssText"] = t.trim();
+  if (node["parent"]) {
+    let ss = node["previous"] ? node["previous"]["end"] : node["parent"]["start"];
+    t = text.substring(ss, node["start"] - 1);
+    t = _expandUnicodeEscapes(t);
+    t = t.replace(RX.multipleSpaces, " ");
+    t = t.substring(t.lastIndexOf(";") + 1);
+    let s = node["parsedSelector"] = node["selector"] = t.trim();
+    node["atRule"] = s.indexOf(AT_START) === 0;
+    if (node["atRule"]) {
+      if (s.indexOf(MEDIA_START) === 0) {
+        node["type"] = types.MEDIA_RULE;
+      } else if (s.match(RX.keyframesRule)) {
+        node["type"] = types.KEYFRAMES_RULE;
+        node["keyframesName"] = node["selector"].split(RX.multipleSpaces).pop();
+      }
+    } else {
+      if (s.indexOf(VAR_START) === 0) {
+        node["type"] = types.MIXIN_RULE;
+      } else {
+        node["type"] = types.STYLE_RULE;
+      }
+    }
+  }
+  let r$ = node["rules"];
+  if (r$) {
+    for (let i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+      parseCss(r, text);
+    }
+  }
+  return node;
+}
+function _expandUnicodeEscapes(s) {
+  return s.replace(/\\([0-9a-f]{1,6})\s/gi, function() {
+    let code = arguments[1], repeat = 6 - code.length;
+    while (repeat--) {
+      code = "0" + code;
+    }
+    return "\\" + code;
+  });
+}
+function stringify(node, preserveProperties, text = "") {
+  let cssText = "";
+  if (node["cssText"] || node["rules"]) {
+    let r$ = node["rules"];
+    if (r$ && !_hasMixinRules(r$)) {
+      for (let i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+        cssText = stringify(r, preserveProperties, cssText);
+      }
+    } else {
+      cssText = preserveProperties ? node["cssText"] : removeCustomProps(node["cssText"]);
+      cssText = cssText.trim();
+      if (cssText) {
+        cssText = "  " + cssText + "\n";
+      }
+    }
+  }
+  if (cssText) {
+    if (node["selector"]) {
+      text += node["selector"] + " " + OPEN_BRACE + "\n";
+    }
+    text += cssText;
+    if (node["selector"]) {
+      text += CLOSE_BRACE + "\n\n";
+    }
+  }
+  return text;
+}
+function _hasMixinRules(rules) {
+  let r = rules[0];
+  return Boolean(r) && Boolean(r["selector"]) && r["selector"].indexOf(VAR_START) === 0;
+}
+function removeCustomProps(cssText) {
+  cssText = removeCustomPropAssignment(cssText);
+  return removeCustomPropApply(cssText);
+}
+function removeCustomPropAssignment(cssText) {
+  return cssText.replace(RX.customProp, "").replace(RX.mixinProp, "");
+}
+function removeCustomPropApply(cssText) {
+  return cssText.replace(RX.mixinApply, "").replace(RX.varApply, "");
+}
+var types = {
+  STYLE_RULE: 1,
+  KEYFRAMES_RULE: 7,
+  MEDIA_RULE: 4,
+  MIXIN_RULE: 1e3
+};
+var OPEN_BRACE = "{";
+var CLOSE_BRACE = "}";
+var RX = {
+  comments: /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
+  port: /@import[^;]*;/gim,
+  customProp: /(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,
+  mixinProp: /(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,
+  mixinApply: /@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,
+  varApply: /[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,
+  keyframesRule: /^@[^\s]*keyframes/,
+  multipleSpaces: /\s+/g
+};
+var VAR_START = "--";
+var MEDIA_START = "@media";
+var AT_START = "@";
+
+// ../../../node_modules/@webcomponents/shadycss/src/common-regex.js
+var VAR_ASSIGN = /(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi;
+var MIXIN_MATCH = /(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi;
+var MEDIA_MATCH = /@media\s(.*)/;
+
+// ../../../node_modules/@webcomponents/shadycss/src/unscoped-style-handler.js
+var styleTextSet = /* @__PURE__ */ new Set();
+var scopingAttribute = "shady-unscoped";
+function processUnscopedStyle(style) {
+  const text = style.textContent;
+  if (!styleTextSet.has(text)) {
+    styleTextSet.add(text);
+    const newStyle = document.createElement("style");
+    newStyle.setAttribute("shady-unscoped", "");
+    newStyle.textContent = text;
+    document.head.appendChild(newStyle);
+  }
+}
+function isUnscopedStyle(style) {
+  return style.hasAttribute(scopingAttribute);
+}
+
+// ../../../node_modules/@webcomponents/shadycss/src/style-util.js
+function toCssText(rules, callback) {
+  if (!rules) {
+    return "";
+  }
+  if (typeof rules === "string") {
+    rules = parse(rules);
+  }
+  if (callback) {
+    forEachRule(rules, callback);
+  }
+  return stringify(rules, nativeCssVariables);
+}
+function rulesForStyle(style) {
+  if (!style["__cssRules"] && style.textContent) {
+    style["__cssRules"] = parse(style.textContent);
+  }
+  return style["__cssRules"] || null;
+}
+function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {
+  if (!node) {
+    return;
+  }
+  let skipRules = false;
+  let type = node["type"];
+  if (onlyActiveRules) {
+    if (type === types.MEDIA_RULE) {
+      let matchMedia = node["selector"].match(MEDIA_MATCH);
+      if (matchMedia) {
+        if (!window.matchMedia(matchMedia[1]).matches) {
+          skipRules = true;
+        }
+      }
+    }
+  }
+  if (type === types.STYLE_RULE) {
+    styleRuleCallback(node);
+  } else if (keyframesRuleCallback && type === types.KEYFRAMES_RULE) {
+    keyframesRuleCallback(node);
+  } else if (type === types.MIXIN_RULE) {
+    skipRules = true;
+  }
+  let r$ = node["rules"];
+  if (r$ && !skipRules) {
+    for (let i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
+      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);
+    }
+  }
+}
+function findMatchingParen(text, start) {
+  let level = 0;
+  for (let i = start, l = text.length; i < l; i++) {
+    if (text[i] === "(") {
+      level++;
+    } else if (text[i] === ")") {
+      if (--level === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function processVariableAndFallback(str, callback) {
+  let start = str.indexOf("var(");
+  if (start === -1) {
+    return callback(str, "", "", "");
+  }
+  let end = findMatchingParen(str, start + 3);
+  let inner = str.substring(start + 4, end);
+  let prefix = str.substring(0, start);
+  let suffix = processVariableAndFallback(str.substring(end + 1), callback);
+  let comma = inner.indexOf(",");
+  if (comma === -1) {
+    return callback(prefix, inner.trim(), "", suffix);
+  }
+  let value = inner.substring(0, comma).trim();
+  let fallback = inner.substring(comma + 1).trim();
+  return callback(prefix, value, fallback, suffix);
+}
+var wrap2 = window["ShadyDOM"] && window["ShadyDOM"]["wrap"] || ((node) => node);
+function getIsExtends(element) {
+  let localName = element["localName"];
+  let is = "", typeExtension = "";
+  if (localName) {
+    if (localName.indexOf("-") > -1) {
+      is = localName;
+    } else {
+      typeExtension = localName;
+      is = element.getAttribute && element.getAttribute("is") || "";
+    }
+  } else {
+    is = /** @type {?} */
+    element.is;
+    typeExtension = /** @type {?} */
+    element.extends;
+  }
+  return { is, typeExtension };
+}
+function gatherStyleText(element) {
+  const styleTextParts = [];
+  const styles = (
+    /** @type {!NodeList<!HTMLStyleElement>} */
+    element.querySelectorAll("style")
+  );
+  for (let i = 0; i < styles.length; i++) {
+    const style = styles[i];
+    if (isUnscopedStyle(style)) {
+      if (!nativeShadow) {
+        processUnscopedStyle(style);
+        style.parentNode.removeChild(style);
+      }
+    } else {
+      styleTextParts.push(style.textContent);
+      style.parentNode.removeChild(style);
+    }
+  }
+  return styleTextParts.join("").trim();
+}
+var CSS_BUILD_ATTR = "css-build";
+function getCssBuild(element) {
+  if (cssBuild !== void 0) {
+    return (
+      /** @type {string} */
+      cssBuild
+    );
+  }
+  if (element.__cssBuild === void 0) {
+    const attrValue = element.getAttribute(CSS_BUILD_ATTR);
+    if (attrValue) {
+      element.__cssBuild = attrValue;
+    } else {
+      const buildComment = getBuildComment(element);
+      if (buildComment !== "") {
+        removeBuildComment(element);
+      }
+      element.__cssBuild = buildComment;
+    }
+  }
+  return element.__cssBuild || "";
+}
+function elementHasBuiltCss(element) {
+  return getCssBuild(element) !== "";
+}
+function getBuildComment(element) {
+  const buildComment = element.localName === "template" ? (
+    /** @type {!HTMLTemplateElement} */
+    element.content.firstChild
+  ) : element.firstChild;
+  if (buildComment instanceof Comment) {
+    const commentParts = buildComment.textContent.trim().split(":");
+    if (commentParts[0] === CSS_BUILD_ATTR) {
+      return commentParts[1];
+    }
+  }
+  return "";
+}
+function removeBuildComment(element) {
+  const buildComment = element.localName === "template" ? (
+    /** @type {!HTMLTemplateElement} */
+    element.content.firstChild
+  ) : element.firstChild;
+  buildComment.parentNode.removeChild(buildComment);
+}
+
+// ../../../node_modules/@webcomponents/shadycss/src/common-utils.js
+function updateNativeProperties(element, properties) {
+  for (let p2 in properties) {
+    if (p2 === null) {
+      element.style.removeProperty(p2);
+    } else {
+      element.style.setProperty(p2, properties[p2]);
+    }
+  }
+}
+function getComputedStyleValue(element, property) {
+  const value = window.getComputedStyle(element).getPropertyValue(property);
+  if (!value) {
+    return "";
+  } else {
+    return value.trim();
+  }
+}
+function detectMixin(cssText) {
+  const has = MIXIN_MATCH.test(cssText) || VAR_ASSIGN.test(cssText);
+  MIXIN_MATCH.lastIndex = 0;
+  VAR_ASSIGN.lastIndex = 0;
+  return has;
+}
+
+// ../../../node_modules/@webcomponents/shadycss/src/apply-shim.js
+var APPLY_NAME_CLEAN = /;\s*/m;
+var INITIAL_INHERIT = /^\s*(initial)|(inherit)\s*$/;
+var IMPORTANT = /\s*!important/;
+var MIXIN_VAR_SEP = "_-_";
+var MixinMap = class {
+  constructor() {
+    this._map = {};
+  }
+  /**
+   * @param {string} name
+   * @param {!PropertyEntry} props
+   */
+  set(name, props) {
+    name = name.trim();
+    this._map[name] = {
+      properties: props,
+      dependants: {}
+    };
+  }
+  /**
+   * @param {string} name
+   * @return {MixinMapEntry}
+   */
+  get(name) {
+    name = name.trim();
+    return this._map[name] || null;
+  }
+};
+var invalidCallback = null;
+var ApplyShim = class {
+  constructor() {
+    this._currentElement = null;
+    this._measureElement = null;
+    this._map = new MixinMap();
+  }
+  /**
+   * return true if `cssText` contains a mixin definition or consumption
+   * @param {string} cssText
+   * @return {boolean}
+   */
+  detectMixin(cssText) {
+    return detectMixin(cssText);
+  }
+  /**
+   * Gather styles into one style for easier processing
+   * @param {!HTMLTemplateElement} template
+   * @return {HTMLStyleElement}
+   */
+  gatherStyles(template) {
+    const styleText = gatherStyleText(template.content);
+    if (styleText) {
+      const style = (
+        /** @type {!HTMLStyleElement} */
+        document.createElement("style")
+      );
+      style.textContent = styleText;
+      template.content.insertBefore(style, template.content.firstChild);
+      return style;
+    }
+    return null;
+  }
+  /**
+   * @param {!HTMLTemplateElement} template
+   * @param {string} elementName
+   * @return {StyleNode}
+   */
+  transformTemplate(template, elementName) {
+    if (template._gatheredStyle === void 0) {
+      template._gatheredStyle = this.gatherStyles(template);
+    }
+    const style = template._gatheredStyle;
+    return style ? this.transformStyle(style, elementName) : null;
+  }
+  /**
+   * @param {!HTMLStyleElement} style
+   * @param {string} elementName
+   * @return {StyleNode}
+   */
+  transformStyle(style, elementName = "") {
+    let ast = rulesForStyle(style);
+    this.transformRules(ast, elementName);
+    style.textContent = toCssText(ast);
+    return ast;
+  }
+  /**
+   * @param {!HTMLStyleElement} style
+   * @return {StyleNode}
+   */
+  transformCustomStyle(style) {
+    let ast = rulesForStyle(style);
+    forEachRule(ast, (rule) => {
+      if (rule["selector"] === ":root") {
+        rule["selector"] = "html";
+      }
+      this.transformRule(rule);
+    });
+    style.textContent = toCssText(ast);
+    return ast;
+  }
+  /**
+   * @param {StyleNode} rules
+   * @param {string} elementName
+   */
+  transformRules(rules, elementName) {
+    this._currentElement = elementName;
+    forEachRule(rules, (r) => {
+      this.transformRule(r);
+    });
+    this._currentElement = null;
+  }
+  /**
+   * @param {!StyleNode} rule
+   */
+  transformRule(rule) {
+    rule["cssText"] = this.transformCssText(rule["parsedCssText"], rule);
+    if (rule["selector"] === ":root") {
+      rule["selector"] = ":host > *";
+    }
+  }
+  /**
+   * @param {string} cssText
+   * @param {!StyleNode} rule
+   * @return {string}
+   */
+  transformCssText(cssText, rule) {
+    cssText = cssText.replace(VAR_ASSIGN, (matchText, propertyName, valueProperty, valueMixin) => this._produceCssProperties(matchText, propertyName, valueProperty, valueMixin, rule));
+    return this._consumeCssProperties(cssText, rule);
+  }
+  /**
+   * @param {string} property
+   * @return {string}
+   */
+  _getInitialValueForProperty(property) {
+    if (!this._measureElement) {
+      this._measureElement = /** @type {HTMLMetaElement} */
+      document.createElement("meta");
+      this._measureElement.setAttribute("apply-shim-measure", "");
+      this._measureElement.style.all = "initial";
+      document.head.appendChild(this._measureElement);
+    }
+    return window.getComputedStyle(this._measureElement).getPropertyValue(property);
+  }
+  /**
+   * Walk over all rules before this rule to find fallbacks for mixins
+   *
+   * @param {!StyleNode} startRule
+   * @return {!Object}
+   */
+  _fallbacksFromPreviousRules(startRule) {
+    let topRule = startRule;
+    while (topRule["parent"]) {
+      topRule = topRule["parent"];
+    }
+    const fallbacks = {};
+    let seenStartRule = false;
+    forEachRule(topRule, (r) => {
+      seenStartRule = seenStartRule || r === startRule;
+      if (seenStartRule) {
+        return;
+      }
+      if (r["selector"] === startRule["selector"]) {
+        Object.assign(fallbacks, this._cssTextToMap(r["parsedCssText"]));
+      }
+    });
+    return fallbacks;
+  }
+  /**
+   * replace mixin consumption with variable consumption
+   * @param {string} text
+   * @param {!StyleNode=} rule
+   * @return {string}
+   */
+  _consumeCssProperties(text, rule) {
+    let m = null;
+    while (m = MIXIN_MATCH.exec(text)) {
+      let matchText = m[0];
+      let mixinName = m[1];
+      let idx = m.index;
+      let applyPos = idx + matchText.indexOf("@apply");
+      let afterApplyPos = idx + matchText.length;
+      let textBeforeApply = text.slice(0, applyPos);
+      let textAfterApply = text.slice(afterApplyPos);
+      let defaults = rule ? this._fallbacksFromPreviousRules(rule) : {};
+      Object.assign(defaults, this._cssTextToMap(textBeforeApply));
+      let replacement = this._atApplyToCssProperties(mixinName, defaults);
+      text = `${textBeforeApply}${replacement}${textAfterApply}`;
+      MIXIN_MATCH.lastIndex = idx + replacement.length;
+    }
+    return text;
+  }
+  /**
+   * produce variable consumption at the site of mixin consumption
+   * `@apply` --foo; -> for all props (${propname}: var(--foo_-_${propname}, ${fallback[propname]}}))
+   * Example:
+   *  border: var(--foo_-_border); padding: var(--foo_-_padding, 2px)
+   *
+   * @param {string} mixinName
+   * @param {Object} fallbacks
+   * @return {string}
+   */
+  _atApplyToCssProperties(mixinName, fallbacks) {
+    mixinName = mixinName.replace(APPLY_NAME_CLEAN, "");
+    let vars = [];
+    let mixinEntry = this._map.get(mixinName);
+    if (!mixinEntry) {
+      this._map.set(mixinName, {});
+      mixinEntry = this._map.get(mixinName);
+    }
+    if (mixinEntry) {
+      if (this._currentElement) {
+        mixinEntry.dependants[this._currentElement] = true;
+      }
+      let p2, parts, f;
+      const properties = mixinEntry.properties;
+      for (p2 in properties) {
+        f = fallbacks && fallbacks[p2];
+        parts = [p2, ": var(", mixinName, MIXIN_VAR_SEP, p2];
+        if (f) {
+          parts.push(",", f.replace(IMPORTANT, ""));
+        }
+        parts.push(")");
+        if (IMPORTANT.test(properties[p2])) {
+          parts.push(" !important");
+        }
+        vars.push(parts.join(""));
+      }
+    }
+    return vars.join("; ");
+  }
+  /**
+   * @param {string} property
+   * @param {string} value
+   * @return {string}
+   */
+  _replaceInitialOrInherit(property, value) {
+    let match = INITIAL_INHERIT.exec(value);
+    if (match) {
+      if (match[1]) {
+        value = this._getInitialValueForProperty(property);
+      } else {
+        value = "apply-shim-inherit";
+      }
+    }
+    return value;
+  }
+  /**
+   * "parse" a mixin definition into a map of properties and values
+   * cssTextToMap('border: 2px solid black') -> ('border', '2px solid black')
+   * @param {string} text
+   * @param {boolean=} replaceInitialOrInherit
+   * @return {!Object<string, string>}
+   */
+  _cssTextToMap(text, replaceInitialOrInherit = false) {
+    let props = text.split(";");
+    let property, value;
+    let out = {};
+    for (let i = 0, p2, sp; i < props.length; i++) {
+      p2 = props[i];
+      if (p2) {
+        sp = p2.split(":");
+        if (sp.length > 1) {
+          property = sp[0].trim();
+          value = sp.slice(1).join(":");
+          if (replaceInitialOrInherit) {
+            value = this._replaceInitialOrInherit(property, value);
+          }
+          out[property] = value;
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * @param {MixinMapEntry} mixinEntry
+   */
+  _invalidateMixinEntry(mixinEntry) {
+    if (!invalidCallback) {
+      return;
+    }
+    for (let elementName in mixinEntry.dependants) {
+      if (elementName !== this._currentElement) {
+        invalidCallback(elementName);
+      }
+    }
+  }
+  /**
+   * @param {string} matchText
+   * @param {string} propertyName
+   * @param {?string} valueProperty
+   * @param {?string} valueMixin
+   * @param {!StyleNode} rule
+   * @return {string}
+   */
+  _produceCssProperties(matchText, propertyName, valueProperty, valueMixin, rule) {
+    if (valueProperty) {
+      processVariableAndFallback(valueProperty, (prefix2, value) => {
+        if (value && this._map.get(value)) {
+          valueMixin = `@apply ${value};`;
+        }
+      });
+    }
+    if (!valueMixin) {
+      return matchText;
+    }
+    let mixinAsProperties = this._consumeCssProperties("" + valueMixin, rule);
+    let prefix = matchText.slice(0, matchText.indexOf("--"));
+    let mixinValues = this._cssTextToMap(mixinAsProperties, true);
+    let combinedProps = mixinValues;
+    let mixinEntry = this._map.get(propertyName);
+    let oldProps = mixinEntry && mixinEntry.properties;
+    if (oldProps) {
+      combinedProps = Object.assign(Object.create(oldProps), mixinValues);
+    } else {
+      this._map.set(propertyName, combinedProps);
+    }
+    let out = [];
+    let p2, v;
+    let needToInvalidate = false;
+    for (p2 in combinedProps) {
+      v = mixinValues[p2];
+      if (v === void 0) {
+        v = "initial";
+      }
+      if (oldProps && !(p2 in oldProps)) {
+        needToInvalidate = true;
+      }
+      out.push(`${propertyName}${MIXIN_VAR_SEP}${p2}: ${v}`);
+    }
+    if (needToInvalidate) {
+      this._invalidateMixinEntry(mixinEntry);
+    }
+    if (mixinEntry) {
+      mixinEntry.properties = combinedProps;
+    }
+    if (valueProperty) {
+      prefix = `${matchText};${prefix}`;
+    }
+    return `${prefix}${out.join("; ")};`;
+  }
+};
+ApplyShim.prototype["detectMixin"] = ApplyShim.prototype.detectMixin;
+ApplyShim.prototype["transformStyle"] = ApplyShim.prototype.transformStyle;
+ApplyShim.prototype["transformCustomStyle"] = ApplyShim.prototype.transformCustomStyle;
+ApplyShim.prototype["transformRules"] = ApplyShim.prototype.transformRules;
+ApplyShim.prototype["transformRule"] = ApplyShim.prototype.transformRule;
+ApplyShim.prototype["transformTemplate"] = ApplyShim.prototype.transformTemplate;
+ApplyShim.prototype["_separator"] = MIXIN_VAR_SEP;
+Object.defineProperty(ApplyShim.prototype, "invalidCallback", {
+  /** @return {?function(string)} */
+  get() {
+    return invalidCallback;
+  },
+  /** @param {?function(string)} cb */
+  set(cb) {
+    invalidCallback = cb;
+  }
+});
+var apply_shim_default = ApplyShim;
+
+// ../../../node_modules/@webcomponents/shadycss/src/template-map.js
+var templateMap = {};
+var template_map_default = templateMap;
+
+// ../../../node_modules/@webcomponents/shadycss/src/apply-shim-utils.js
+var CURRENT_VERSION = "_applyShimCurrentVersion";
+var NEXT_VERSION = "_applyShimNextVersion";
+var VALIDATING_VERSION = "_applyShimValidatingVersion";
+var promise = Promise.resolve();
+function invalidate(elementName) {
+  let template = template_map_default[elementName];
+  if (template) {
+    invalidateTemplate(template);
+  }
+}
+function invalidateTemplate(template) {
+  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;
+  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;
+  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;
+}
+function templateIsValid(template) {
+  return template[CURRENT_VERSION] === template[NEXT_VERSION];
+}
+function templateIsValidating(template) {
+  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];
+}
+function startValidatingTemplate(template) {
+  template[VALIDATING_VERSION] = template[NEXT_VERSION];
+  if (!template._validating) {
+    template._validating = true;
+    promise.then(function() {
+      template[CURRENT_VERSION] = template[NEXT_VERSION];
+      template._validating = false;
+    });
+  }
+}
+
+// ../../../node_modules/@webcomponents/shadycss/src/document-wait.js
+var readyPromise = null;
+var whenReady = window["HTMLImports"] && window["HTMLImports"]["whenReady"] || null;
+var resolveFn;
+function documentWait(callback) {
+  requestAnimationFrame(function() {
+    if (whenReady) {
+      whenReady(callback);
+    } else {
+      if (!readyPromise) {
+        readyPromise = new Promise((resolve2) => {
+          resolveFn = resolve2;
+        });
+        if (document.readyState === "complete") {
+          resolveFn();
+        } else {
+          document.addEventListener("readystatechange", () => {
+            if (document.readyState === "complete") {
+              resolveFn();
+            }
+          });
+        }
+      }
+      readyPromise.then(function() {
+        callback && callback();
+      });
+    }
+  });
+}
+
+// ../../../node_modules/@webcomponents/shadycss/src/custom-style-interface.js
+var SEEN_MARKER = "__seenByShadyCSS";
+var CACHED_STYLE = "__shadyCSSCachedStyle";
+var transformFn = null;
+var validateFn = null;
+var CustomStyleInterface = class {
+  constructor() {
+    this["customStyles"] = [];
+    this["enqueued"] = false;
+    documentWait(() => {
+      if (window["ShadyCSS"]["flushCustomStyles"]) {
+        window["ShadyCSS"]["flushCustomStyles"]();
+      }
+    });
+  }
+  /**
+   * Queue a validation for new custom styles to batch style recalculations
+   */
+  enqueueDocumentValidation() {
+    if (this["enqueued"] || !validateFn) {
+      return;
+    }
+    this["enqueued"] = true;
+    documentWait(validateFn);
+  }
+  /**
+   * @param {!HTMLStyleElement} style
+   */
+  addCustomStyle(style) {
+    if (!style[SEEN_MARKER]) {
+      style[SEEN_MARKER] = true;
+      this["customStyles"].push(style);
+      this.enqueueDocumentValidation();
+    }
+  }
+  /**
+   * @param {!CustomStyleProvider} customStyle
+   * @return {HTMLStyleElement}
+   */
+  getStyleForCustomStyle(customStyle) {
+    if (customStyle[CACHED_STYLE]) {
+      return customStyle[CACHED_STYLE];
+    }
+    let style;
+    if (customStyle["getStyle"]) {
+      style = customStyle["getStyle"]();
+    } else {
+      style = customStyle;
+    }
+    return style;
+  }
+  /**
+   * @return {!Array<!CustomStyleProvider>}
+   */
+  processStyles() {
+    const cs = this["customStyles"];
+    for (let i = 0; i < cs.length; i++) {
+      const customStyle = cs[i];
+      if (customStyle[CACHED_STYLE]) {
+        continue;
+      }
+      const style = this.getStyleForCustomStyle(customStyle);
+      if (style) {
+        const styleToTransform = (
+          /** @type {!HTMLStyleElement} */
+          style["__appliedElement"] || style
+        );
+        if (transformFn) {
+          transformFn(styleToTransform);
+        }
+        customStyle[CACHED_STYLE] = styleToTransform;
+      }
+    }
+    return cs;
+  }
+};
+CustomStyleInterface.prototype["addCustomStyle"] = CustomStyleInterface.prototype.addCustomStyle;
+CustomStyleInterface.prototype["getStyleForCustomStyle"] = CustomStyleInterface.prototype.getStyleForCustomStyle;
+CustomStyleInterface.prototype["processStyles"] = CustomStyleInterface.prototype.processStyles;
+Object.defineProperties(CustomStyleInterface.prototype, {
+  "transformCallback": {
+    /** @return {?function(!HTMLStyleElement)} */
+    get() {
+      return transformFn;
+    },
+    /** @param {?function(!HTMLStyleElement)} fn */
+    set(fn) {
+      transformFn = fn;
+    }
+  },
+  "validateCallback": {
+    /** @return {?function()} */
+    get() {
+      return validateFn;
+    },
+    /**
+     * @param {?function()} fn
+     * @this {CustomStyleInterface}
+     */
+    set(fn) {
+      let needsEnqueue = false;
+      if (!validateFn) {
+        needsEnqueue = true;
+      }
+      validateFn = fn;
+      if (needsEnqueue) {
+        this.enqueueDocumentValidation();
+      }
+    }
+  }
+});
+
+// ../../../node_modules/@webcomponents/shadycss/entrypoints/apply-shim.js
+var applyShim = new apply_shim_default();
+var ApplyShimInterface = class {
+  constructor() {
+    this.customStyleInterface = null;
+    applyShim["invalidCallback"] = invalidate;
+  }
+  ensure() {
+    if (this.customStyleInterface) {
+      return;
+    }
+    if (window.ShadyCSS.CustomStyleInterface) {
+      this.customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */
+      window.ShadyCSS.CustomStyleInterface;
+      this.customStyleInterface["transformCallback"] = (style) => {
+        applyShim.transformCustomStyle(style);
+      };
+      this.customStyleInterface["validateCallback"] = () => {
+        requestAnimationFrame(() => {
+          if (this.customStyleInterface["enqueued"]) {
+            this.flushCustomStyles();
+          }
+        });
+      };
+    }
+  }
+  /**
+   * @param {!HTMLTemplateElement} template
+   * @param {string} elementName
+   */
+  prepareTemplate(template, elementName) {
+    this.ensure();
+    if (elementHasBuiltCss(template)) {
+      return;
+    }
+    template_map_default[elementName] = template;
+    let ast = applyShim.transformTemplate(template, elementName);
+    template["_styleAst"] = ast;
+  }
+  flushCustomStyles() {
+    this.ensure();
+    if (!this.customStyleInterface) {
+      return;
+    }
+    let styles = this.customStyleInterface["processStyles"]();
+    if (!this.customStyleInterface["enqueued"]) {
+      return;
+    }
+    for (let i = 0; i < styles.length; i++) {
+      let cs = styles[i];
+      let style = this.customStyleInterface["getStyleForCustomStyle"](cs);
+      if (style) {
+        applyShim.transformCustomStyle(style);
+      }
+    }
+    this.customStyleInterface["enqueued"] = false;
+  }
+  /**
+   * @param {HTMLElement} element
+   * @param {Object=} properties
+   */
+  styleSubtree(element, properties) {
+    this.ensure();
+    if (properties) {
+      updateNativeProperties(element, properties);
+    }
+    if (element.shadowRoot) {
+      this.styleElement(element);
+      let shadowChildren = (
+        /** @type {!ParentNode} */
+        element.shadowRoot.children || element.shadowRoot.childNodes
+      );
+      for (let i = 0; i < shadowChildren.length; i++) {
+        this.styleSubtree(
+          /** @type {HTMLElement} */
+          shadowChildren[i]
+        );
+      }
+    } else {
+      let children = element.children || element.childNodes;
+      for (let i = 0; i < children.length; i++) {
+        this.styleSubtree(
+          /** @type {HTMLElement} */
+          children[i]
+        );
+      }
+    }
+  }
+  /**
+   * @param {HTMLElement} element
+   */
+  styleElement(element) {
+    this.ensure();
+    let { is } = getIsExtends(element);
+    let template = template_map_default[is];
+    if (template && elementHasBuiltCss(template)) {
+      return;
+    }
+    if (template && !templateIsValid(template)) {
+      if (!templateIsValidating(template)) {
+        this.prepareTemplate(template, is);
+        startValidatingTemplate(template);
+      }
+      let root = element.shadowRoot;
+      if (root) {
+        let style = (
+          /** @type {HTMLStyleElement} */
+          root.querySelector("style")
+        );
+        if (style) {
+          style["__cssRules"] = template["_styleAst"];
+          style.textContent = toCssText(template["_styleAst"]);
+        }
+      }
+    }
+  }
+  /**
+   * @param {Object=} properties
+   */
+  styleDocument(properties) {
+    this.ensure();
+    this.styleSubtree(document.body, properties);
+  }
+};
+if (!window.ShadyCSS || !window.ShadyCSS.ScopingShim) {
+  const applyShimInterface = new ApplyShimInterface();
+  let CustomStyleInterface2 = window.ShadyCSS && window.ShadyCSS.CustomStyleInterface;
+  window.ShadyCSS = {
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     * @param {string=} elementExtends
+     */
+    prepareTemplate(template, elementName, elementExtends) {
+      applyShimInterface.flushCustomStyles();
+      applyShimInterface.prepareTemplate(template, elementName);
+    },
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     * @param {string=} elementExtends
+     */
+    prepareTemplateStyles(template, elementName, elementExtends) {
+      window.ShadyCSS.prepareTemplate(template, elementName, elementExtends);
+    },
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     */
+    prepareTemplateDom(template, elementName) {
+    },
+    // eslint-disable-line no-unused-vars
+    /**
+     * @param {!HTMLElement} element
+     * @param {Object=} properties
+     */
+    styleSubtree(element, properties) {
+      applyShimInterface.flushCustomStyles();
+      applyShimInterface.styleSubtree(element, properties);
+    },
+    /**
+     * @param {!HTMLElement} element
+     */
+    styleElement(element) {
+      applyShimInterface.flushCustomStyles();
+      applyShimInterface.styleElement(element);
+    },
+    /**
+     * @param {Object=} properties
+     */
+    styleDocument(properties) {
+      applyShimInterface.flushCustomStyles();
+      applyShimInterface.styleDocument(properties);
+    },
+    /**
+     * @param {Element} element
+     * @param {string} property
+     * @return {string}
+     */
+    getComputedStyleValue(element, property) {
+      return getComputedStyleValue(element, property);
+    },
+    flushCustomStyles() {
+      applyShimInterface.flushCustomStyles();
+    },
+    nativeCss: nativeCssVariables,
+    nativeShadow,
+    cssBuild,
+    disableRuntime
+  };
+  if (CustomStyleInterface2) {
+    window.ShadyCSS.CustomStyleInterface = CustomStyleInterface2;
+  }
+}
+window.ShadyCSS.ApplyShim = applyShim;
+
+// ../../../node_modules/@polymer/polymer/lib/utils/debounce.js
+var Debouncer = class _Debouncer {
+  constructor() {
+    this._asyncModule = null;
+    this._callback = null;
+    this._timer = null;
+  }
+  /**
+   * Sets the scheduler; that is, a module with the Async interface,
+   * a callback and optional arguments to be passed to the run function
+   * from the async module.
+   *
+   * @param {!AsyncInterface} asyncModule Object with Async interface.
+   * @param {function()} callback Callback to run.
+   * @return {void}
+   */
+  setConfig(asyncModule, callback) {
+    this._asyncModule = asyncModule;
+    this._callback = callback;
+    this._timer = this._asyncModule.run(() => {
+      this._timer = null;
+      debouncerQueue.delete(this);
+      this._callback();
+    });
+  }
+  /**
+   * Cancels an active debouncer and returns a reference to itself.
+   *
+   * @return {void}
+   */
+  cancel() {
+    if (this.isActive()) {
+      this._cancelAsync();
+      debouncerQueue.delete(this);
+    }
+  }
+  /**
+   * Cancels a debouncer's async callback.
+   *
+   * @return {void}
+   */
+  _cancelAsync() {
+    if (this.isActive()) {
+      this._asyncModule.cancel(
+        /** @type {number} */
+        this._timer
+      );
+      this._timer = null;
+    }
+  }
+  /**
+   * Flushes an active debouncer and returns a reference to itself.
+   *
+   * @return {void}
+   */
+  flush() {
+    if (this.isActive()) {
+      this.cancel();
+      this._callback();
+    }
+  }
+  /**
+   * Returns true if the debouncer is active.
+   *
+   * @return {boolean} True if active.
+   */
+  isActive() {
+    return this._timer != null;
+  }
+  /**
+   * Creates a debouncer if no debouncer is passed as a parameter
+   * or it cancels an active debouncer otherwise. The following
+   * example shows how a debouncer can be called multiple times within a
+   * microtask and "debounced" such that the provided callback function is
+   * called once. Add this method to a custom element:
+   *
+   * ```js
+   * import {microTask} from '@polymer/polymer/lib/utils/async.js';
+   * import {Debouncer} from '@polymer/polymer/lib/utils/debounce.js';
+   * // ...
+   *
+   * _debounceWork() {
+   *   this._debounceJob = Debouncer.debounce(this._debounceJob,
+   *       microTask, () => this._doWork());
+   * }
+   * ```
+   *
+   * If the `_debounceWork` method is called multiple times within the same
+   * microtask, the `_doWork` function will be called only once at the next
+   * microtask checkpoint.
+   *
+   * Note: In testing it is often convenient to avoid asynchrony. To accomplish
+   * this with a debouncer, you can use `enqueueDebouncer` and
+   * `flush`. For example, extend the above example by adding
+   * `enqueueDebouncer(this._debounceJob)` at the end of the
+   * `_debounceWork` method. Then in a test, call `flush` to ensure
+   * the debouncer has completed.
+   *
+   * @param {Debouncer?} debouncer Debouncer object.
+   * @param {!AsyncInterface} asyncModule Object with Async interface
+   * @param {function()} callback Callback to run.
+   * @return {!Debouncer} Returns a debouncer object.
+   */
+  static debounce(debouncer, asyncModule, callback) {
+    if (debouncer instanceof _Debouncer) {
+      debouncer._cancelAsync();
+    } else {
+      debouncer = new _Debouncer();
+    }
+    debouncer.setConfig(asyncModule, callback);
+    return debouncer;
+  }
+};
+var debouncerQueue = /* @__PURE__ */ new Set();
+var enqueueDebouncer = function(debouncer) {
+  debouncerQueue.add(debouncer);
+};
+var flushDebouncers = function() {
+  const didFlush = Boolean(debouncerQueue.size);
+  debouncerQueue.forEach((debouncer) => {
+    try {
+      debouncer.flush();
+    } catch (e) {
+      setTimeout(() => {
+        throw e;
+      });
+    }
+  });
+  return didFlush;
+};
+
+// ../../../node_modules/@polymer/polymer/lib/utils/gestures.js
+var HAS_NATIVE_TA = typeof document.head.style.touchAction === "string";
+var GESTURE_KEY = "__polymerGestures";
+var HANDLED_OBJ = "__polymerGesturesHandled";
+var TOUCH_ACTION = "__polymerGesturesTouchAction";
+var TAP_DISTANCE = 25;
+var TRACK_DISTANCE = 5;
+var TRACK_LENGTH = 2;
+var MOUSE_TIMEOUT = 2500;
+var MOUSE_EVENTS = ["mousedown", "mousemove", "mouseup", "click"];
+var MOUSE_WHICH_TO_BUTTONS = [0, 1, 4, 2];
+var MOUSE_HAS_BUTTONS = (function() {
+  try {
+    return new MouseEvent("test", { buttons: 1 }).buttons === 1;
+  } catch (e) {
+    return false;
+  }
+})();
+function isMouseEvent(name) {
+  return MOUSE_EVENTS.indexOf(name) > -1;
+}
+var supportsPassive = false;
+(function() {
+  try {
+    let opts = Object.defineProperty({}, "passive", { get() {
+      supportsPassive = true;
+    } });
+    window.addEventListener("test", null, opts);
+    window.removeEventListener("test", null, opts);
+  } catch (e) {
+  }
+})();
+function PASSIVE_TOUCH(eventName) {
+  if (isMouseEvent(eventName) || eventName === "touchend") {
+    return;
+  }
+  if (HAS_NATIVE_TA && supportsPassive && passiveTouchGestures) {
+    return { passive: true };
+  } else {
+    return;
+  }
+}
+var IS_TOUCH_ONLY = navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/);
+var clickedLabels = [];
+var labellable = {
+  "button": true,
+  "input": true,
+  "keygen": true,
+  "meter": true,
+  "output": true,
+  "textarea": true,
+  "progress": true,
+  "select": true
+};
+var canBeDisabled = {
+  "button": true,
+  "command": true,
+  "fieldset": true,
+  "input": true,
+  "keygen": true,
+  "optgroup": true,
+  "option": true,
+  "select": true,
+  "textarea": true
+};
+function canBeLabelled(el) {
+  return labellable[el.localName] || false;
+}
+function matchingLabels(el) {
+  let labels = Array.prototype.slice.call(
+    /** @type {HTMLInputElement} */
+    el.labels || []
+  );
+  if (!labels.length) {
+    labels = [];
+    try {
+      let root = el.getRootNode();
+      if (el.id) {
+        let matching = root.querySelectorAll(`label[for = '${el.id}']`);
+        for (let i = 0; i < matching.length; i++) {
+          labels.push(
+            /** @type {!HTMLLabelElement} */
+            matching[i]
+          );
+        }
+      }
+    } catch (e) {
+    }
+  }
+  return labels;
+}
+var mouseCanceller = function(mouseEvent) {
+  let sc = mouseEvent.sourceCapabilities;
+  if (sc && !sc.firesTouchEvents) {
+    return;
+  }
+  mouseEvent[HANDLED_OBJ] = { skip: true };
+  if (mouseEvent.type === "click") {
+    let clickFromLabel = false;
+    let path = getComposedPath(mouseEvent);
+    for (let i = 0; i < path.length; i++) {
+      if (path[i].nodeType === Node.ELEMENT_NODE) {
+        if (path[i].localName === "label") {
+          clickedLabels.push(
+            /** @type {!HTMLLabelElement} */
+            path[i]
+          );
+        } else if (canBeLabelled(
+          /** @type {!HTMLElement} */
+          path[i]
+        )) {
+          let ownerLabels = matchingLabels(
+            /** @type {!HTMLElement} */
+            path[i]
+          );
+          for (let j = 0; j < ownerLabels.length; j++) {
+            clickFromLabel = clickFromLabel || clickedLabels.indexOf(ownerLabels[j]) > -1;
+          }
+        }
+      }
+      if (path[i] === POINTERSTATE.mouse.target) {
+        return;
+      }
+    }
+    if (clickFromLabel) {
+      return;
+    }
+    mouseEvent.preventDefault();
+    mouseEvent.stopPropagation();
+  }
+};
+function setupTeardownMouseCanceller(setup) {
+  let events = IS_TOUCH_ONLY ? ["click"] : MOUSE_EVENTS;
+  for (let i = 0, en; i < events.length; i++) {
+    en = events[i];
+    if (setup) {
+      clickedLabels.length = 0;
+      document.addEventListener(en, mouseCanceller, true);
+    } else {
+      document.removeEventListener(en, mouseCanceller, true);
+    }
+  }
+}
+function ignoreMouse(e) {
+  if (!cancelSyntheticClickEvents) {
+    return;
+  }
+  if (!POINTERSTATE.mouse.mouseIgnoreJob) {
+    setupTeardownMouseCanceller(true);
+  }
+  let unset = function() {
+    setupTeardownMouseCanceller();
+    POINTERSTATE.mouse.target = null;
+    POINTERSTATE.mouse.mouseIgnoreJob = null;
+  };
+  POINTERSTATE.mouse.target = getComposedPath(e)[0];
+  POINTERSTATE.mouse.mouseIgnoreJob = Debouncer.debounce(
+    POINTERSTATE.mouse.mouseIgnoreJob,
+    timeOut.after(MOUSE_TIMEOUT),
+    unset
+  );
+}
+function hasLeftMouseButton(ev) {
+  let type = ev.type;
+  if (!isMouseEvent(type)) {
+    return false;
+  }
+  if (type === "mousemove") {
+    let buttons = ev.buttons === void 0 ? 1 : ev.buttons;
+    if (ev instanceof window.MouseEvent && !MOUSE_HAS_BUTTONS) {
+      buttons = MOUSE_WHICH_TO_BUTTONS[ev.which] || 0;
+    }
+    return Boolean(buttons & 1);
+  } else {
+    let button = ev.button === void 0 ? 0 : ev.button;
+    return button === 0;
+  }
+}
+function isSyntheticClick(ev) {
+  if (ev.type === "click") {
+    if (ev.detail === 0) {
+      return true;
+    }
+    let t = _findOriginalTarget(ev);
+    if (!t.nodeType || /** @type {Element} */
+    t.nodeType !== Node.ELEMENT_NODE) {
+      return true;
+    }
+    let bcr = (
+      /** @type {Element} */
+      t.getBoundingClientRect()
+    );
+    let x = ev.pageX, y = ev.pageY;
+    return !(x >= bcr.left && x <= bcr.right && (y >= bcr.top && y <= bcr.bottom));
+  }
+  return false;
+}
+var POINTERSTATE = {
+  mouse: {
+    target: null,
+    mouseIgnoreJob: null
+  },
+  touch: {
+    x: 0,
+    y: 0,
+    id: -1,
+    scrollDecided: false
+  }
+};
+function firstTouchAction(ev) {
+  let ta = "auto";
+  let path = getComposedPath(ev);
+  for (let i = 0, n; i < path.length; i++) {
+    n = path[i];
+    if (n[TOUCH_ACTION]) {
+      ta = n[TOUCH_ACTION];
+      break;
+    }
+  }
+  return ta;
+}
+function trackDocument(stateObj, movefn, upfn) {
+  stateObj.movefn = movefn;
+  stateObj.upfn = upfn;
+  document.addEventListener("mousemove", movefn);
+  document.addEventListener("mouseup", upfn);
+}
+function untrackDocument(stateObj) {
+  document.removeEventListener("mousemove", stateObj.movefn);
+  document.removeEventListener("mouseup", stateObj.upfn);
+  stateObj.movefn = null;
+  stateObj.upfn = null;
+}
+if (cancelSyntheticClickEvents) {
+  document.addEventListener("touchend", ignoreMouse, supportsPassive ? { passive: true } : false);
+}
+var getComposedPath = window.ShadyDOM && window.ShadyDOM.noPatch ? window.ShadyDOM.composedPath : (event) => event.composedPath && event.composedPath() || [];
+var gestures = {};
+var recognizers = [];
+function deepTargetFind(x, y) {
+  let node = document.elementFromPoint(x, y);
+  let next = node;
+  while (next && next.shadowRoot && !window.ShadyDOM) {
+    let oldNext = next;
+    next = next.shadowRoot.elementFromPoint(x, y);
+    if (oldNext === next) {
+      break;
+    }
+    if (next) {
+      node = next;
+    }
+  }
+  return node;
+}
+function _findOriginalTarget(ev) {
+  const path = getComposedPath(
+    /** @type {?Event} */
+    ev
+  );
+  return path.length > 0 ? path[0] : ev.target;
+}
+function _handleNative(ev) {
+  let handled;
+  let type = ev.type;
+  let node = ev.currentTarget;
+  let gobj = node[GESTURE_KEY];
+  if (!gobj) {
+    return;
+  }
+  let gs = gobj[type];
+  if (!gs) {
+    return;
+  }
+  if (!ev[HANDLED_OBJ]) {
+    ev[HANDLED_OBJ] = {};
+    if (type.slice(0, 5) === "touch") {
+      ev = /** @type {TouchEvent} */
+      ev;
+      let t = ev.changedTouches[0];
+      if (type === "touchstart") {
+        if (ev.touches.length === 1) {
+          POINTERSTATE.touch.id = t.identifier;
+        }
+      }
+      if (POINTERSTATE.touch.id !== t.identifier) {
+        return;
+      }
+      if (!HAS_NATIVE_TA) {
+        if (type === "touchstart" || type === "touchmove") {
+          _handleTouchAction(ev);
+        }
+      }
+    }
+  }
+  handled = ev[HANDLED_OBJ];
+  if (handled.skip) {
+    return;
+  }
+  for (let i = 0, r; i < recognizers.length; i++) {
+    r = recognizers[i];
+    if (gs[r.name] && !handled[r.name]) {
+      if (r.flow && r.flow.start.indexOf(ev.type) > -1 && r.reset) {
+        r.reset();
+      }
+    }
+  }
+  for (let i = 0, r; i < recognizers.length; i++) {
+    r = recognizers[i];
+    if (gs[r.name] && !handled[r.name]) {
+      handled[r.name] = true;
+      r[type](ev);
+    }
+  }
+}
+function _handleTouchAction(ev) {
+  let t = ev.changedTouches[0];
+  let type = ev.type;
+  if (type === "touchstart") {
+    POINTERSTATE.touch.x = t.clientX;
+    POINTERSTATE.touch.y = t.clientY;
+    POINTERSTATE.touch.scrollDecided = false;
+  } else if (type === "touchmove") {
+    if (POINTERSTATE.touch.scrollDecided) {
+      return;
+    }
+    POINTERSTATE.touch.scrollDecided = true;
+    let ta = firstTouchAction(ev);
+    let shouldPrevent = false;
+    let dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
+    let dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
+    if (!ev.cancelable) {
+    } else if (ta === "none") {
+      shouldPrevent = true;
+    } else if (ta === "pan-x") {
+      shouldPrevent = dy > dx;
+    } else if (ta === "pan-y") {
+      shouldPrevent = dx > dy;
+    }
+    if (shouldPrevent) {
+      ev.preventDefault();
+    } else {
+      prevent("track");
+    }
+  }
+}
+function addListener(node, evType, handler) {
+  if (gestures[evType]) {
+    _add(node, evType, handler);
+    return true;
+  }
+  return false;
+}
+function removeListener(node, evType, handler) {
+  if (gestures[evType]) {
+    _remove(node, evType, handler);
+    return true;
+  }
+  return false;
+}
+function _add(node, evType, handler) {
+  let recognizer = gestures[evType];
+  let deps = recognizer.deps;
+  let name = recognizer.name;
+  let gobj = node[GESTURE_KEY];
+  if (!gobj) {
+    node[GESTURE_KEY] = gobj = {};
+  }
+  for (let i = 0, dep, gd; i < deps.length; i++) {
+    dep = deps[i];
+    if (IS_TOUCH_ONLY && isMouseEvent(dep) && dep !== "click") {
+      continue;
+    }
+    gd = gobj[dep];
+    if (!gd) {
+      gobj[dep] = gd = { _count: 0 };
+    }
+    if (gd._count === 0) {
+      node.addEventListener(dep, _handleNative, PASSIVE_TOUCH(dep));
+    }
+    gd[name] = (gd[name] || 0) + 1;
+    gd._count = (gd._count || 0) + 1;
+  }
+  node.addEventListener(evType, handler);
+  if (recognizer.touchAction) {
+    setTouchAction(node, recognizer.touchAction);
+  }
+}
+function _remove(node, evType, handler) {
+  let recognizer = gestures[evType];
+  let deps = recognizer.deps;
+  let name = recognizer.name;
+  let gobj = node[GESTURE_KEY];
+  if (gobj) {
+    for (let i = 0, dep, gd; i < deps.length; i++) {
+      dep = deps[i];
+      gd = gobj[dep];
+      if (gd && gd[name]) {
+        gd[name] = (gd[name] || 1) - 1;
+        gd._count = (gd._count || 1) - 1;
+        if (gd._count === 0) {
+          node.removeEventListener(dep, _handleNative, PASSIVE_TOUCH(dep));
+        }
+      }
+    }
+  }
+  node.removeEventListener(evType, handler);
+}
+function register2(recog) {
+  recognizers.push(recog);
+  for (let i = 0; i < recog.emits.length; i++) {
+    gestures[recog.emits[i]] = recog;
+  }
+}
+function _findRecognizerByEvent(evName) {
+  for (let i = 0, r; i < recognizers.length; i++) {
+    r = recognizers[i];
+    for (let j = 0, n; j < r.emits.length; j++) {
+      n = r.emits[j];
+      if (n === evName) {
+        return r;
+      }
+    }
+  }
+  return null;
+}
+function setTouchAction(node, value) {
+  if (HAS_NATIVE_TA && node instanceof HTMLElement) {
+    microTask.run(() => {
+      node.style.touchAction = value;
+    });
+  }
+  node[TOUCH_ACTION] = value;
+}
+function _fire(target, type, detail) {
+  let ev = new Event(type, { bubbles: true, cancelable: true, composed: true });
+  ev.detail = detail;
+  wrap(
+    /** @type {!Node} */
+    target
+  ).dispatchEvent(ev);
+  if (ev.defaultPrevented) {
+    let preventer = detail.preventer || detail.sourceEvent;
+    if (preventer && preventer.preventDefault) {
+      preventer.preventDefault();
+    }
+  }
+}
+function prevent(evName) {
+  let recognizer = _findRecognizerByEvent(evName);
+  if (recognizer.info) {
+    recognizer.info.prevent = true;
+  }
+}
+register2({
+  name: "downup",
+  deps: ["mousedown", "touchstart", "touchend"],
+  flow: {
+    start: ["mousedown", "touchstart"],
+    end: ["mouseup", "touchend"]
+  },
+  emits: ["down", "up"],
+  info: {
+    movefn: null,
+    upfn: null
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @return {void}
+   */
+  reset: function() {
+    untrackDocument(this.info);
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {MouseEvent} e
+   * @return {void}
+   */
+  mousedown: function(e) {
+    if (!hasLeftMouseButton(e)) {
+      return;
+    }
+    let t = _findOriginalTarget(e);
+    let self = this;
+    let movefn = function movefn2(e2) {
+      if (!hasLeftMouseButton(e2)) {
+        downupFire("up", t, e2);
+        untrackDocument(self.info);
+      }
+    };
+    let upfn = function upfn2(e2) {
+      if (hasLeftMouseButton(e2)) {
+        downupFire("up", t, e2);
+      }
+      untrackDocument(self.info);
+    };
+    trackDocument(this.info, movefn, upfn);
+    downupFire("down", t, e);
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchstart: function(e) {
+    downupFire("down", _findOriginalTarget(e), e.changedTouches[0], e);
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchend: function(e) {
+    downupFire("up", _findOriginalTarget(e), e.changedTouches[0], e);
+  }
+});
+function downupFire(type, target, event, preventer) {
+  if (!target) {
+    return;
+  }
+  _fire(target, type, {
+    x: event.clientX,
+    y: event.clientY,
+    sourceEvent: event,
+    preventer,
+    prevent: function(e) {
+      return prevent(e);
+    }
+  });
+}
+register2({
+  name: "track",
+  touchAction: "none",
+  deps: ["mousedown", "touchstart", "touchmove", "touchend"],
+  flow: {
+    start: ["mousedown", "touchstart"],
+    end: ["mouseup", "touchend"]
+  },
+  emits: ["track"],
+  info: {
+    x: 0,
+    y: 0,
+    state: "start",
+    started: false,
+    moves: [],
+    /** @this {GestureInfo} */
+    addMove: function(move) {
+      if (this.moves.length > TRACK_LENGTH) {
+        this.moves.shift();
+      }
+      this.moves.push(move);
+    },
+    movefn: null,
+    upfn: null,
+    prevent: false
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @return {void}
+   */
+  reset: function() {
+    this.info.state = "start";
+    this.info.started = false;
+    this.info.moves = [];
+    this.info.x = 0;
+    this.info.y = 0;
+    this.info.prevent = false;
+    untrackDocument(this.info);
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {MouseEvent} e
+   * @return {void}
+   */
+  mousedown: function(e) {
+    if (!hasLeftMouseButton(e)) {
+      return;
+    }
+    let t = _findOriginalTarget(e);
+    let self = this;
+    let movefn = function movefn2(e2) {
+      let x = e2.clientX, y = e2.clientY;
+      if (trackHasMovedEnough(self.info, x, y)) {
+        self.info.state = self.info.started ? e2.type === "mouseup" ? "end" : "track" : "start";
+        if (self.info.state === "start") {
+          prevent("tap");
+        }
+        self.info.addMove({ x, y });
+        if (!hasLeftMouseButton(e2)) {
+          self.info.state = "end";
+          untrackDocument(self.info);
+        }
+        if (t) {
+          trackFire(self.info, t, e2);
+        }
+        self.info.started = true;
+      }
+    };
+    let upfn = function upfn2(e2) {
+      if (self.info.started) {
+        movefn(e2);
+      }
+      untrackDocument(self.info);
+    };
+    trackDocument(this.info, movefn, upfn);
+    this.info.x = e.clientX;
+    this.info.y = e.clientY;
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchstart: function(e) {
+    let ct = e.changedTouches[0];
+    this.info.x = ct.clientX;
+    this.info.y = ct.clientY;
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchmove: function(e) {
+    let t = _findOriginalTarget(e);
+    let ct = e.changedTouches[0];
+    let x = ct.clientX, y = ct.clientY;
+    if (trackHasMovedEnough(this.info, x, y)) {
+      if (this.info.state === "start") {
+        prevent("tap");
+      }
+      this.info.addMove({ x, y });
+      trackFire(this.info, t, ct);
+      this.info.state = "track";
+      this.info.started = true;
+    }
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchend: function(e) {
+    let t = _findOriginalTarget(e);
+    let ct = e.changedTouches[0];
+    if (this.info.started) {
+      this.info.state = "end";
+      this.info.addMove({ x: ct.clientX, y: ct.clientY });
+      trackFire(this.info, t, ct);
+    }
+  }
+});
+function trackHasMovedEnough(info, x, y) {
+  if (info.prevent) {
+    return false;
+  }
+  if (info.started) {
+    return true;
+  }
+  let dx = Math.abs(info.x - x);
+  let dy = Math.abs(info.y - y);
+  return dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE;
+}
+function trackFire(info, target, touch) {
+  if (!target) {
+    return;
+  }
+  let secondlast = info.moves[info.moves.length - 2];
+  let lastmove = info.moves[info.moves.length - 1];
+  let dx = lastmove.x - info.x;
+  let dy = lastmove.y - info.y;
+  let ddx, ddy = 0;
+  if (secondlast) {
+    ddx = lastmove.x - secondlast.x;
+    ddy = lastmove.y - secondlast.y;
+  }
+  _fire(target, "track", {
+    state: info.state,
+    x: touch.clientX,
+    y: touch.clientY,
+    dx,
+    dy,
+    ddx,
+    ddy,
+    sourceEvent: touch,
+    hover: function() {
+      return deepTargetFind(touch.clientX, touch.clientY);
+    }
+  });
+}
+register2({
+  name: "tap",
+  deps: ["mousedown", "click", "touchstart", "touchend"],
+  flow: {
+    start: ["mousedown", "touchstart"],
+    end: ["click", "touchend"]
+  },
+  emits: ["tap"],
+  info: {
+    x: NaN,
+    y: NaN,
+    prevent: false
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @return {void}
+   */
+  reset: function() {
+    this.info.x = NaN;
+    this.info.y = NaN;
+    this.info.prevent = false;
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {MouseEvent} e
+   * @return {void}
+   */
+  mousedown: function(e) {
+    if (hasLeftMouseButton(e)) {
+      this.info.x = e.clientX;
+      this.info.y = e.clientY;
+    }
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {MouseEvent} e
+   * @return {void}
+   */
+  click: function(e) {
+    if (hasLeftMouseButton(e)) {
+      trackForward(this.info, e);
+    }
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchstart: function(e) {
+    const touch = e.changedTouches[0];
+    this.info.x = touch.clientX;
+    this.info.y = touch.clientY;
+  },
+  /**
+   * @this {GestureRecognizer}
+   * @param {TouchEvent} e
+   * @return {void}
+   */
+  touchend: function(e) {
+    trackForward(this.info, e.changedTouches[0], e);
+  }
+});
+function trackForward(info, e, preventer) {
+  let dx = Math.abs(e.clientX - info.x);
+  let dy = Math.abs(e.clientY - info.y);
+  let t = _findOriginalTarget(preventer || e);
+  if (!t || canBeDisabled[
+    /** @type {!HTMLElement} */
+    t.localName
+  ] && t.hasAttribute("disabled")) {
+    return;
+  }
+  if (isNaN(dx) || isNaN(dy) || dx <= TAP_DISTANCE && dy <= TAP_DISTANCE || isSyntheticClick(e)) {
+    if (!info.prevent) {
+      _fire(t, "tap", {
+        x: e.clientX,
+        y: e.clientY,
+        sourceEvent: e,
+        preventer
+      });
+    }
+  }
+}
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/gesture-event-listeners.js
+var GestureEventListeners = dedupingMixin((superClass) => {
+  class GestureEventListeners2 extends superClass {
+    /**
+     * Add the event listener to the node if it is a gestures event.
+     *
+     * @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) {
+      if (!addListener(node, eventName, handler)) {
+        super._addEventListenerToNode(node, eventName, handler);
+      }
+    }
+    /**
+     * Remove the event listener to the node if it is a gestures event.
+     *
+     * @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) {
+      if (!removeListener(node, eventName, handler)) {
+        super._removeEventListenerFromNode(node, eventName, handler);
+      }
+    }
+  }
+  return GestureEventListeners2;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/dir-mixin.js
+var HOST_DIR = /:host\(:dir\((ltr|rtl)\)\)/g;
+var HOST_DIR_REPLACMENT = ':host([dir="$1"])';
+var EL_DIR = /([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g;
+var EL_DIR_REPLACMENT = ':host([dir="$2"]) $1';
+var DIR_CHECK = /:dir\((?:ltr|rtl)\)/;
+var SHIM_SHADOW = Boolean(window["ShadyDOM"] && window["ShadyDOM"]["inUse"]);
+var DIR_INSTANCES = [];
+var observer = null;
+var documentDir = "";
+function getRTL() {
+  documentDir = document.documentElement.getAttribute("dir");
+}
+function setRTL(instance) {
+  if (!instance.__autoDirOptOut) {
+    const el = (
+      /** @type {!HTMLElement} */
+      instance
+    );
+    el.setAttribute("dir", documentDir);
+  }
+}
+function updateDirection() {
+  getRTL();
+  documentDir = document.documentElement.getAttribute("dir");
+  for (let i = 0; i < DIR_INSTANCES.length; i++) {
+    setRTL(DIR_INSTANCES[i]);
+  }
+}
+function takeRecords() {
+  if (observer && observer.takeRecords().length) {
+    updateDirection();
+  }
+}
+var DirMixin = dedupingMixin((base) => {
+  if (!SHIM_SHADOW) {
+    if (!observer) {
+      getRTL();
+      observer = new MutationObserver(updateDirection);
+      observer.observe(document.documentElement, { attributes: true, attributeFilter: ["dir"] });
+    }
+  }
+  const elementBase = PropertyAccessors(base);
+  class Dir extends elementBase {
+    /**
+     * @param {string} cssText .
+     * @param {string} baseURI .
+     * @return {string} .
+     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
+     * @nocollapse
+     */
+    static _processStyleText(cssText, baseURI) {
+      cssText = elementBase._processStyleText.call(this, cssText, baseURI);
+      if (!SHIM_SHADOW && DIR_CHECK.test(cssText)) {
+        cssText = this._replaceDirInCssText(cssText);
+        this.__activateDir = true;
+      }
+      return cssText;
+    }
+    /**
+     * Replace `:dir` in the given CSS text
+     *
+     * @param {string} text CSS text to replace DIR
+     * @return {string} Modified CSS
+     * @nocollapse
+     */
+    static _replaceDirInCssText(text) {
+      let replacedText = text;
+      replacedText = replacedText.replace(HOST_DIR, HOST_DIR_REPLACMENT);
+      replacedText = replacedText.replace(EL_DIR, EL_DIR_REPLACMENT);
+      return replacedText;
+    }
+    constructor() {
+      super();
+      this.__autoDirOptOut = false;
+    }
+    /**
+     * @override
+     * @suppress {invalidCasts} Closure doesn't understand that `this` is an
+     *     HTMLElement
+     * @return {void}
+     */
+    ready() {
+      super.ready();
+      this.__autoDirOptOut = /** @type {!HTMLElement} */
+      this.hasAttribute("dir");
+    }
+    /**
+     * @override
+     * @suppress {missingProperties} If it exists on elementBase, it can be
+     *   super'd
+     * @return {void}
+     */
+    connectedCallback() {
+      if (elementBase.prototype.connectedCallback) {
+        super.connectedCallback();
+      }
+      if (this.constructor.__activateDir) {
+        takeRecords();
+        DIR_INSTANCES.push(this);
+        setRTL(this);
+      }
+    }
+    /**
+     * @override
+     * @suppress {missingProperties} If it exists on elementBase, it can be
+     *   super'd
+     * @return {void}
+     */
+    disconnectedCallback() {
+      if (elementBase.prototype.disconnectedCallback) {
+        super.disconnectedCallback();
+      }
+      if (this.constructor.__activateDir) {
+        const idx = DIR_INSTANCES.indexOf(this);
+        if (idx > -1) {
+          DIR_INSTANCES.splice(idx, 1);
+        }
+      }
+    }
+  }
+  Dir.__activateDir = false;
+  return Dir;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/utils/unresolved.js
+function resolve() {
+  document.body.removeAttribute("unresolved");
+}
+if (document.readyState === "interactive" || document.readyState === "complete") {
+  resolve();
+} else {
+  window.addEventListener("DOMContentLoaded", resolve);
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/array-splice.js
+function newSplice(index, removed, addedCount) {
+  return {
+    index,
+    removed,
+    addedCount
+  };
+}
+var EDIT_LEAVE = 0;
+var EDIT_UPDATE = 1;
+var EDIT_ADD = 2;
+var EDIT_DELETE = 3;
+function calcEditDistances(current, currentStart, currentEnd, old, oldStart, oldEnd) {
+  let rowCount = oldEnd - oldStart + 1;
+  let columnCount = currentEnd - currentStart + 1;
+  let distances = new Array(rowCount);
+  for (let i = 0; i < rowCount; i++) {
+    distances[i] = new Array(columnCount);
+    distances[i][0] = i;
+  }
+  for (let j = 0; j < columnCount; j++)
+    distances[0][j] = j;
+  for (let i = 1; i < rowCount; i++) {
+    for (let j = 1; j < columnCount; j++) {
+      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))
+        distances[i][j] = distances[i - 1][j - 1];
+      else {
+        let north = distances[i - 1][j] + 1;
+        let west = distances[i][j - 1] + 1;
+        distances[i][j] = north < west ? north : west;
+      }
+    }
+  }
+  return distances;
+}
+function spliceOperationsFromEditDistances(distances) {
+  let i = distances.length - 1;
+  let j = distances[0].length - 1;
+  let current = distances[i][j];
+  let edits = [];
+  while (i > 0 || j > 0) {
+    if (i == 0) {
+      edits.push(EDIT_ADD);
+      j--;
+      continue;
+    }
+    if (j == 0) {
+      edits.push(EDIT_DELETE);
+      i--;
+      continue;
+    }
+    let northWest = distances[i - 1][j - 1];
+    let west = distances[i - 1][j];
+    let north = distances[i][j - 1];
+    let min;
+    if (west < north)
+      min = west < northWest ? west : northWest;
+    else
+      min = north < northWest ? north : northWest;
+    if (min == northWest) {
+      if (northWest == current) {
+        edits.push(EDIT_LEAVE);
+      } else {
+        edits.push(EDIT_UPDATE);
+        current = northWest;
+      }
+      i--;
+      j--;
+    } else if (min == west) {
+      edits.push(EDIT_DELETE);
+      i--;
+      current = west;
+    } else {
+      edits.push(EDIT_ADD);
+      j--;
+      current = north;
+    }
+  }
+  edits.reverse();
+  return edits;
+}
+function calcSplices(current, currentStart, currentEnd, old, oldStart, oldEnd) {
+  let prefixCount = 0;
+  let suffixCount = 0;
+  let splice;
+  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);
+  if (currentStart == 0 && oldStart == 0)
+    prefixCount = sharedPrefix(current, old, minLength);
+  if (currentEnd == current.length && oldEnd == old.length)
+    suffixCount = sharedSuffix(current, old, minLength - prefixCount);
+  currentStart += prefixCount;
+  oldStart += prefixCount;
+  currentEnd -= suffixCount;
+  oldEnd -= suffixCount;
+  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)
+    return [];
+  if (currentStart == currentEnd) {
+    splice = newSplice(currentStart, [], 0);
+    while (oldStart < oldEnd)
+      splice.removed.push(old[oldStart++]);
+    return [splice];
+  } else if (oldStart == oldEnd)
+    return [newSplice(currentStart, [], currentEnd - currentStart)];
+  let ops = spliceOperationsFromEditDistances(
+    calcEditDistances(
+      current,
+      currentStart,
+      currentEnd,
+      old,
+      oldStart,
+      oldEnd
+    )
+  );
+  splice = void 0;
+  let splices = [];
+  let index = currentStart;
+  let oldIndex = oldStart;
+  for (let i = 0; i < ops.length; i++) {
+    switch (ops[i]) {
+      case EDIT_LEAVE:
+        if (splice) {
+          splices.push(splice);
+          splice = void 0;
+        }
+        index++;
+        oldIndex++;
+        break;
+      case EDIT_UPDATE:
+        if (!splice)
+          splice = newSplice(index, [], 0);
+        splice.addedCount++;
+        index++;
+        splice.removed.push(old[oldIndex]);
+        oldIndex++;
+        break;
+      case EDIT_ADD:
+        if (!splice)
+          splice = newSplice(index, [], 0);
+        splice.addedCount++;
+        index++;
+        break;
+      case EDIT_DELETE:
+        if (!splice)
+          splice = newSplice(index, [], 0);
+        splice.removed.push(old[oldIndex]);
+        oldIndex++;
+        break;
+    }
+  }
+  if (splice) {
+    splices.push(splice);
+  }
+  return splices;
+}
+function sharedPrefix(current, old, searchLength) {
+  for (let i = 0; i < searchLength; i++)
+    if (!equals(current[i], old[i]))
+      return i;
+  return searchLength;
+}
+function sharedSuffix(current, old, searchLength) {
+  let index1 = current.length;
+  let index2 = old.length;
+  let count = 0;
+  while (count < searchLength && equals(current[--index1], old[--index2]))
+    count++;
+  return count;
+}
+function calculateSplices(current, previous) {
+  return calcSplices(
+    current,
+    0,
+    current.length,
+    previous,
+    0,
+    previous.length
+  );
+}
+function equals(currentValue, previousValue) {
+  return currentValue === previousValue;
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/flattened-nodes-observer.js
+function isSlot(node) {
+  return node.localName === "slot";
+}
+var FlattenedNodesObserver = class {
+  /**
+   * Returns the list of flattened nodes for the given `node`.
+   * This list consists of a node's children and, for any children
+   * that are `<slot>` elements, the expanded flattened list of `assignedNodes`.
+   * For example, if the observed node has children `<a></a><slot></slot><b></b>`
+   * and the `<slot>` has one `<div>` assigned to it, then the flattened
+   * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
+   * `<slot>` elements assigned to it, these are flattened as well.
+   *
+   * @param {!HTMLElement|!HTMLSlotElement} node The node for which to
+   *      return the list of flattened nodes.
+   * @return {!Array<!Node>} The list of flattened nodes for the given `node`.
+   * @nocollapse See https://github.com/google/closure-compiler/issues/2763
+   */
+  // eslint-disable-next-line
+  static getFlattenedNodes(node) {
+    const wrapped = wrap(node);
+    if (isSlot(node)) {
+      node = /** @type {!HTMLSlotElement} */
+      node;
+      return wrapped.assignedNodes({ flatten: true });
+    } else {
+      const results = [];
+      for (let i = 0; i < wrapped.childNodes.length; i++) {
+        const node2 = wrapped.childNodes[i];
+        if (isSlot(node2)) {
+          const slotNode = (
+            /** @type {!HTMLSlotElement} */
+            node2
+          );
+          results.push(...wrap(slotNode).assignedNodes({ flatten: true }));
+        } else {
+          results.push(node2);
+        }
+      }
+      return results;
+    }
+  }
+  /**
+   * @param {!HTMLElement} target Node on which to listen for changes.
+   * @param {?function(this: Element, { target: !HTMLElement, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Function called when there are additions
+   * or removals from the target's list of flattened nodes.
+   */
+  // eslint-disable-next-line
+  constructor(target, callback) {
+    this._shadyChildrenObserver = null;
+    this._nativeChildrenObserver = null;
+    this._connected = false;
+    this._target = target;
+    this.callback = callback;
+    this._effectiveNodes = [];
+    this._observer = null;
+    this._scheduled = false;
+    this._boundSchedule = () => {
+      this._schedule();
+    };
+    this.connect();
+    this._schedule();
+  }
+  /**
+   * Activates an observer. This method is automatically called when
+   * a `FlattenedNodesObserver` is created. It should only be called to
+   * re-activate an observer that has been deactivated via the `disconnect` method.
+   *
+   * @return {void}
+   */
+  connect() {
+    if (isSlot(this._target)) {
+      this._listenSlots([this._target]);
+    } else if (wrap(this._target).children) {
+      this._listenSlots(
+        /** @type {!NodeList<!Node>} */
+        wrap(this._target).children
+      );
+      if (window.ShadyDOM) {
+        this._shadyChildrenObserver = window.ShadyDOM.observeChildren(this._target, (mutations) => {
+          this._processMutations(mutations);
+        });
+      } else {
+        this._nativeChildrenObserver = new MutationObserver((mutations) => {
+          this._processMutations(mutations);
+        });
+        this._nativeChildrenObserver.observe(this._target, { childList: true });
+      }
+    }
+    this._connected = true;
+  }
+  /**
+   * Deactivates the flattened nodes observer. After calling this method
+   * the observer callback will not be called when changes to flattened nodes
+   * occur. The `connect` method may be subsequently called to reactivate
+   * the observer.
+   *
+   * @return {void}
+   * @override
+   */
+  disconnect() {
+    if (isSlot(this._target)) {
+      this._unlistenSlots([this._target]);
+    } else if (wrap(this._target).children) {
+      this._unlistenSlots(
+        /** @type {!NodeList<!Node>} */
+        wrap(this._target).children
+      );
+      if (window.ShadyDOM && this._shadyChildrenObserver) {
+        window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver);
+        this._shadyChildrenObserver = null;
+      } else if (this._nativeChildrenObserver) {
+        this._nativeChildrenObserver.disconnect();
+        this._nativeChildrenObserver = null;
+      }
+    }
+    this._connected = false;
+  }
+  /**
+   * @return {void}
+   * @private
+   */
+  _schedule() {
+    if (!this._scheduled) {
+      this._scheduled = true;
+      microTask.run(() => this.flush());
+    }
+  }
+  /**
+   * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
+   * @return {void}
+   * @private
+   */
+  _processMutations(mutations) {
+    this._processSlotMutations(mutations);
+    this.flush();
+  }
+  /**
+   * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
+   * @return {void}
+   * @private
+   */
+  _processSlotMutations(mutations) {
+    if (mutations) {
+      for (let i = 0; i < mutations.length; i++) {
+        let mutation = mutations[i];
+        if (mutation.addedNodes) {
+          this._listenSlots(mutation.addedNodes);
+        }
+        if (mutation.removedNodes) {
+          this._unlistenSlots(mutation.removedNodes);
+        }
+      }
+    }
+  }
+  /**
+   * Flushes the observer causing any pending changes to be immediately
+   * delivered the observer callback. By default these changes are delivered
+   * asynchronously at the next microtask checkpoint.
+   *
+   * @return {boolean} Returns true if any pending changes caused the observer
+   * callback to run.
+   */
+  flush() {
+    if (!this._connected) {
+      return false;
+    }
+    if (window.ShadyDOM) {
+      ShadyDOM.flush();
+    }
+    if (this._nativeChildrenObserver) {
+      this._processSlotMutations(this._nativeChildrenObserver.takeRecords());
+    } else if (this._shadyChildrenObserver) {
+      this._processSlotMutations(this._shadyChildrenObserver.takeRecords());
+    }
+    this._scheduled = false;
+    let info = {
+      target: this._target,
+      addedNodes: [],
+      removedNodes: []
+    };
+    let newNodes = this.constructor.getFlattenedNodes(this._target);
+    let splices = calculateSplices(
+      newNodes,
+      this._effectiveNodes
+    );
+    for (let i = 0, s; i < splices.length && (s = splices[i]); i++) {
+      for (let j = 0, n; j < s.removed.length && (n = s.removed[j]); j++) {
+        info.removedNodes.push(n);
+      }
+    }
+    for (let i = 0, s; i < splices.length && (s = splices[i]); i++) {
+      for (let j = s.index; j < s.index + s.addedCount; j++) {
+        info.addedNodes.push(newNodes[j]);
+      }
+    }
+    this._effectiveNodes = newNodes;
+    let didFlush = false;
+    if (info.addedNodes.length || info.removedNodes.length) {
+      didFlush = true;
+      this.callback.call(this._target, info);
+    }
+    return didFlush;
+  }
+  /**
+   * @param {!Array<!Node>|!NodeList<!Node>} nodeList Nodes that could change
+   * @return {void}
+   * @private
+   */
+  _listenSlots(nodeList) {
+    for (let i = 0; i < nodeList.length; i++) {
+      let n = nodeList[i];
+      if (isSlot(n)) {
+        n.addEventListener("slotchange", this._boundSchedule);
+      }
+    }
+  }
+  /**
+   * @param {!Array<!Node>|!NodeList<!Node>} nodeList Nodes that could change
+   * @return {void}
+   * @private
+   */
+  _unlistenSlots(nodeList) {
+    for (let i = 0; i < nodeList.length; i++) {
+      let n = nodeList[i];
+      if (isSlot(n)) {
+        n.removeEventListener("slotchange", this._boundSchedule);
+      }
+    }
+  }
+};
+
+// ../../../node_modules/@polymer/polymer/lib/utils/flush.js
+var flush = function() {
+  let shadyDOM, debouncers;
+  do {
+    shadyDOM = window.ShadyDOM && ShadyDOM.flush();
+    if (window.ShadyCSS && window.ShadyCSS.ScopingShim) {
+      window.ShadyCSS.ScopingShim.flush();
+    }
+    debouncers = flushDebouncers();
+  } while (shadyDOM || debouncers);
+};
+
+// ../../../node_modules/@polymer/polymer/lib/legacy/polymer.dom.js
+var p = Element.prototype;
+var normalizedMatchesSelector = p.matches || p.matchesSelector || p.mozMatchesSelector || p.msMatchesSelector || p.oMatchesSelector || p.webkitMatchesSelector;
+var matchesSelector = function(node, selector) {
+  return normalizedMatchesSelector.call(node, selector);
+};
+var DomApiNative = class {
+  /**
+   * @param {!Node} node Node for which to create a Polymer.dom helper object.
+   */
+  constructor(node) {
+    if (window["ShadyDOM"] && window["ShadyDOM"]["inUse"]) {
+      window["ShadyDOM"]["patch"](node);
+    }
+    this.node = node;
+  }
+  /**
+   * Returns an instance of `FlattenedNodesObserver` that
+   * listens for node changes on this element.
+   *
+   * @param {function(this:HTMLElement, { target: !HTMLElement, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Called when direct or distributed children
+   *   of this element changes
+   * @return {!PolymerDomApi.ObserveHandle} Observer instance
+   * @override
+   */
+  observeNodes(callback) {
+    return new FlattenedNodesObserver(
+      /** @type {!HTMLElement} */
+      this.node,
+      callback
+    );
+  }
+  /**
+   * Disconnects an observer previously created via `observeNodes`
+   *
+   * @param {!PolymerDomApi.ObserveHandle} observerHandle Observer instance
+   *   to disconnect.
+   * @return {void}
+   * @override
+   */
+  unobserveNodes(observerHandle) {
+    observerHandle.disconnect();
+  }
+  /**
+   * Provided as a backwards-compatible API only.  This method does nothing.
+   * @return {void}
+   */
+  notifyObserver() {
+  }
+  /**
+   * Returns true if the provided node is contained with this element's
+   * light-DOM children or shadow root, including any nested shadow roots
+   * of children therein.
+   *
+   * @param {Node} node Node to test
+   * @return {boolean} Returns true if the given `node` is contained within
+   *   this element's light or shadow DOM.
+   * @override
+   */
+  deepContains(node) {
+    if (wrap(this.node).contains(node)) {
+      return true;
+    }
+    let n = node;
+    let doc = node.ownerDocument;
+    while (n && n !== doc && n !== this.node) {
+      n = wrap(n).parentNode || wrap(n).host;
+    }
+    return n === this.node;
+  }
+  /**
+   * Returns the root node of this node.  Equivalent to `getRootNode()`.
+   *
+   * @return {!Node} Top most element in the dom tree in which the node
+   * exists. If the node is connected to a document this is either a
+   * shadowRoot or the document; otherwise, it may be the node
+   * itself or a node or document fragment containing it.
+   * @override
+   */
+  getOwnerRoot() {
+    return wrap(this.node).getRootNode();
+  }
+  /**
+   * For slot elements, returns the nodes assigned to the slot; otherwise
+   * an empty array. It is equivalent to `<slot>.addignedNodes({flatten:true})`.
+   *
+   * @return {!Array<!Node>} Array of assigned nodes
+   * @override
+   */
+  getDistributedNodes() {
+    return this.node.localName === "slot" ? wrap(this.node).assignedNodes({ flatten: true }) : [];
+  }
+  /**
+   * Returns an array of all slots this element was distributed to.
+   *
+   * @return {!Array<!HTMLSlotElement>} Description
+   * @override
+   */
+  getDestinationInsertionPoints() {
+    let ip$ = [];
+    let n = wrap(this.node).assignedSlot;
+    while (n) {
+      ip$.push(n);
+      n = wrap(n).assignedSlot;
+    }
+    return ip$;
+  }
+  /**
+   * Calls `importNode` on the `ownerDocument` for this node.
+   *
+   * @param {!Node} node Node to import
+   * @param {boolean} deep True if the node should be cloned deeply during
+   *   import
+   * @return {Node} Clone of given node imported to this owner document
+   */
+  importNode(node, deep) {
+    let doc = this.node instanceof Document ? this.node : this.node.ownerDocument;
+    return wrap(doc).importNode(node, deep);
+  }
+  /**
+   * @return {!Array<!Node>} Returns a flattened list of all child nodes and
+   * nodes assigned to child slots.
+   * @override
+   */
+  getEffectiveChildNodes() {
+    return FlattenedNodesObserver.getFlattenedNodes(
+      /** @type {!HTMLElement} */
+      this.node
+    );
+  }
+  /**
+   * Returns a filtered list of flattened child elements for this element based
+   * on the given selector.
+   *
+   * @param {string} selector Selector to filter nodes against
+   * @return {!Array<!HTMLElement>} List of flattened child elements
+   * @override
+   */
+  queryDistributedElements(selector) {
+    let c$ = this.getEffectiveChildNodes();
+    let list = [];
+    for (let i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
+      if (c.nodeType === Node.ELEMENT_NODE && matchesSelector(c, selector)) {
+        list.push(c);
+      }
+    }
+    return list;
+  }
+  /**
+   * For shadow roots, returns the currently focused element within this
+   * shadow root.
+   *
+   * return {Node|undefined} Currently focused element
+   * @override
+   */
+  get activeElement() {
+    let node = this.node;
+    return node._activeElement !== void 0 ? node._activeElement : node.activeElement;
+  }
+};
+function forwardMethods(proto, methods) {
+  for (let i = 0; i < methods.length; i++) {
+    let method = methods[i];
+    proto[method] = /** @this {DomApiNative} */
+    function() {
+      return this.node[method].apply(this.node, arguments);
+    };
+  }
+}
+function forwardReadOnlyProperties(proto, properties) {
+  for (let i = 0; i < properties.length; i++) {
+    let name = properties[i];
+    Object.defineProperty(proto, name, {
+      get: function() {
+        const domApi = (
+          /** @type {DomApiNative} */
+          this
+        );
+        return domApi.node[name];
+      },
+      configurable: true
+    });
+  }
+}
+function forwardProperties(proto, properties) {
+  for (let i = 0; i < properties.length; i++) {
+    let name = properties[i];
+    Object.defineProperty(proto, name, {
+      /**
+       * @this {DomApiNative}
+       * @return {*} .
+       */
+      get: function() {
+        return this.node[name];
+      },
+      /**
+       * @this {DomApiNative}
+       * @param {*} value .
+       */
+      set: function(value) {
+        this.node[name] = value;
+      },
+      configurable: true
+    });
+  }
+}
+var EventApi = class {
+  constructor(event) {
+    this.event = event;
+  }
+  /**
+   * Returns the first node on the `composedPath` of this event.
+   *
+   * @return {!EventTarget} The node this event was dispatched to
+   */
+  get rootTarget() {
+    return this.path[0];
+  }
+  /**
+   * Returns the local (re-targeted) target for this event.
+   *
+   * @return {!EventTarget} The local (re-targeted) target for this event.
+   */
+  get localTarget() {
+    return this.event.target;
+  }
+  /**
+   * Returns the `composedPath` for this event.
+   * @return {!Array<!EventTarget>} The nodes this event propagated through
+   */
+  get path() {
+    return this.event.composedPath();
+  }
+};
+DomApiNative.prototype.cloneNode;
+DomApiNative.prototype.appendChild;
+DomApiNative.prototype.insertBefore;
+DomApiNative.prototype.removeChild;
+DomApiNative.prototype.replaceChild;
+DomApiNative.prototype.setAttribute;
+DomApiNative.prototype.removeAttribute;
+DomApiNative.prototype.querySelector;
+DomApiNative.prototype.querySelectorAll;
+DomApiNative.prototype.parentNode;
+DomApiNative.prototype.firstChild;
+DomApiNative.prototype.lastChild;
+DomApiNative.prototype.nextSibling;
+DomApiNative.prototype.previousSibling;
+DomApiNative.prototype.firstElementChild;
+DomApiNative.prototype.lastElementChild;
+DomApiNative.prototype.nextElementSibling;
+DomApiNative.prototype.previousElementSibling;
+DomApiNative.prototype.childNodes;
+DomApiNative.prototype.children;
+DomApiNative.prototype.classList;
+DomApiNative.prototype.textContent;
+DomApiNative.prototype.innerHTML;
+var DomApiImpl = DomApiNative;
+if (window["ShadyDOM"] && window["ShadyDOM"]["inUse"] && window["ShadyDOM"]["noPatch"] && window["ShadyDOM"]["Wrapper"]) {
+  class Wrapper extends window["ShadyDOM"]["Wrapper"] {
+  }
+  Object.getOwnPropertyNames(DomApiNative.prototype).forEach((prop) => {
+    if (prop != "activeElement") {
+      Wrapper.prototype[prop] = DomApiNative.prototype[prop];
+    }
+  });
+  forwardReadOnlyProperties(Wrapper.prototype, [
+    "classList"
+  ]);
+  DomApiImpl = Wrapper;
+  Object.defineProperties(EventApi.prototype, {
+    // Returns the "lowest" node in the same root as the event's currentTarget.
+    // When in `noPatch` mode, this must be calculated by walking the event's
+    // path.
+    localTarget: {
+      get() {
+        const current = this.event.currentTarget;
+        const currentRoot = current && dom(current).getOwnerRoot();
+        const p$ = this.path;
+        for (let i = 0; i < p$.length; i++) {
+          const e = p$[i];
+          if (dom(e).getOwnerRoot() === currentRoot) {
+            return e;
+          }
+        }
+      },
+      configurable: true
+    },
+    path: {
+      get() {
+        return window["ShadyDOM"]["composedPath"](this.event);
+      },
+      configurable: true
+    }
+  });
+} else {
+  forwardMethods(DomApiNative.prototype, [
+    "cloneNode",
+    "appendChild",
+    "insertBefore",
+    "removeChild",
+    "replaceChild",
+    "setAttribute",
+    "removeAttribute",
+    "querySelector",
+    "querySelectorAll",
+    "attachShadow"
+  ]);
+  forwardReadOnlyProperties(DomApiNative.prototype, [
+    "parentNode",
+    "firstChild",
+    "lastChild",
+    "nextSibling",
+    "previousSibling",
+    "firstElementChild",
+    "lastElementChild",
+    "nextElementSibling",
+    "previousElementSibling",
+    "childNodes",
+    "children",
+    "classList",
+    "shadowRoot"
+  ]);
+  forwardProperties(DomApiNative.prototype, [
+    "textContent",
+    "innerHTML",
+    "className"
+  ]);
+}
+var dom = function(obj) {
+  obj = obj || document;
+  if (obj instanceof DomApiImpl) {
+    return (
+      /** @type {!DomApi} */
+      obj
+    );
+  }
+  if (obj instanceof EventApi) {
+    return (
+      /** @type {!EventApi} */
+      obj
+    );
+  }
+  let helper = obj["__domApi"];
+  if (!helper) {
+    if (obj instanceof Event) {
+      helper = new EventApi(obj);
+    } else {
+      helper = new DomApiImpl(
+        /** @type {Node} */
+        obj
+      );
+    }
+    obj["__domApi"] = helper;
+  }
+  return helper;
+};
+
+// ../../../node_modules/@polymer/polymer/lib/utils/scope-subtree.js
+var ShadyDOM2 = window.ShadyDOM;
+var ShadyCSS = window.ShadyCSS;
+function sameScope(node, scope) {
+  return wrap(node).getRootNode() === scope;
+}
+function scopeSubtree(container, shouldObserve = false) {
+  if (!ShadyDOM2 || !ShadyCSS) {
+    return null;
+  }
+  if (!ShadyDOM2["handlesDynamicScoping"]) {
+    return null;
+  }
+  const ScopingShim = ShadyCSS["ScopingShim"];
+  if (!ScopingShim) {
+    return null;
+  }
+  const containerScope = ScopingShim["scopeForNode"](container);
+  const root = wrap(container).getRootNode();
+  const scopify = (node) => {
+    if (!sameScope(node, root)) {
+      return;
+    }
+    const elements = Array.from(ShadyDOM2["nativeMethods"]["querySelectorAll"].call(node, "*"));
+    elements.push(node);
+    for (let i = 0; i < elements.length; i++) {
+      const el = elements[i];
+      if (!sameScope(el, root)) {
+        continue;
+      }
+      const currentScope = ScopingShim["currentScopeForNode"](el);
+      if (currentScope !== containerScope) {
+        if (currentScope !== "") {
+          ScopingShim["unscopeNode"](el, currentScope);
+        }
+        ScopingShim["scopeNode"](el, containerScope);
+      }
+    }
+  };
+  scopify(container);
+  if (shouldObserve) {
+    const mo = new MutationObserver((mxns) => {
+      for (let i = 0; i < mxns.length; i++) {
+        const mxn = mxns[i];
+        for (let j = 0; j < mxn.addedNodes.length; j++) {
+          const addedNode = mxn.addedNodes[j];
+          if (addedNode.nodeType === Node.ELEMENT_NODE) {
+            scopify(addedNode);
+          }
+        }
+      }
+    });
+    mo.observe(container, { childList: true, subtree: true });
+    return mo;
+  } else {
+    return null;
+  }
+}
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/disable-upgrade-mixin.js
+var DISABLED_ATTR = "disable-upgrade";
+var findObservedAttributesGetter = (ctor) => {
+  while (ctor) {
+    const desc = Object.getOwnPropertyDescriptor(ctor, "observedAttributes");
+    if (desc) {
+      return desc.get;
+    }
+    ctor = Object.getPrototypeOf(ctor.prototype).constructor;
+  }
+  return () => [];
+};
+var DisableUpgradeMixin = dedupingMixin((base) => {
+  const superClass = ElementMixin(base);
+  let observedAttributesGetter = findObservedAttributesGetter(superClass);
+  class DisableUpgradeClass extends superClass {
+    constructor() {
+      super();
+      this.__isUpgradeDisabled;
+    }
+    static get observedAttributes() {
+      return observedAttributesGetter.call(this).concat(DISABLED_ATTR);
+    }
+    // Prevent element from initializing properties when it's upgrade disabled.
+    /** @override */
+    _initializeProperties() {
+      if (this.hasAttribute(DISABLED_ATTR)) {
+        this.__isUpgradeDisabled = true;
+      } else {
+        super._initializeProperties();
+      }
+    }
+    // Prevent element from enabling properties when it's upgrade disabled.
+    // Normally overriding connectedCallback would be enough, but dom-* elements
+    /** @override */
+    _enableProperties() {
+      if (!this.__isUpgradeDisabled) {
+        super._enableProperties();
+      }
+    }
+    // If the element starts upgrade-disabled and a property is set for
+    // which an accessor exists, the default should not be applied.
+    // This additional check is needed because defaults are applied via
+    // `_initializeProperties` which is called after initial properties
+    // have been set when the element starts upgrade-disabled.
+    /** @override */
+    _canApplyPropertyDefault(property) {
+      return super._canApplyPropertyDefault(property) && !(this.__isUpgradeDisabled && this._isPropertyPending(property));
+    }
+    /**
+     * @override
+     * @param {string} name Attribute name.
+     * @param {?string} old The previous value for the attribute.
+     * @param {?string} value The new value for the attribute.
+     * @param {?string} namespace The XML namespace for the attribute.
+     * @return {void}
+     */
+    attributeChangedCallback(name, old, value, namespace) {
+      if (name == DISABLED_ATTR) {
+        if (this.__isUpgradeDisabled && value == null) {
+          super._initializeProperties();
+          this.__isUpgradeDisabled = false;
+          if (wrap(this).isConnected) {
+            super.connectedCallback();
+          }
+        }
+      } else {
+        super.attributeChangedCallback(
+          name,
+          old,
+          value,
+          /** @type {null|string} */
+          namespace
+        );
+      }
+    }
+    // Prevent element from connecting when it's upgrade disabled.
+    // This prevents user code in `attached` from being called.
+    /** @override */
+    connectedCallback() {
+      if (!this.__isUpgradeDisabled) {
+        super.connectedCallback();
+      }
+    }
+    // Prevent element from disconnecting when it's upgrade disabled.
+    // This avoids allowing user code `detached` from being called without a
+    // paired call to `attached`.
+    /** @override */
+    disconnectedCallback() {
+      if (!this.__isUpgradeDisabled) {
+        super.disconnectedCallback();
+      }
+    }
+  }
+  return DisableUpgradeClass;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/legacy/legacy-element-mixin.js
+var DISABLED_ATTR2 = "disable-upgrade";
+var styleInterface = window.ShadyCSS;
+var LegacyElementMixin = dedupingMixin((base) => {
+  const GesturesElement = GestureEventListeners(ElementMixin(base));
+  const legacyElementBase = builtCSS ? GesturesElement : DirMixin(GesturesElement);
+  const observedAttributesGetter = findObservedAttributesGetter(legacyElementBase);
+  const DIRECTION_MAP = {
+    "x": "pan-x",
+    "y": "pan-y",
+    "none": "none",
+    "all": "auto"
+  };
+  class LegacyElement2 extends legacyElementBase {
+    constructor() {
+      super();
+      this.isAttached;
+      this.__boundListeners;
+      this._debouncers;
+      this.__isUpgradeDisabled;
+      this.__needsAttributesAtConnected;
+      this._legacyForceObservedAttributes;
+    }
+    /**
+     * Forwards `importMeta` from the prototype (i.e. from the info object
+     * passed to `Polymer({...})`) to the static API.
+     *
+     * @return {!Object} The `import.meta` object set on the prototype
+     * @suppress {missingProperties} `this` is always in the instance in
+     *  closure for some reason even in a static method, rather than the class
+     * @nocollapse
+     */
+    static get importMeta() {
+      return this.prototype.importMeta;
+    }
+    /**
+     * Legacy callback called during the `constructor`, for overriding
+     * by the user.
+     * @override
+     * @return {void}
+     */
+    created() {
+    }
+    /**
+     * Processes an attribute reaction when the `legacyNoObservedAttributes`
+     * setting is in use.
+     * @param {string} name Name of attribute that changed
+     * @param {?string} old Old attribute value
+     * @param {?string} value New attribute value
+     * @return {void}
+     */
+    __attributeReaction(name, old, value) {
+      if (this.__dataAttributes && this.__dataAttributes[name] || name === DISABLED_ATTR2) {
+        this.attributeChangedCallback(name, old, value, null);
+      }
+    }
+    /**
+     * Sets the value of an attribute.
+     * @override
+     */
+    setAttribute(name, value) {
+      if (legacyNoObservedAttributes && !this._legacyForceObservedAttributes) {
+        const oldValue = this.getAttribute(name);
+        super.setAttribute(name, value);
+        this.__attributeReaction(name, oldValue, String(value));
+      } else {
+        super.setAttribute(name, value);
+      }
+    }
+    /**
+     * Removes an attribute.
+     * @override
+     */
+    removeAttribute(name) {
+      if (legacyNoObservedAttributes && !this._legacyForceObservedAttributes) {
+        const oldValue = this.getAttribute(name);
+        super.removeAttribute(name);
+        this.__attributeReaction(name, oldValue, null);
+      } else {
+        super.removeAttribute(name);
+      }
+    }
+    // NOTE: Inlined for perf from version of DisableUpgradeMixin.
+    static get observedAttributes() {
+      if (legacyNoObservedAttributes && !this.prototype._legacyForceObservedAttributes) {
+        if (!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes", this))) {
+          this.__observedAttributes = [];
+          register(this.prototype);
+        }
+        return this.__observedAttributes;
+      } else {
+        return observedAttributesGetter.call(this).concat(DISABLED_ATTR2);
+      }
+    }
+    // NOTE: Inlined for perf from version of DisableUpgradeMixin.
+    // Prevent element from enabling properties when it's upgrade disabled.
+    // Normally overriding connectedCallback would be enough, but dom-* elements
+    /** @override */
+    _enableProperties() {
+      if (!this.__isUpgradeDisabled) {
+        super._enableProperties();
+      }
+    }
+    // NOTE: Inlined for perf from version of DisableUpgradeMixin.
+    // If the element starts upgrade-disabled and a property is set for
+    // which an accessor exists, the default should not be applied.
+    // This additional check is needed because defaults are applied via
+    // `_initializeProperties` which is called after initial properties
+    // have been set when the element starts upgrade-disabled.
+    /** @override */
+    _canApplyPropertyDefault(property) {
+      return super._canApplyPropertyDefault(property) && !(this.__isUpgradeDisabled && this._isPropertyPending(property));
+    }
+    /**
+     * Provides an implementation of `connectedCallback`
+     * which adds Polymer legacy API's `attached` method.
+     * @return {void}
+     * @override
+     */
+    connectedCallback() {
+      if (this.__needsAttributesAtConnected) {
+        this._takeAttributes();
+      }
+      if (!this.__isUpgradeDisabled) {
+        super.connectedCallback();
+        this.isAttached = true;
+        this.attached();
+      }
+    }
+    /**
+     * Legacy callback called during `connectedCallback`, for overriding
+     * by the user.
+     * @override
+     * @return {void}
+     */
+    attached() {
+    }
+    /**
+     * Provides an implementation of `disconnectedCallback`
+     * which adds Polymer legacy API's `detached` method.
+     * @return {void}
+     * @override
+     */
+    disconnectedCallback() {
+      if (!this.__isUpgradeDisabled) {
+        super.disconnectedCallback();
+        this.isAttached = false;
+        this.detached();
+      }
+    }
+    /**
+     * Legacy callback called during `disconnectedCallback`, for overriding
+     * by the user.
+     * @override
+     * @return {void}
+     */
+    detached() {
+    }
+    /**
+     * Provides an override implementation of `attributeChangedCallback`
+     * which adds the Polymer legacy API's `attributeChanged` method.
+     * @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) {
+        if (name == DISABLED_ATTR2) {
+          if (this.__isUpgradeDisabled && value == null) {
+            this._initializeProperties();
+            this.__isUpgradeDisabled = false;
+            if (wrap(this).isConnected) {
+              this.connectedCallback();
+            }
+          }
+        } else {
+          super.attributeChangedCallback(name, old, value, namespace);
+          this.attributeChanged(name, old, value);
+        }
+      }
+    }
+    /**
+     * Legacy callback called during `attributeChangedChallback`, for overriding
+     * by the user.
+     * @param {string} name Name of attribute.
+     * @param {?string} old Old value of attribute.
+     * @param {?string} value Current value of attribute.
+     * @return {void}
+     * @override
+     */
+    attributeChanged(name, old, value) {
+    }
+    // eslint-disable-line no-unused-vars
+    /**
+     * Overrides the default `Polymer.PropertyEffects` implementation to
+     * add support for class initialization via the `_registered` callback.
+     * This is called only when the first instance of the element is created.
+     *
+     * @return {void}
+     * @override
+     * @suppress {invalidCasts}
+     */
+    _initializeProperties() {
+      if (legacyOptimizations && this.hasAttribute(DISABLED_ATTR2)) {
+        this.__isUpgradeDisabled = true;
+      } else {
+        let proto = Object.getPrototypeOf(this);
+        if (!proto.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished", proto))) {
+          this._registered();
+          proto.__hasRegisterFinished = true;
+        }
+        super._initializeProperties();
+        this.root = /** @type {HTMLElement} */
+        this;
+        this.created();
+        if (legacyNoObservedAttributes && !this._legacyForceObservedAttributes) {
+          if (this.hasAttributes()) {
+            this._takeAttributes();
+          } else if (!this.parentNode) {
+            this.__needsAttributesAtConnected = true;
+          }
+        }
+        this._applyListeners();
+      }
+    }
+    _takeAttributes() {
+      const a = this.attributes;
+      for (let i = 0, l = a.length; i < l; i++) {
+        const attr = a[i];
+        this.__attributeReaction(attr.name, null, attr.value);
+      }
+    }
+    /**
+     * Called automatically when an element is initializing.
+     * Users may override this method to perform class registration time
+     * work. The implementation should ensure the work is performed
+     * only once for the class.
+     * @protected
+     * @return {void}
+     * @override
+     */
+    _registered() {
+    }
+    /**
+     * Overrides the default `Polymer.PropertyEffects` implementation to
+     * add support for installing `hostAttributes` and `listeners`.
+     *
+     * @return {void}
+     * @override
+     */
+    ready() {
+      this._ensureAttributes();
+      super.ready();
+    }
+    /**
+     * Ensures an element has required attributes. Called when the element
+     * is being readied via `ready`. Users should override to set the
+     * element's required attributes. The implementation should be sure
+     * to check and not override existing attributes added by
+     * the user of the element. Typically, setting attributes should be left
+     * to the element user and not done here; reasonable exceptions include
+     * setting aria roles and focusability.
+     * @protected
+     * @return {void}
+     * @override
+     */
+    _ensureAttributes() {
+    }
+    /**
+     * Adds element event listeners. Called when the element
+     * is being readied via `ready`. Users should override to
+     * add any required element event listeners.
+     * In performance critical elements, the work done here should be kept
+     * to a minimum since it is done before the element is rendered. In
+     * these elements, consider adding listeners asynchronously so as not to
+     * block render.
+     * @protected
+     * @return {void}
+     * @override
+     */
+    _applyListeners() {
+    }
+    /**
+     * Converts a typed JavaScript value to a string.
+     *
+     * Note this method is provided as backward-compatible legacy API
+     * only.  It is not directly called by any Polymer features. To customize
+     * how properties are serialized to attributes for attribute bindings and
+     * `reflectToAttribute: true` properties as well as this method, override
+     * the `_serializeValue` method provided by `Polymer.PropertyAccessors`.
+     *
+     * @param {*} value Value to deserialize
+     * @return {string | undefined} Serialized value
+     * @override
+     */
+    serialize(value) {
+      return this._serializeValue(value);
+    }
+    /**
+     * Converts a string to a typed JavaScript value.
+     *
+     * Note this method is provided as backward-compatible legacy API
+     * only.  It is not directly called by any Polymer features.  To customize
+     * how attributes are deserialized to properties for in
+     * `attributeChangedCallback`, override `_deserializeValue` method
+     * provided by `Polymer.PropertyAccessors`.
+     *
+     * @param {string} value String to deserialize
+     * @param {*} type Type to deserialize the string to
+     * @return {*} Returns the deserialized value in the `type` given.
+     * @override
+     */
+    deserialize(value, type) {
+      return this._deserializeValue(value, type);
+    }
+    /**
+     * Serializes a property to its associated attribute.
+     *
+     * Note this method is provided as backward-compatible legacy API
+     * only.  It is not directly called by any Polymer features.
+     *
+     * @param {string} property Property name to reflect.
+     * @param {string=} attribute Attribute name to reflect.
+     * @param {*=} value Property value to reflect.
+     * @return {void}
+     * @override
+     */
+    reflectPropertyToAttribute(property, attribute, value) {
+      this._propertyToAttribute(property, attribute, value);
+    }
+    /**
+     * Sets a typed value to an HTML attribute on a node.
+     *
+     * Note this method is provided as backward-compatible legacy API
+     * only.  It is not directly called by any Polymer features.
+     *
+     * @param {*} value Value to serialize.
+     * @param {string} attribute Attribute name to serialize to.
+     * @param {Element} node Element to set attribute to.
+     * @return {void}
+     * @override
+     */
+    serializeValueToAttribute(value, attribute, node) {
+      this._valueToNodeAttribute(
+        /** @type {Element} */
+        node || this,
+        value,
+        attribute
+      );
+    }
+    /**
+     * Copies own properties (including accessor descriptors) from a source
+     * object to a target object.
+     *
+     * @param {Object} prototype Target object to copy properties to.
+     * @param {Object} api Source object to copy properties from.
+     * @return {Object} prototype object that was passed as first argument.
+     * @override
+     */
+    extend(prototype, api) {
+      if (!(prototype && api)) {
+        return prototype || api;
+      }
+      let n$ = Object.getOwnPropertyNames(api);
+      for (let i = 0, n; i < n$.length && (n = n$[i]); i++) {
+        let pd = Object.getOwnPropertyDescriptor(api, n);
+        if (pd) {
+          Object.defineProperty(prototype, n, pd);
+        }
+      }
+      return prototype;
+    }
+    /**
+     * Copies props from a source object to a target object.
+     *
+     * Note, this method uses a simple `for...in` strategy for enumerating
+     * properties.  To ensure only `ownProperties` are copied from source
+     * to target and that accessor implementations are copied, use `extend`.
+     *
+     * @param {!Object} target Target object to copy properties to.
+     * @param {!Object} source Source object to copy properties from.
+     * @return {!Object} Target object that was passed as first argument.
+     * @override
+     */
+    mixin(target, source) {
+      for (let i in source) {
+        target[i] = source[i];
+      }
+      return target;
+    }
+    /**
+     * Sets the prototype of an object.
+     *
+     * Note this method is provided as backward-compatible legacy API
+     * only.  It is not directly called by any Polymer features.
+     * @param {Object} object The object on which to set the prototype.
+     * @param {Object} prototype The prototype that will be set on the given
+     * `object`.
+     * @return {Object} Returns the given `object` with its prototype set
+     * to the given `prototype` object.
+     * @override
+     */
+    chainObject(object, prototype) {
+      if (object && prototype && object !== prototype) {
+        object.__proto__ = prototype;
+      }
+      return object;
+    }
+    /* **** Begin Template **** */
+    /**
+     * Calls `importNode` on the `content` of the `template` specified and
+     * returns a document fragment containing the imported content.
+     *
+     * @param {HTMLTemplateElement} template HTML template element to instance.
+     * @return {!DocumentFragment} Document fragment containing the imported
+     *   template content.
+     * @override
+     * @suppress {missingProperties} go/missingfnprops
+     */
+    instanceTemplate(template) {
+      let content = this.constructor._contentForTemplate(template);
+      let dom2 = (
+        /** @type {!DocumentFragment} */
+        document.importNode(content, true)
+      );
+      return dom2;
+    }
+    /* **** Begin Events **** */
+    /**
+     * Dispatches a custom event with an optional detail value.
+     *
+     * @param {string} type Name of event type.
+     * @param {*=} detail Detail value containing event-specific
+     *   payload.
+     * @param {{ bubbles: (boolean|undefined), cancelable: (boolean|undefined),
+     *     composed: (boolean|undefined) }=}
+     *  options Object specifying options.  These may include:
+     *  `bubbles` (boolean, defaults to `true`),
+     *  `cancelable` (boolean, defaults to false), and
+     *  `node` on which to fire the event (HTMLElement, defaults to `this`).
+     * @return {!Event} The new event that was fired.
+     * @override
+     */
+    fire(type, detail, options) {
+      options = options || {};
+      detail = detail === null || detail === void 0 ? {} : detail;
+      let event = new Event(type, {
+        bubbles: options.bubbles === void 0 ? true : options.bubbles,
+        cancelable: Boolean(options.cancelable),
+        composed: options.composed === void 0 ? true : options.composed
+      });
+      event.detail = detail;
+      let node = options.node || this;
+      wrap(node).dispatchEvent(event);
+      return event;
+    }
+    /**
+     * Convenience method to add an event listener on a given element,
+     * late bound to a named method on this element.
+     *
+     * @param {?EventTarget} node Element to add event listener to.
+     * @param {string} eventName Name of event to listen for.
+     * @param {string} methodName Name of handler method on `this` to call.
+     * @return {void}
+     * @override
+     */
+    listen(node, eventName, methodName) {
+      node = /** @type {!EventTarget} */
+      node || this;
+      let hbl = this.__boundListeners || (this.__boundListeners = /* @__PURE__ */ new WeakMap());
+      let bl = hbl.get(node);
+      if (!bl) {
+        bl = {};
+        hbl.set(node, bl);
+      }
+      let key = eventName + methodName;
+      if (!bl[key]) {
+        bl[key] = this._addMethodEventListenerToNode(
+          /** @type {!Node} */
+          node,
+          eventName,
+          methodName,
+          this
+        );
+      }
+    }
+    /**
+     * Convenience method to remove an event listener from a given element,
+     * late bound to a named method on this element.
+     *
+     * @param {?EventTarget} node Element to remove event listener from.
+     * @param {string} eventName Name of event to stop listening to.
+     * @param {string} methodName Name of handler method on `this` to not call
+     anymore.
+     * @return {void}
+     * @override
+     */
+    unlisten(node, eventName, methodName) {
+      node = /** @type {!EventTarget} */
+      node || this;
+      let bl = this.__boundListeners && this.__boundListeners.get(
+        /** @type {!Element} */
+        node
+      );
+      let key = eventName + methodName;
+      let handler = bl && bl[key];
+      if (handler) {
+        this._removeEventListenerFromNode(
+          /** @type {!Node} */
+          node,
+          eventName,
+          handler
+        );
+        bl[key] = /** @type {?} */
+        null;
+      }
+    }
+    /**
+     * Override scrolling behavior to all direction, one direction, or none.
+     *
+     * Valid scroll directions:
+     *   - 'all': scroll in any direction
+     *   - 'x': scroll only in the 'x' direction
+     *   - 'y': scroll only in the 'y' direction
+     *   - 'none': disable scrolling for this node
+     *
+     * @param {string=} direction Direction to allow scrolling
+     * Defaults to `all`.
+     * @param {Element=} node Element to apply scroll direction setting.
+     * Defaults to `this`.
+     * @return {void}
+     * @override
+     */
+    setScrollDirection(direction, node) {
+      setTouchAction(
+        /** @type {!Element} */
+        node || this,
+        DIRECTION_MAP[direction] || "auto"
+      );
+    }
+    /* **** End Events **** */
+    /**
+     * Convenience method to run `querySelector` on this local DOM scope.
+     *
+     * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
+     *
+     * @param {string} slctr Selector to run on this local DOM scope
+     * @return {Element} Element found by the selector, or null if not found.
+     * @override
+     */
+    $$(slctr) {
+      return this.root.querySelector(slctr);
+    }
+    /**
+     * Return the element whose local dom within which this element
+     * is contained. This is a shorthand for
+     * `this.getRootNode().host`.
+     * @this {Element}
+     * @return {?Node} The element whose local dom within which this element is
+     * contained.
+     * @override
+     */
+    get domHost() {
+      let root = wrap(this).getRootNode();
+      return root instanceof DocumentFragment ? (
+        /** @type {ShadowRoot} */
+        root.host
+      ) : root;
+    }
+    /**
+     * Force this element to distribute its children to its local dom.
+     * This should not be necessary as of Polymer 2.0.2 and is provided only
+     * for backwards compatibility.
+     * @return {void}
+     * @override
+     */
+    distributeContent() {
+      const thisEl = (
+        /** @type {Element} */
+        this
+      );
+      const domApi = (
+        /** @type {PolymerDomApi} */
+        dom(thisEl)
+      );
+      if (window.ShadyDOM && domApi.shadowRoot) {
+        ShadyDOM.flush();
+      }
+    }
+    /**
+     * Returns a list of nodes that are the effective childNodes. The effective
+     * childNodes list is the same as the element's childNodes except that
+     * any `<content>` elements are replaced with the list of nodes distributed
+     * to the `<content>`, the result of its `getDistributedNodes` method.
+     * @return {!Array<!Node>} List of effective child nodes.
+     * @suppress {invalidCasts} LegacyElementMixin must be applied to an
+     *     HTMLElement
+     * @override
+     */
+    getEffectiveChildNodes() {
+      const thisEl = (
+        /** @type {Element} */
+        this
+      );
+      const domApi = (
+        /** @type {PolymerDomApi} */
+        dom(thisEl)
+      );
+      return domApi.getEffectiveChildNodes();
+    }
+    /**
+     * Returns a list of nodes distributed within this element that match
+     * `selector`. These can be dom children or elements distributed to
+     * children that are insertion points.
+     * @param {string} selector Selector to run.
+     * @return {!Array<!Node>} List of distributed elements that match selector.
+     * @suppress {invalidCasts} LegacyElementMixin must be applied to an
+     * HTMLElement
+     * @override
+     */
+    queryDistributedElements(selector) {
+      const thisEl = (
+        /** @type {Element} */
+        this
+      );
+      const domApi = (
+        /** @type {PolymerDomApi} */
+        dom(thisEl)
+      );
+      return domApi.queryDistributedElements(selector);
+    }
+    /**
+     * Returns a list of elements that are the effective children. The effective
+     * children list is the same as the element's children except that
+     * any `<content>` elements are replaced with the list of elements
+     * distributed to the `<content>`.
+     *
+     * @return {!Array<!Node>} List of effective children.
+     * @override
+     */
+    getEffectiveChildren() {
+      let list = this.getEffectiveChildNodes();
+      return list.filter(function(n) {
+        return n.nodeType === Node.ELEMENT_NODE;
+      });
+    }
+    /**
+     * Returns a string of text content that is the concatenation of the
+     * text content's of the element's effective childNodes (the elements
+     * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
+     *
+     * @return {string} List of effective children.
+     * @override
+     */
+    getEffectiveTextContent() {
+      let cn = this.getEffectiveChildNodes();
+      let tc = [];
+      for (let i = 0, c; c = cn[i]; i++) {
+        if (c.nodeType !== Node.COMMENT_NODE) {
+          tc.push(c.textContent);
+        }
+      }
+      return tc.join("");
+    }
+    /**
+     * Returns the first effective childNode within this element that
+     * match `selector`. These can be dom child nodes or elements distributed
+     * to children that are insertion points.
+     * @param {string} selector Selector to run.
+     * @return {Node} First effective child node that matches selector.
+     * @override
+     */
+    queryEffectiveChildren(selector) {
+      let e$ = this.queryDistributedElements(selector);
+      return e$ && e$[0];
+    }
+    /**
+     * Returns a list of effective childNodes within this element that
+     * match `selector`. These can be dom child nodes or elements distributed
+     * to children that are insertion points.
+     * @param {string} selector Selector to run.
+     * @return {!Array<!Node>} List of effective child nodes that match
+     *     selector.
+     * @override
+     */
+    queryAllEffectiveChildren(selector) {
+      return this.queryDistributedElements(selector);
+    }
+    /**
+     * Returns a list of nodes distributed to this element's `<slot>`.
+     *
+     * If this element contains more than one `<slot>` in its local DOM,
+     * an optional selector may be passed to choose the desired content.
+     *
+     * @param {string=} slctr CSS selector to choose the desired
+     *   `<slot>`.  Defaults to `content`.
+     * @return {!Array<!Node>} List of distributed nodes for the `<slot>`.
+     * @override
+     */
+    getContentChildNodes(slctr) {
+      let content = this.root.querySelector(slctr || "slot");
+      return content ? (
+        /** @type {PolymerDomApi} */
+        dom(content).getDistributedNodes()
+      ) : [];
+    }
+    /**
+     * Returns a list of element children distributed to this element's
+     * `<slot>`.
+     *
+     * If this element contains more than one `<slot>` in its
+     * local DOM, an optional selector may be passed to choose the desired
+     * content.  This method differs from `getContentChildNodes` in that only
+     * elements are returned.
+     *
+     * @param {string=} slctr CSS selector to choose the desired
+     *   `<content>`.  Defaults to `content`.
+     * @return {!Array<!HTMLElement>} List of distributed nodes for the
+     *   `<slot>`.
+     * @suppress {invalidCasts}
+     * @override
+     */
+    getContentChildren(slctr) {
+      let children = (
+        /** @type {!Array<!HTMLElement>} */
+        this.getContentChildNodes(slctr).filter(function(n) {
+          return n.nodeType === Node.ELEMENT_NODE;
+        })
+      );
+      return children;
+    }
+    /**
+     * Checks whether an element is in this element's light DOM tree.
+     *
+     * @param {?Node} node The element to be checked.
+     * @return {boolean} true if node is in this element's light DOM tree.
+     * @suppress {invalidCasts} LegacyElementMixin must be applied to an
+     * HTMLElement
+     * @override
+     */
+    isLightDescendant(node) {
+      const thisNode = (
+        /** @type {Node} */
+        this
+      );
+      return thisNode !== node && wrap(thisNode).contains(node) && wrap(thisNode).getRootNode() === wrap(node).getRootNode();
+    }
+    /**
+     * Checks whether an element is in this element's local DOM tree.
+     *
+     * @param {!Element} node The element to be checked.
+     * @return {boolean} true if node is in this element's local DOM tree.
+     * @override
+     */
+    isLocalDescendant(node) {
+      return this.root === wrap(node).getRootNode();
+    }
+    /**
+     * No-op for backwards compatibility. This should now be handled by
+     * ShadyCss library.
+     * @param  {!Element} container Container element to scope
+     * @param  {boolean=} shouldObserve if true, start a mutation observer for added nodes to the container
+     * @return {?MutationObserver} Returns a new MutationObserver on `container` if `shouldObserve` is true.
+     * @override
+     */
+    scopeSubtree(container, shouldObserve = false) {
+      return scopeSubtree(container, shouldObserve);
+    }
+    /**
+     * Returns the computed style value for the given property.
+     * @param {string} property The css property name.
+     * @return {string} Returns the computed css property value for the given
+     * `property`.
+     * @suppress {invalidCasts} LegacyElementMixin must be applied to an
+     *     HTMLElement
+     * @override
+     */
+    getComputedStyleValue(property) {
+      return styleInterface.getComputedStyleValue(
+        /** @type {!Element} */
+        this,
+        property
+      );
+    }
+    // debounce
+    /**
+     * Call `debounce` to collapse multiple requests for a named task into
+     * one invocation which is made after the wait time has elapsed with
+     * no new request.  If no wait time is given, the callback will be called
+     * at microtask timing (guaranteed before paint).
+     *
+     *     debouncedClickAction(e) {
+     *       // will not call `processClick` more than once per 100ms
+     *       this.debounce('click', function() {
+     *        this.processClick();
+     *       } 100);
+     *     }
+     *
+     * @param {string} jobName String to identify the debounce job.
+     * @param {function():void} callback Function that is called (with `this`
+     *   context) when the wait time elapses.
+     * @param {number=} wait Optional wait time in milliseconds (ms) after the
+     *   last signal that must elapse before invoking `callback`
+     * @return {!Object} Returns a debouncer object on which exists the
+     * following methods: `isActive()` returns true if the debouncer is
+     * active; `cancel()` cancels the debouncer if it is active;
+     * `flush()` immediately invokes the debounced callback if the debouncer
+     * is active.
+     * @override
+     */
+    debounce(jobName, callback, wait) {
+      this._debouncers = this._debouncers || {};
+      return this._debouncers[jobName] = Debouncer.debounce(
+        this._debouncers[jobName],
+        wait > 0 ? timeOut.after(wait) : microTask,
+        callback.bind(this)
+      );
+    }
+    /**
+     * Returns whether a named debouncer is active.
+     *
+     * @param {string} jobName The name of the debouncer started with `debounce`
+     * @return {boolean} Whether the debouncer is active (has not yet fired).
+     * @override
+     */
+    isDebouncerActive(jobName) {
+      this._debouncers = this._debouncers || {};
+      let debouncer = this._debouncers[jobName];
+      return !!(debouncer && debouncer.isActive());
+    }
+    /**
+     * Immediately calls the debouncer `callback` and inactivates it.
+     *
+     * @param {string} jobName The name of the debouncer started with `debounce`
+     * @return {void}
+     * @override
+     */
+    flushDebouncer(jobName) {
+      this._debouncers = this._debouncers || {};
+      let debouncer = this._debouncers[jobName];
+      if (debouncer) {
+        debouncer.flush();
+      }
+    }
+    /**
+     * Cancels an active debouncer.  The `callback` will not be called.
+     *
+     * @param {string} jobName The name of the debouncer started with `debounce`
+     * @return {void}
+     * @override
+     */
+    cancelDebouncer(jobName) {
+      this._debouncers = this._debouncers || {};
+      let debouncer = this._debouncers[jobName];
+      if (debouncer) {
+        debouncer.cancel();
+      }
+    }
+    /**
+     * Runs a callback function asynchronously.
+     *
+     * By default (if no waitTime is specified), async callbacks are run at
+     * microtask timing, which will occur before paint.
+     *
+     * @param {!Function} callback The callback function to run, bound to
+     *     `this`.
+     * @param {number=} waitTime Time to wait before calling the
+     *   `callback`.  If unspecified or 0, the callback will be run at microtask
+     *   timing (before paint).
+     * @return {number} Handle that may be used to cancel the async job.
+     * @override
+     */
+    async(callback, waitTime) {
+      return waitTime > 0 ? timeOut.run(callback.bind(this), waitTime) : ~microTask.run(callback.bind(this));
+    }
+    /**
+     * Cancels an async operation started with `async`.
+     *
+     * @param {number} handle Handle returned from original `async` call to
+     *   cancel.
+     * @return {void}
+     * @override
+     */
+    cancelAsync(handle) {
+      handle < 0 ? microTask.cancel(~handle) : timeOut.cancel(handle);
+    }
+    // other
+    /**
+     * Convenience method for creating an element and configuring it.
+     *
+     * @param {string} tag HTML element tag to create.
+     * @param {Object=} props Object of properties to configure on the
+     *    instance.
+     * @return {!Element} Newly created and configured element.
+     * @override
+     */
+    create(tag, props) {
+      let elt = document.createElement(tag);
+      if (props) {
+        if (elt.setProperties) {
+          elt.setProperties(props);
+        } else {
+          for (let n in props) {
+            elt[n] = props[n];
+          }
+        }
+      }
+      return elt;
+    }
+    /**
+     * Polyfill for Element.prototype.matches, which is sometimes still
+     * prefixed.
+     *
+     * @param {string} selector Selector to test.
+     * @param {!Element=} node Element to test the selector against.
+     * @return {boolean} Whether the element matches the selector.
+     * @override
+     */
+    elementMatches(selector, node) {
+      return matchesSelector(node || this, selector);
+    }
+    /**
+     * Toggles an HTML attribute on or off.
+     *
+     * @param {string} name HTML attribute name
+     * @param {boolean=} bool Boolean to force the attribute on or off.
+     *    When unspecified, the state of the attribute will be reversed.
+     * @return {boolean} true if the attribute now exists
+     * @override
+     */
+    toggleAttribute(name, bool) {
+      let node = (
+        /** @type {Element} */
+        this
+      );
+      if (arguments.length === 3) {
+        node = /** @type {Element} */
+        arguments[2];
+      }
+      if (arguments.length == 1) {
+        bool = !node.hasAttribute(name);
+      }
+      if (bool) {
+        wrap(node).setAttribute(name, "");
+        return true;
+      } else {
+        wrap(node).removeAttribute(name);
+        return false;
+      }
+    }
+    /**
+     * Toggles a CSS class on or off.
+     *
+     * @param {string} name CSS class name
+     * @param {boolean=} bool Boolean to force the class on or off.
+     *    When unspecified, the state of the class will be reversed.
+     * @param {Element=} node Node to target.  Defaults to `this`.
+     * @return {void}
+     * @override
+     */
+    toggleClass(name, bool, node) {
+      node = /** @type {Element} */
+      node || this;
+      if (arguments.length == 1) {
+        bool = !node.classList.contains(name);
+      }
+      if (bool) {
+        node.classList.add(name);
+      } else {
+        node.classList.remove(name);
+      }
+    }
+    /**
+     * Cross-platform helper for setting an element's CSS `transform` property.
+     *
+     * @param {string} transformText Transform setting.
+     * @param {Element=} node Element to apply the transform to.
+     * Defaults to `this`
+     * @return {void}
+     * @override
+     */
+    transform(transformText, node) {
+      node = /** @type {Element} */
+      node || this;
+      node.style.webkitTransform = transformText;
+      node.style.transform = transformText;
+    }
+    /**
+     * Cross-platform helper for setting an element's CSS `translate3d`
+     * property.
+     *
+     * @param {number|string} x X offset.
+     * @param {number|string} y Y offset.
+     * @param {number|string} z Z offset.
+     * @param {Element=} node Element to apply the transform to.
+     * Defaults to `this`.
+     * @return {void}
+     * @override
+     */
+    translate3d(x, y, z, node) {
+      node = /** @type {Element} */
+      node || this;
+      this.transform("translate3d(" + x + "," + y + "," + z + ")", node);
+    }
+    /**
+     * Removes an item from an array, if it exists.
+     *
+     * If the array is specified by path, a change notification is
+     * generated, so that observers, data bindings and computed
+     * properties watching that path can update.
+     *
+     * If the array is passed directly, **no change
+     * notification is generated**.
+     *
+     * @param {string | !Array<number|string>} arrayOrPath Path to array from
+     *     which to remove the item
+     *   (or the array itself).
+     * @param {*} item Item to remove.
+     * @return {Array} Array containing item removed.
+     * @override
+     */
+    arrayDelete(arrayOrPath, item) {
+      let index;
+      if (Array.isArray(arrayOrPath)) {
+        index = arrayOrPath.indexOf(item);
+        if (index >= 0) {
+          return arrayOrPath.splice(index, 1);
+        }
+      } else {
+        let arr = get(this, arrayOrPath);
+        index = arr.indexOf(item);
+        if (index >= 0) {
+          return this.splice(arrayOrPath, index, 1);
+        }
+      }
+      return null;
+    }
+    // logging
+    /**
+     * Facades `console.log`/`warn`/`error` as override point.
+     *
+     * @param {string} level One of 'log', 'warn', 'error'
+     * @param {Array} args Array of strings or objects to log
+     * @return {void}
+     * @override
+     */
+    _logger(level, args) {
+      if (Array.isArray(args) && args.length === 1 && Array.isArray(args[0])) {
+        args = args[0];
+      }
+      switch (level) {
+        case "log":
+        case "warn":
+        case "error":
+          console[level](...args);
+      }
+    }
+    /**
+     * Facades `console.log` as an override point.
+     *
+     * @param {...*} args Array of strings or objects to log
+     * @return {void}
+     * @override
+     */
+    _log(...args) {
+      this._logger("log", args);
+    }
+    /**
+     * Facades `console.warn` as an override point.
+     *
+     * @param {...*} args Array of strings or objects to log
+     * @return {void}
+     * @override
+     */
+    _warn(...args) {
+      this._logger("warn", args);
+    }
+    /**
+     * Facades `console.error` as an override point.
+     *
+     * @param {...*} args Array of strings or objects to log
+     * @return {void}
+     * @override
+     */
+    _error(...args) {
+      this._logger("error", args);
+    }
+    /**
+     * Formats a message using the element type an a method name.
+     *
+     * @param {string} methodName Method name to associate with message
+     * @param {...*} args Array of strings or objects to log
+     * @return {!Array} Array with formatting information for `console`
+     *   logging.
+     * @override
+     */
+    _logf(methodName, ...args) {
+      return ["[%s::%s]", this.is, methodName, ...args];
+    }
+  }
+  LegacyElement2.prototype.is = "";
+  return LegacyElement2;
+});
+
+// ../../../node_modules/@polymer/polymer/lib/legacy/class.js
+var lifecycleProps = {
+  attached: true,
+  detached: true,
+  ready: true,
+  created: true,
+  beforeRegister: true,
+  registered: true,
+  attributeChanged: true,
+  listeners: true,
+  hostAttributes: true
+};
+var excludeOnInfo = {
+  attached: true,
+  detached: true,
+  ready: true,
+  created: true,
+  beforeRegister: true,
+  registered: true,
+  attributeChanged: true,
+  behaviors: true,
+  _noAccessors: true
+};
+var excludeOnBehaviors = Object.assign({
+  listeners: true,
+  hostAttributes: true,
+  properties: true,
+  observers: true
+}, excludeOnInfo);
+function copyProperties(source, target, excludeProps) {
+  const noAccessors = source._noAccessors;
+  const propertyNames = Object.getOwnPropertyNames(source);
+  for (let i = 0; i < propertyNames.length; i++) {
+    let p2 = propertyNames[i];
+    if (p2 in excludeProps) {
+      continue;
+    }
+    if (noAccessors) {
+      target[p2] = source[p2];
+    } else {
+      let pd = Object.getOwnPropertyDescriptor(source, p2);
+      if (pd) {
+        pd.configurable = true;
+        Object.defineProperty(target, p2, pd);
+      }
+    }
+  }
+}
+function mixinBehaviors(behaviors, klass) {
+  return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
+}
+function applyBehaviors(proto, behaviors, lifecycle) {
+  for (let i = 0; i < behaviors.length; i++) {
+    applyInfo(proto, behaviors[i], lifecycle, excludeOnBehaviors);
+  }
+}
+function applyInfo(proto, info, lifecycle, excludeProps) {
+  copyProperties(info, proto, excludeProps);
+  for (let p2 in lifecycleProps) {
+    if (info[p2]) {
+      lifecycle[p2] = lifecycle[p2] || [];
+      lifecycle[p2].push(info[p2]);
+    }
+  }
+}
+function flattenBehaviors(behaviors, list, exclude) {
+  list = list || [];
+  for (let i = behaviors.length - 1; i >= 0; i--) {
+    let b = behaviors[i];
+    if (b) {
+      if (Array.isArray(b)) {
+        flattenBehaviors(b, list);
+      } else {
+        if (list.indexOf(b) < 0 && (!exclude || exclude.indexOf(b) < 0)) {
+          list.unshift(b);
+        }
+      }
+    } else {
+      console.warn("behavior is null, check for missing or 404 import");
+    }
+  }
+  return list;
+}
+function mergeProperties(target, source) {
+  for (const p2 in source) {
+    const targetInfo = target[p2];
+    const sourceInfo = source[p2];
+    if (!("value" in sourceInfo) && targetInfo && "value" in targetInfo) {
+      target[p2] = Object.assign({ value: targetInfo.value }, sourceInfo);
+    } else {
+      target[p2] = sourceInfo;
+    }
+  }
+}
+var LegacyElement = LegacyElementMixin(HTMLElement);
+function GenerateClassFromInfo(info, Base, behaviors) {
+  let behaviorList;
+  const lifecycle = {};
+  class PolymerGenerated extends Base {
+    // explicitly not calling super._finalizeClass
+    /** @nocollapse */
+    static _finalizeClass() {
+      if (!this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom", this))) {
+        Base._finalizeClass.call(this);
+      } else {
+        if (behaviorList) {
+          for (let i = 0, b; i < behaviorList.length; i++) {
+            b = behaviorList[i];
+            if (b.properties) {
+              this.createProperties(b.properties);
+            }
+            if (b.observers) {
+              this.createObservers(b.observers, b.properties);
+            }
+          }
+        }
+        if (info.properties) {
+          this.createProperties(info.properties);
+        }
+        if (info.observers) {
+          this.createObservers(info.observers, info.properties);
+        }
+        this._prepareTemplate();
+      }
+    }
+    /** @nocollapse */
+    static get properties() {
+      const properties = {};
+      if (behaviorList) {
+        for (let i = 0; i < behaviorList.length; i++) {
+          mergeProperties(properties, behaviorList[i].properties);
+        }
+      }
+      mergeProperties(properties, info.properties);
+      return properties;
+    }
+    /** @nocollapse */
+    static get observers() {
+      let observers = [];
+      if (behaviorList) {
+        for (let i = 0, b; i < behaviorList.length; i++) {
+          b = behaviorList[i];
+          if (b.observers) {
+            observers = observers.concat(b.observers);
+          }
+        }
+      }
+      if (info.observers) {
+        observers = observers.concat(info.observers);
+      }
+      return observers;
+    }
+    /**
+     * @return {void}
+     */
+    created() {
+      super.created();
+      const list = lifecycle.created;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          list[i].call(this);
+        }
+      }
+    }
+    /**
+     * @return {void}
+     */
+    _registered() {
+      const generatedProto = PolymerGenerated.prototype;
+      if (!generatedProto.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished", generatedProto))) {
+        generatedProto.__hasRegisterFinished = true;
+        super._registered();
+        if (legacyOptimizations) {
+          copyPropertiesToProto(generatedProto);
+        }
+        const proto = Object.getPrototypeOf(this);
+        let list = lifecycle.beforeRegister;
+        if (list) {
+          for (let i = 0; i < list.length; i++) {
+            list[i].call(proto);
+          }
+        }
+        list = lifecycle.registered;
+        if (list) {
+          for (let i = 0; i < list.length; i++) {
+            list[i].call(proto);
+          }
+        }
+      }
+    }
+    /**
+     * @return {void}
+     */
+    _applyListeners() {
+      super._applyListeners();
+      const list = lifecycle.listeners;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          const listeners = list[i];
+          if (listeners) {
+            for (let l in listeners) {
+              this._addMethodEventListenerToNode(this, l, listeners[l]);
+            }
+          }
+        }
+      }
+    }
+    // note: exception to "super then me" rule;
+    // do work before calling super so that super attributes
+    // only apply if not already set.
+    /**
+     * @return {void}
+     */
+    _ensureAttributes() {
+      const list = lifecycle.hostAttributes;
+      if (list) {
+        for (let i = list.length - 1; i >= 0; i--) {
+          const hostAttributes = list[i];
+          for (let a in hostAttributes) {
+            this._ensureAttribute(a, hostAttributes[a]);
+          }
+        }
+      }
+      super._ensureAttributes();
+    }
+    /**
+     * @return {void}
+     */
+    ready() {
+      super.ready();
+      let list = lifecycle.ready;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          list[i].call(this);
+        }
+      }
+    }
+    /**
+     * @return {void}
+     */
+    attached() {
+      super.attached();
+      let list = lifecycle.attached;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          list[i].call(this);
+        }
+      }
+    }
+    /**
+     * @return {void}
+     */
+    detached() {
+      super.detached();
+      let list = lifecycle.detached;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          list[i].call(this);
+        }
+      }
+    }
+    /**
+     * 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
+     * @return {void}
+     */
+    attributeChanged(name, old, value) {
+      super.attributeChanged();
+      let list = lifecycle.attributeChanged;
+      if (list) {
+        for (let i = 0; i < list.length; i++) {
+          list[i].call(this, name, old, value);
+        }
+      }
+    }
+  }
+  if (behaviors) {
+    if (!Array.isArray(behaviors)) {
+      behaviors = [behaviors];
+    }
+    let superBehaviors = Base.prototype.behaviors;
+    behaviorList = flattenBehaviors(behaviors, null, superBehaviors);
+    PolymerGenerated.prototype.behaviors = superBehaviors ? superBehaviors.concat(behaviors) : behaviorList;
+  }
+  const copyPropertiesToProto = (proto) => {
+    if (behaviorList) {
+      applyBehaviors(proto, behaviorList, lifecycle);
+    }
+    applyInfo(proto, info, lifecycle, excludeOnInfo);
+  };
+  if (!legacyOptimizations) {
+    copyPropertiesToProto(PolymerGenerated.prototype);
+  }
+  PolymerGenerated.generatedFrom = info;
+  return PolymerGenerated;
+}
+var Class = function(info, mixin) {
+  if (!info) {
+    console.warn("Polymer.Class requires `info` argument");
+  }
+  let klass = mixin ? mixin(LegacyElement) : LegacyElement;
+  klass = GenerateClassFromInfo(info, klass, info.behaviors);
+  klass.is = klass.prototype.is = info.is;
+  return klass;
+};
+
+export {
+  nativeShadow,
+  cssBuild,
+  disableRuntime,
+  nativeCssVariables,
+  updateNativeProperties,
+  getComputedStyleValue,
+  CustomStyleInterface,
+  Debouncer,
+  enqueueDebouncer,
+  GestureEventListeners,
+  calculateSplices,
+  flush,
+  dom,
+  LegacyElementMixin,
+  mixinBehaviors,
+  Class
+};
+//# sourceMappingURL=chunk-BHAOVVTR.js.map