@avs/go-react 0.12.71731 → 0.13.71740

package/demo/node_modules/.vite/deps/@polymer_iron-resizable-behavior_iron-resizable-behavior__js.js

@@ -0,0 +1,2321 @@
+import {
+  PolymerElement
+} from "./chunk-BSA4YZO6.js";
+import {
+  Class,
+  CustomStyleInterface,
+  Debouncer,
+  GestureEventListeners,
+  LegacyElementMixin,
+  calculateSplices,
+  cssBuild,
+  disableRuntime,
+  dom,
+  enqueueDebouncer,
+  flush,
+  getComputedStyleValue,
+  nativeCssVariables,
+  nativeShadow,
+  updateNativeProperties
+} from "./chunk-BHAOVVTR.js";
+import "./chunk-QQPVW2K2.js";
+import {
+  ElementMixin,
+  PropertyEffects,
+  cssFromModules,
+  fastDomIf,
+  legacyOptimizations,
+  legacyWarnings,
+  matches,
+  microTask,
+  root,
+  strictTemplatePolicy,
+  suppressTemplateNotifications,
+  timeOut,
+  translate,
+  useShadow,
+  wrap
+} from "./chunk-PRUGAEYJ.js";
+import {
+  dedupingMixin
+} from "./chunk-I2HDYNON.js";
+import "./chunk-MXBCLPIN.js";
+import "./chunk-BUSYA2B4.js";
+
+// ../../../node_modules/@polymer/polymer/lib/legacy/polymer-fn.js
+var Polymer = function(info) {
+  let klass;
+  if (typeof info === "function") {
+    klass = info;
+  } else {
+    klass = Polymer.Class(info);
+  }
+  if (info._legacyForceObservedAttributes) {
+    klass.prototype._legacyForceObservedAttributes = info._legacyForceObservedAttributes;
+  }
+  customElements.define(
+    klass.is,
+    /** @type {!HTMLElement} */
+    klass
+  );
+  return klass;
+};
+Polymer.Class = Class;
+
+// ../../../node_modules/@polymer/polymer/lib/mixins/mutable-data.js
+function mutablePropertyChange(inst, property, value, old, mutableData) {
+  let isObject;
+  if (mutableData) {
+    isObject = typeof value === "object" && value !== null;
+    if (isObject) {
+      old = inst.__dataTemp[property];
+    }
+  }
+  let shouldChange = old !== value && (old === old || value === value);
+  if (isObject && shouldChange) {
+    inst.__dataTemp[property] = value;
+  }
+  return shouldChange;
+}
+var MutableData = dedupingMixin((superClass) => {
+  class MutableData2 extends superClass {
+    /**
+     * Overrides `PropertyEffects` to provide option for skipping
+     * strict equality checking for Objects and Arrays.
+     *
+     * This method pulls the value to dirty check against from the `__dataTemp`
+     * cache (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param {string} property Property name
+     * @param {*} value New property value
+     * @param {*} old Previous property value
+     * @return {boolean} Whether the property should be considered a change
+     * @protected
+     */
+    _shouldPropertyChange(property, value, old) {
+      return mutablePropertyChange(this, property, value, old, true);
+    }
+  }
+  return MutableData2;
+});
+var OptionalMutableData = dedupingMixin((superClass) => {
+  class OptionalMutableData2 extends superClass {
+    /** @nocollapse */
+    static get properties() {
+      return {
+        /**
+         * Instance-level flag for configuring the dirty-checking strategy
+         * for this element.  When true, Objects and Arrays will skip dirty
+         * checking, otherwise strict equality checking will be used.
+         */
+        mutableData: Boolean
+      };
+    }
+    /**
+     * Overrides `PropertyEffects` to provide option for skipping
+     * strict equality checking for Objects and Arrays.
+     *
+     * When `this.mutableData` is true on this instance, this method
+     * pulls the value to dirty check against from the `__dataTemp` cache
+     * (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param {string} property Property name
+     * @param {*} value New property value
+     * @param {*} old Previous property value
+     * @return {boolean} Whether the property should be considered a change
+     * @protected
+     */
+    _shouldPropertyChange(property, value, old) {
+      return mutablePropertyChange(this, property, value, old, this.mutableData);
+    }
+  }
+  return OptionalMutableData2;
+});
+MutableData._mutablePropertyChange = mutablePropertyChange;
+
+// ../../../node_modules/@polymer/polymer/lib/utils/templatize.js
+var newInstance = null;
+function HTMLTemplateElementExtension() {
+  return newInstance;
+}
+HTMLTemplateElementExtension.prototype = Object.create(HTMLTemplateElement.prototype, {
+  constructor: {
+    value: HTMLTemplateElementExtension,
+    writable: true
+  }
+});
+var DataTemplate = PropertyEffects(HTMLTemplateElementExtension);
+var MutableDataTemplate = MutableData(DataTemplate);
+function upgradeTemplate(template, constructor) {
+  newInstance = template;
+  Object.setPrototypeOf(template, constructor.prototype);
+  new constructor();
+  newInstance = null;
+}
+var templateInstanceBase = PropertyEffects(class {
+});
+function showHideChildren(hide, children) {
+  for (let i = 0; i < children.length; i++) {
+    let n = children[i];
+    if (Boolean(hide) != Boolean(n.__hideTemplateChildren__)) {
+      if (n.nodeType === Node.TEXT_NODE) {
+        if (hide) {
+          n.__polymerTextContent__ = n.textContent;
+          n.textContent = "";
+        } else {
+          n.textContent = n.__polymerTextContent__;
+        }
+      } else if (n.localName === "slot") {
+        if (hide) {
+          n.__polymerReplaced__ = document.createComment("hidden-slot");
+          wrap(wrap(n).parentNode).replaceChild(n.__polymerReplaced__, n);
+        } else {
+          const replace = n.__polymerReplaced__;
+          if (replace) {
+            wrap(wrap(replace).parentNode).replaceChild(n, replace);
+          }
+        }
+      } else if (n.style) {
+        if (hide) {
+          n.__polymerDisplay__ = n.style.display;
+          n.style.display = "none";
+        } else {
+          n.style.display = n.__polymerDisplay__;
+        }
+      }
+    }
+    n.__hideTemplateChildren__ = hide;
+    if (n._showHideChildren) {
+      n._showHideChildren(hide);
+    }
+  }
+}
+var TemplateInstanceBase = class extends templateInstanceBase {
+  constructor(props) {
+    super();
+    this._configureProperties(props);
+    this.root = this._stampTemplate(this.__dataHost);
+    let children = [];
+    this.children = /** @type {!NodeList} */
+    children;
+    for (let n = this.root.firstChild; n; n = n.nextSibling) {
+      children.push(n);
+      n.__templatizeInstance = this;
+    }
+    if (this.__templatizeOwner && this.__templatizeOwner.__hideTemplateChildren__) {
+      this._showHideChildren(true);
+    }
+    let options = this.__templatizeOptions;
+    if (props && options.instanceProps || !options.instanceProps) {
+      this._enableProperties();
+    }
+  }
+  /**
+   * Configure the given `props` by calling `_setPendingProperty`. Also
+   * sets any properties stored in `__hostProps`.
+   * @private
+   * @param {Object} props Object of property name-value pairs to set.
+   * @return {void}
+   */
+  _configureProperties(props) {
+    let options = this.__templatizeOptions;
+    if (options.forwardHostProp) {
+      for (let hprop in this.__hostProps) {
+        this._setPendingProperty(hprop, this.__dataHost["_host_" + hprop]);
+      }
+    }
+    for (let iprop in props) {
+      this._setPendingProperty(iprop, props[iprop]);
+    }
+  }
+  /**
+   * Forwards a host property to this instance.  This method should be
+   * called on instances from the `options.forwardHostProp` callback
+   * to propagate changes of host properties to each instance.
+   *
+   * Note this method enqueues the change, which are flushed as a batch.
+   *
+   * @param {string} prop Property or path name
+   * @param {*} value Value of the property to forward
+   * @return {void}
+   */
+  forwardHostProp(prop, value) {
+    if (this._setPendingPropertyOrPath(prop, value, false, true)) {
+      this.__dataHost._enqueueClient(this);
+    }
+  }
+  /**
+   * Override point for adding custom or simulated event handling.
+   *
+   * @override
+   * @param {!Node} node Node to add event listener to
+   * @param {string} eventName Name of event
+   * @param {function(!Event):void} handler Listener function to add
+   * @return {void}
+   */
+  _addEventListenerToNode(node, eventName, handler) {
+    if (this._methodHost && this.__templatizeOptions.parentModel) {
+      this._methodHost._addEventListenerToNode(node, eventName, (e) => {
+        e.model = this;
+        handler(e);
+      });
+    } else {
+      let templateHost = this.__dataHost.__dataHost;
+      if (templateHost) {
+        templateHost._addEventListenerToNode(node, eventName, handler);
+      }
+    }
+  }
+  /**
+   * Shows or hides the template instance top level child elements. For
+   * text nodes, `textContent` is removed while "hidden" and replaced when
+   * "shown."
+   * @param {boolean} hide Set to true to hide the children;
+   * set to false to show them.
+   * @return {void}
+   * @protected
+   */
+  _showHideChildren(hide) {
+    showHideChildren(hide, this.children);
+  }
+  /**
+   * Overrides default property-effects implementation to intercept
+   * textContent bindings while children are "hidden" and cache in
+   * private storage for later retrieval.
+   *
+   * @override
+   * @param {!Node} node The node to set a property on
+   * @param {string} prop The property to set
+   * @param {*} value The value to set
+   * @return {void}
+   * @protected
+   */
+  _setUnmanagedPropertyToNode(node, prop, value) {
+    if (node.__hideTemplateChildren__ && node.nodeType == Node.TEXT_NODE && prop == "textContent") {
+      node.__polymerTextContent__ = value;
+    } else {
+      super._setUnmanagedPropertyToNode(node, prop, value);
+    }
+  }
+  /**
+   * Find the parent model of this template instance.  The parent model
+   * is either another templatize instance that had option `parentModel: true`,
+   * or else the host element.
+   *
+   * @return {!Polymer_PropertyEffects} The parent model of this instance
+   */
+  get parentModel() {
+    let model = this.__parentModel;
+    if (!model) {
+      let options;
+      model = this;
+      do {
+        model = model.__dataHost.__dataHost;
+      } while ((options = model.__templatizeOptions) && !options.parentModel);
+      this.__parentModel = model;
+    }
+    return model;
+  }
+  /**
+   * Stub of HTMLElement's `dispatchEvent`, so that effects that may
+   * dispatch events safely no-op.
+   *
+   * @param {Event} event Event to dispatch
+   * @return {boolean} Always true.
+   * @override
+   */
+  dispatchEvent(event) {
+    return true;
+  }
+};
+TemplateInstanceBase.prototype.__dataHost;
+TemplateInstanceBase.prototype.__templatizeOptions;
+TemplateInstanceBase.prototype._methodHost;
+TemplateInstanceBase.prototype.__templatizeOwner;
+TemplateInstanceBase.prototype.__hostProps;
+var MutableTemplateInstanceBase = MutableData(
+  // This cast shouldn't be neccessary, but Closure doesn't understand that
+  // TemplateInstanceBase is a constructor function.
+  /** @type {function(new:TemplateInstanceBase)} */
+  TemplateInstanceBase
+);
+function findMethodHost(template) {
+  let templateHost = template.__dataHost;
+  return templateHost && templateHost._methodHost || templateHost;
+}
+function createTemplatizerClass(template, templateInfo, options) {
+  let templatizerBase = options.mutableData ? MutableTemplateInstanceBase : TemplateInstanceBase;
+  if (templatize.mixin) {
+    templatizerBase = templatize.mixin(templatizerBase);
+  }
+  let klass = class extends templatizerBase {
+  };
+  klass.prototype.__templatizeOptions = options;
+  klass.prototype._bindTemplate(template);
+  addNotifyEffects(klass, template, templateInfo, options);
+  return klass;
+}
+function addPropagateEffects(target, templateInfo, options, methodHost) {
+  let userForwardHostProp = options.forwardHostProp;
+  if (userForwardHostProp && templateInfo.hasHostProps) {
+    const isTemplate = target.localName == "template";
+    let klass = templateInfo.templatizeTemplateClass;
+    if (!klass) {
+      if (isTemplate) {
+        let templatizedBase = options.mutableData ? MutableDataTemplate : DataTemplate;
+        class TemplatizedTemplate extends templatizedBase {
+        }
+        klass = templateInfo.templatizeTemplateClass = TemplatizedTemplate;
+      } else {
+        const templatizedBase = target.constructor;
+        class TemplatizedTemplateExtension extends templatizedBase {
+        }
+        klass = templateInfo.templatizeTemplateClass = TemplatizedTemplateExtension;
+      }
+      let hostProps = templateInfo.hostProps;
+      for (let prop in hostProps) {
+        klass.prototype._addPropertyEffect(
+          "_host_" + prop,
+          klass.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,
+          { fn: createForwardHostPropEffect(prop, userForwardHostProp) }
+        );
+        klass.prototype._createNotifyingProperty("_host_" + prop);
+      }
+      if (legacyWarnings && methodHost) {
+        warnOnUndeclaredProperties(templateInfo, options, methodHost);
+      }
+    }
+    if (target.__dataProto) {
+      Object.assign(target.__data, target.__dataProto);
+    }
+    if (isTemplate) {
+      upgradeTemplate(target, klass);
+      target.__dataTemp = {};
+      target.__dataPending = null;
+      target.__dataOld = null;
+      target._enableProperties();
+    } else {
+      Object.setPrototypeOf(target, klass.prototype);
+      const hostProps = templateInfo.hostProps;
+      for (let prop in hostProps) {
+        prop = "_host_" + prop;
+        if (prop in target) {
+          const val = target[prop];
+          delete target[prop];
+          target.__data[prop] = val;
+        }
+      }
+    }
+  }
+}
+function createForwardHostPropEffect(hostProp, userForwardHostProp) {
+  return function forwardHostProp(template, prop, props) {
+    userForwardHostProp.call(
+      template.__templatizeOwner,
+      prop.substring("_host_".length),
+      props[prop]
+    );
+  };
+}
+function addNotifyEffects(klass, template, templateInfo, options) {
+  let hostProps = templateInfo.hostProps || {};
+  for (let iprop in options.instanceProps) {
+    delete hostProps[iprop];
+    let userNotifyInstanceProp = options.notifyInstanceProp;
+    if (userNotifyInstanceProp) {
+      klass.prototype._addPropertyEffect(
+        iprop,
+        klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
+        { fn: createNotifyInstancePropEffect(iprop, userNotifyInstanceProp) }
+      );
+    }
+  }
+  if (options.forwardHostProp && template.__dataHost) {
+    for (let hprop in hostProps) {
+      if (!templateInfo.hasHostProps) {
+        templateInfo.hasHostProps = true;
+      }
+      klass.prototype._addPropertyEffect(
+        hprop,
+        klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
+        { fn: createNotifyHostPropEffect() }
+      );
+    }
+  }
+}
+function createNotifyInstancePropEffect(instProp, userNotifyInstanceProp) {
+  return function notifyInstanceProp(inst, prop, props) {
+    userNotifyInstanceProp.call(
+      inst.__templatizeOwner,
+      inst,
+      prop,
+      props[prop]
+    );
+  };
+}
+function createNotifyHostPropEffect() {
+  return function notifyHostProp(inst, prop, props) {
+    inst.__dataHost._setPendingPropertyOrPath("_host_" + prop, props[prop], true, true);
+  };
+}
+function templatize(template, owner, options) {
+  if (strictTemplatePolicy && !findMethodHost(template)) {
+    throw new Error("strictTemplatePolicy: template owner not trusted");
+  }
+  options = /** @type {!TemplatizeOptions} */
+  options || {};
+  if (template.__templatizeOwner) {
+    throw new Error("A <template> can only be templatized once");
+  }
+  template.__templatizeOwner = owner;
+  const ctor = owner ? owner.constructor : TemplateInstanceBase;
+  let templateInfo = ctor._parseTemplate(template);
+  let baseClass = templateInfo.templatizeInstanceClass;
+  if (!baseClass) {
+    baseClass = createTemplatizerClass(template, templateInfo, options);
+    templateInfo.templatizeInstanceClass = baseClass;
+  }
+  const methodHost = findMethodHost(template);
+  addPropagateEffects(template, templateInfo, options, methodHost);
+  let klass = class TemplateInstance extends baseClass {
+  };
+  klass.prototype._methodHost = methodHost;
+  klass.prototype.__dataHost = /** @type {!DataTemplate} */
+  template;
+  klass.prototype.__templatizeOwner = /** @type {!Object} */
+  owner;
+  klass.prototype.__hostProps = templateInfo.hostProps;
+  klass = /** @type {function(new:TemplateInstanceBase)} */
+  klass;
+  return klass;
+}
+function warnOnUndeclaredProperties(templateInfo, options, methodHost) {
+  const declaredProps = methodHost.constructor._properties;
+  const { propertyEffects } = templateInfo;
+  const { instanceProps } = options;
+  for (let prop in propertyEffects) {
+    if (!declaredProps[prop] && !(instanceProps && instanceProps[prop])) {
+      const effects = propertyEffects[prop];
+      for (let i = 0; i < effects.length; i++) {
+        const { part } = effects[i].info;
+        if (!(part.signature && part.signature.static)) {
+          console.warn(`Property '${prop}' used in template but not declared in 'properties'; attribute will not be observed.`);
+          break;
+        }
+      }
+    }
+  }
+}
+function modelForElement(template, node) {
+  let model;
+  while (node) {
+    if (model = node.__dataHost ? node : node.__templatizeInstance) {
+      if (model.__dataHost != template) {
+        node = model.__dataHost;
+      } else {
+        return model;
+      }
+    } else {
+      node = wrap(node).parentNode;
+    }
+  }
+  return null;
+}
+
+// ../../../node_modules/@polymer/polymer/lib/utils/hide-template-controls.js
+var elementsHidden = false;
+function hideElementsGlobally() {
+  if (legacyOptimizations && !useShadow) {
+    if (!elementsHidden) {
+      elementsHidden = true;
+      const style = document.createElement("style");
+      style.textContent = "dom-bind,dom-if,dom-repeat{display:none;}";
+      document.head.appendChild(style);
+    }
+    return true;
+  }
+  return false;
+}
+
+// ../../../node_modules/@polymer/polymer/lib/elements/dom-bind.js
+var domBindBase = GestureEventListeners(
+  OptionalMutableData(
+    PropertyEffects(HTMLElement)
+  )
+);
+var DomBind = class extends domBindBase {
+  static get observedAttributes() {
+    return ["mutable-data"];
+  }
+  constructor() {
+    super();
+    if (strictTemplatePolicy) {
+      throw new Error(`strictTemplatePolicy: dom-bind not allowed`);
+    }
+    this.root = null;
+    this.$ = null;
+    this.__children = null;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * @override
+   * @param {string} name Name of attribute that changed
+   * @param {?string} old Old attribute value
+   * @param {?string} value New attribute value
+   * @param {?string} namespace Attribute namespace.
+   * @return {void}
+   */
+  attributeChangedCallback(name, old, value, namespace) {
+    this.mutableData = true;
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  connectedCallback() {
+    if (!hideElementsGlobally()) {
+      this.style.display = "none";
+    }
+    this.render();
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  disconnectedCallback() {
+    this.__removeChildren();
+  }
+  __insertChildren() {
+    wrap(wrap(this).parentNode).insertBefore(this.root, this);
+  }
+  __removeChildren() {
+    if (this.__children) {
+      for (let i = 0; i < this.__children.length; i++) {
+        this.root.appendChild(this.__children[i]);
+      }
+    }
+  }
+  /**
+   * Forces the element to render its content. This is typically only
+   * necessary to call if HTMLImports with the async attribute are used.
+   * @return {void}
+   */
+  render() {
+    let template;
+    if (!this.__children) {
+      template = /** @type {?HTMLTemplateElement} */
+      template || this.querySelector("template");
+      if (!template) {
+        let observer = new MutationObserver(() => {
+          template = /** @type {HTMLTemplateElement} */
+          this.querySelector("template");
+          if (template) {
+            observer.disconnect();
+            this.render();
+          } else {
+            throw new Error("dom-bind requires a <template> child");
+          }
+        });
+        observer.observe(this, { childList: true });
+        return;
+      }
+      this.root = this._stampTemplate(
+        /** @type {!HTMLTemplateElement} */
+        template
+      );
+      this.$ = this.root.$;
+      this.__children = [];
+      for (let n = this.root.firstChild; n; n = n.nextSibling) {
+        this.__children[this.__children.length] = n;
+      }
+      this._enableProperties();
+    }
+    this.__insertChildren();
+    this.dispatchEvent(new CustomEvent("dom-change", {
+      bubbles: true,
+      composed: true
+    }));
+  }
+};
+customElements.define("dom-bind", DomBind);
+
+// ../../../node_modules/@polymer/polymer/lib/elements/dom-repeat.js
+var domRepeatBase = OptionalMutableData(PolymerElement);
+var DomRepeat = class extends domRepeatBase {
+  // Not needed to find template; can be removed once the analyzer
+  // can find the tag name from customElements.define call
+  static get is() {
+    return "dom-repeat";
+  }
+  static get template() {
+    return null;
+  }
+  static get properties() {
+    return {
+      /**
+       * An array containing items determining how many instances of the template
+       * to stamp and that that each template instance should bind to.
+       */
+      items: {
+        type: Array
+      },
+      /**
+       * The name of the variable to add to the binding scope for the array
+       * element associated with a given template instance.
+       */
+      as: {
+        type: String,
+        value: "item"
+      },
+      /**
+       * The name of the variable to add to the binding scope with the index
+       * of the instance in the sorted and filtered list of rendered items.
+       * Note, for the index in the `this.items` array, use the value of the
+       * `itemsIndexAs` property.
+       */
+      indexAs: {
+        type: String,
+        value: "index"
+      },
+      /**
+       * The name of the variable to add to the binding scope with the index
+       * of the instance in the `this.items` array. Note, for the index of
+       * this instance in the sorted and filtered list of rendered items,
+       * use the value of the `indexAs` property.
+       */
+      itemsIndexAs: {
+        type: String,
+        value: "itemsIndex"
+      },
+      /**
+       * A function that should determine the sort order of the items.  This
+       * property should either be provided as a string, indicating a method
+       * name on the element's host, or else be an actual function.  The
+       * function should match the sort function passed to `Array.sort`.
+       * Using a sort function has no effect on the underlying `items` array.
+       */
+      sort: {
+        type: Function,
+        observer: "__sortChanged"
+      },
+      /**
+       * A function that can be used to filter items out of the view.  This
+       * property should either be provided as a string, indicating a method
+       * name on the element's host, or else be an actual function.  The
+       * function should match the sort function passed to `Array.filter`.
+       * Using a filter function has no effect on the underlying `items` array.
+       */
+      filter: {
+        type: Function,
+        observer: "__filterChanged"
+      },
+      /**
+       * When using a `filter` or `sort` function, the `observe` property
+       * should be set to a space-separated list of the names of item
+       * sub-fields that should trigger a re-sort or re-filter when changed.
+       * These should generally be fields of `item` that the sort or filter
+       * function depends on.
+       */
+      observe: {
+        type: String,
+        observer: "__observeChanged"
+      },
+      /**
+       * When using a `filter` or `sort` function, the `delay` property
+       * determines a debounce time in ms after a change to observed item
+       * properties that must pass before the filter or sort is re-run.
+       * This is useful in rate-limiting shuffling of the view when
+       * item changes may be frequent.
+       */
+      delay: Number,
+      /**
+       * Count of currently rendered items after `filter` (if any) has been applied.
+       * If "chunking mode" is enabled, `renderedItemCount` is updated each time a
+       * set of template instances is rendered.
+       *
+       */
+      renderedItemCount: {
+        type: Number,
+        notify: !suppressTemplateNotifications,
+        readOnly: true
+      },
+      /**
+       * When greater than zero, defines an initial count of template instances
+       * to render after setting the `items` array, before the next paint, and
+       * puts the `dom-repeat` into "chunking mode".  The remaining items (and
+       * any future items as a result of pushing onto the array) will be created
+       * and rendered incrementally at each animation frame thereof until all
+       * instances have been rendered.
+       */
+      initialCount: {
+        type: Number
+      },
+      /**
+       * When `initialCount` is used, this property defines a frame rate (in
+       * fps) to target by throttling the number of instances rendered each
+       * frame to not exceed the budget for the target frame rate.  The
+       * framerate is effectively the number of `requestAnimationFrame`s that
+       * it tries to allow to actually fire in a given second. It does this
+       * by measuring the time between `rAF`s and continuously adjusting the
+       * number of items created each `rAF` to maintain the target framerate.
+       * Setting this to a higher number allows lower latency and higher
+       * throughput for event handlers and other tasks, but results in a
+       * longer time for the remaining items to complete rendering.
+       */
+      targetFramerate: {
+        type: Number,
+        value: 20
+      },
+      _targetFrameTime: {
+        type: Number,
+        computed: "__computeFrameTime(targetFramerate)"
+      },
+      /**
+       * When the global `suppressTemplateNotifications` setting is used, setting
+       * `notifyDomChange: true` will enable firing `dom-change` events on this
+       * element.
+       */
+      notifyDomChange: {
+        type: Boolean
+      },
+      /**
+       * When chunking is enabled via `initialCount` and the `items` array is
+       * set to a new array, this flag controls whether the previously rendered
+       * instances are reused or not.
+       *
+       * When `true`, any previously rendered template instances are updated in
+       * place to their new item values synchronously in one shot, and then any
+       * further items (if any) are chunked out.  When `false`, the list is
+       * returned back to its `initialCount` (any instances over the initial
+       * count are discarded) and the remainder of the list is chunked back in.
+       * Set this to `true` to avoid re-creating the list and losing scroll
+       * position, although note that when changing the list to completely
+       * different data the render thread will be blocked until all existing
+       * instances are updated to their new data.
+       */
+      reuseChunkedInstances: {
+        type: Boolean
+      }
+    };
+  }
+  static get observers() {
+    return ["__itemsChanged(items.*)"];
+  }
+  constructor() {
+    super();
+    this.__instances = [];
+    this.__renderDebouncer = null;
+    this.__itemsIdxToInstIdx = {};
+    this.__chunkCount = null;
+    this.__renderStartTime = null;
+    this.__itemsArrayChanged = false;
+    this.__shouldMeasureChunk = false;
+    this.__shouldContinueChunking = false;
+    this.__chunkingId = 0;
+    this.__sortFn = null;
+    this.__filterFn = null;
+    this.__observePaths = null;
+    this.__ctor = null;
+    this.__isDetached = true;
+    this.template = null;
+    this._templateInfo;
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.__isDetached = true;
+    for (let i = 0; i < this.__instances.length; i++) {
+      this.__detachInstance(i);
+    }
+    if (this.__chunkingId) {
+      cancelAnimationFrame(this.__chunkingId);
+    }
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  connectedCallback() {
+    super.connectedCallback();
+    if (!hideElementsGlobally()) {
+      this.style.display = "none";
+    }
+    if (this.__isDetached) {
+      this.__isDetached = false;
+      let wrappedParent = wrap(wrap(this).parentNode);
+      for (let i = 0; i < this.__instances.length; i++) {
+        this.__attachInstance(i, wrappedParent);
+      }
+      if (this.__chunkingId) {
+        this.__render();
+      }
+    }
+  }
+  __ensureTemplatized() {
+    if (!this.__ctor) {
+      const thisAsTemplate = (
+        /** @type {!HTMLTemplateElement} */
+        /** @type {!HTMLElement} */
+        this
+      );
+      let template = this.template = thisAsTemplate._templateInfo ? thisAsTemplate : (
+        /** @type {!HTMLTemplateElement} */
+        this.querySelector("template")
+      );
+      if (!template) {
+        let observer = new MutationObserver(() => {
+          if (this.querySelector("template")) {
+            observer.disconnect();
+            this.__render();
+          } else {
+            throw new Error("dom-repeat requires a <template> child");
+          }
+        });
+        observer.observe(this, { childList: true });
+        return false;
+      }
+      let instanceProps = {};
+      instanceProps[this.as] = true;
+      instanceProps[this.indexAs] = true;
+      instanceProps[this.itemsIndexAs] = true;
+      this.__ctor = templatize(template, this, {
+        mutableData: this.mutableData,
+        parentModel: true,
+        instanceProps,
+        /**
+         * @this {DomRepeat}
+         * @param {string} prop Property to set
+         * @param {*} value Value to set property to
+         */
+        forwardHostProp: function(prop, value) {
+          let i$ = this.__instances;
+          for (let i = 0, inst; i < i$.length && (inst = i$[i]); i++) {
+            inst.forwardHostProp(prop, value);
+          }
+        },
+        /**
+         * @this {DomRepeat}
+         * @param {Object} inst Instance to notify
+         * @param {string} prop Property to notify
+         * @param {*} value Value to notify
+         */
+        notifyInstanceProp: function(inst, prop, value) {
+          if (matches(this.as, prop)) {
+            let idx = inst[this.itemsIndexAs];
+            if (prop == this.as) {
+              this.items[idx] = value;
+            }
+            let path = translate(this.as, `${JSCompiler_renameProperty("items", this)}.${idx}`, prop);
+            this.notifyPath(path, value);
+          }
+        }
+      });
+    }
+    return true;
+  }
+  __getMethodHost() {
+    return this.__dataHost._methodHost || this.__dataHost;
+  }
+  __functionFromPropertyValue(functionOrMethodName) {
+    if (typeof functionOrMethodName === "string") {
+      let methodName = functionOrMethodName;
+      let obj = this.__getMethodHost();
+      return function() {
+        return obj[methodName].apply(obj, arguments);
+      };
+    }
+    return functionOrMethodName;
+  }
+  __sortChanged(sort) {
+    this.__sortFn = this.__functionFromPropertyValue(sort);
+    if (this.items) {
+      this.__debounceRender(this.__render);
+    }
+  }
+  __filterChanged(filter) {
+    this.__filterFn = this.__functionFromPropertyValue(filter);
+    if (this.items) {
+      this.__debounceRender(this.__render);
+    }
+  }
+  __computeFrameTime(rate) {
+    return Math.ceil(1e3 / rate);
+  }
+  __observeChanged() {
+    this.__observePaths = this.observe && this.observe.replace(".*", ".").split(" ");
+  }
+  __handleObservedPaths(path) {
+    if (this.__sortFn || this.__filterFn) {
+      if (!path) {
+        this.__debounceRender(this.__render, this.delay);
+      } else if (this.__observePaths) {
+        let paths = this.__observePaths;
+        for (let i = 0; i < paths.length; i++) {
+          if (path.indexOf(paths[i]) === 0) {
+            this.__debounceRender(this.__render, this.delay);
+          }
+        }
+      }
+    }
+  }
+  __itemsChanged(change) {
+    if (this.items && !Array.isArray(this.items)) {
+      console.warn("dom-repeat expected array for `items`, found", this.items);
+    }
+    if (!this.__handleItemPath(change.path, change.value)) {
+      if (change.path === "items") {
+        this.__itemsArrayChanged = true;
+      }
+      this.__debounceRender(this.__render);
+    }
+  }
+  /**
+   * @param {function(this:DomRepeat)} fn Function to debounce.
+   * @param {number=} delay Delay in ms to debounce by.
+   */
+  __debounceRender(fn, delay = 0) {
+    this.__renderDebouncer = Debouncer.debounce(
+      this.__renderDebouncer,
+      delay > 0 ? timeOut.after(delay) : microTask,
+      fn.bind(this)
+    );
+    enqueueDebouncer(this.__renderDebouncer);
+  }
+  /**
+   * Forces the element to render its content. Normally rendering is
+   * asynchronous to a provoking change. This is done for efficiency so
+   * that multiple changes trigger only a single render. The render method
+   * should be called if, for example, template rendering is required to
+   * validate application state.
+   * @return {void}
+   */
+  render() {
+    this.__debounceRender(this.__render);
+    flush();
+  }
+  __render() {
+    if (!this.__ensureTemplatized()) {
+      return;
+    }
+    let items = this.items || [];
+    const isntIdxToItemsIdx = this.__sortAndFilterItems(items);
+    const limit = this.__calculateLimit(isntIdxToItemsIdx.length);
+    this.__updateInstances(items, limit, isntIdxToItemsIdx);
+    if (this.initialCount && (this.__shouldMeasureChunk || this.__shouldContinueChunking)) {
+      cancelAnimationFrame(this.__chunkingId);
+      this.__chunkingId = requestAnimationFrame(() => {
+        this.__chunkingId = null;
+        this.__continueChunking();
+      });
+    }
+    this._setRenderedItemCount(this.__instances.length);
+    if (!suppressTemplateNotifications || this.notifyDomChange) {
+      this.dispatchEvent(new CustomEvent("dom-change", {
+        bubbles: true,
+        composed: true
+      }));
+    }
+  }
+  __sortAndFilterItems(items) {
+    let isntIdxToItemsIdx = new Array(items.length);
+    for (let i = 0; i < items.length; i++) {
+      isntIdxToItemsIdx[i] = i;
+    }
+    if (this.__filterFn) {
+      isntIdxToItemsIdx = isntIdxToItemsIdx.filter((i, idx, array) => this.__filterFn(items[i], idx, array));
+    }
+    if (this.__sortFn) {
+      isntIdxToItemsIdx.sort((a, b) => this.__sortFn(items[a], items[b]));
+    }
+    return isntIdxToItemsIdx;
+  }
+  __calculateLimit(filteredItemCount) {
+    let limit = filteredItemCount;
+    const currentCount = this.__instances.length;
+    if (this.initialCount) {
+      let newCount;
+      if (!this.__chunkCount || this.__itemsArrayChanged && !this.reuseChunkedInstances) {
+        limit = Math.min(filteredItemCount, this.initialCount);
+        newCount = Math.max(limit - currentCount, 0);
+        this.__chunkCount = newCount || 1;
+      } else {
+        newCount = Math.min(
+          Math.max(filteredItemCount - currentCount, 0),
+          this.__chunkCount
+        );
+        limit = Math.min(currentCount + newCount, filteredItemCount);
+      }
+      this.__shouldMeasureChunk = newCount === this.__chunkCount;
+      this.__shouldContinueChunking = limit < filteredItemCount;
+      this.__renderStartTime = performance.now();
+    }
+    this.__itemsArrayChanged = false;
+    return limit;
+  }
+  __continueChunking() {
+    if (this.__shouldMeasureChunk) {
+      const renderTime = performance.now() - this.__renderStartTime;
+      const ratio = this._targetFrameTime / renderTime;
+      this.__chunkCount = Math.round(this.__chunkCount * ratio) || 1;
+    }
+    if (this.__shouldContinueChunking) {
+      this.__debounceRender(this.__render);
+    }
+  }
+  __updateInstances(items, limit, isntIdxToItemsIdx) {
+    const itemsIdxToInstIdx = this.__itemsIdxToInstIdx = {};
+    let instIdx;
+    for (instIdx = 0; instIdx < limit; instIdx++) {
+      let inst = this.__instances[instIdx];
+      let itemIdx = isntIdxToItemsIdx[instIdx];
+      let item = items[itemIdx];
+      itemsIdxToInstIdx[itemIdx] = instIdx;
+      if (inst) {
+        inst._setPendingProperty(this.as, item);
+        inst._setPendingProperty(this.indexAs, instIdx);
+        inst._setPendingProperty(this.itemsIndexAs, itemIdx);
+        inst._flushProperties();
+      } else {
+        this.__insertInstance(item, instIdx, itemIdx);
+      }
+    }
+    for (let i = this.__instances.length - 1; i >= instIdx; i--) {
+      this.__detachAndRemoveInstance(i);
+    }
+  }
+  __detachInstance(idx) {
+    let inst = this.__instances[idx];
+    const wrappedRoot = wrap(inst.root);
+    for (let i = 0; i < inst.children.length; i++) {
+      let el = inst.children[i];
+      wrappedRoot.appendChild(el);
+    }
+    return inst;
+  }
+  __attachInstance(idx, parent) {
+    let inst = this.__instances[idx];
+    parent.insertBefore(inst.root, this);
+  }
+  __detachAndRemoveInstance(idx) {
+    this.__detachInstance(idx);
+    this.__instances.splice(idx, 1);
+  }
+  __stampInstance(item, instIdx, itemIdx) {
+    let model = {};
+    model[this.as] = item;
+    model[this.indexAs] = instIdx;
+    model[this.itemsIndexAs] = itemIdx;
+    return new this.__ctor(model);
+  }
+  __insertInstance(item, instIdx, itemIdx) {
+    const inst = this.__stampInstance(item, instIdx, itemIdx);
+    let beforeRow = this.__instances[instIdx + 1];
+    let beforeNode = beforeRow ? beforeRow.children[0] : this;
+    wrap(wrap(this).parentNode).insertBefore(inst.root, beforeNode);
+    this.__instances[instIdx] = inst;
+    return inst;
+  }
+  // Implements extension point from Templatize mixin
+  /**
+   * Shows or hides the template instance top level child elements. For
+   * text nodes, `textContent` is removed while "hidden" and replaced when
+   * "shown."
+   * @param {boolean} hidden Set to true to hide the children;
+   * set to false to show them.
+   * @return {void}
+   * @protected
+   */
+  _showHideChildren(hidden) {
+    for (let i = 0; i < this.__instances.length; i++) {
+      this.__instances[i]._showHideChildren(hidden);
+    }
+  }
+  // Called as a side effect of a host items.<key>.<path> path change,
+  // responsible for notifying item.<path> changes to inst for key
+  __handleItemPath(path, value) {
+    let itemsPath = path.slice(6);
+    let dot = itemsPath.indexOf(".");
+    let itemsIdx = dot < 0 ? itemsPath : itemsPath.substring(0, dot);
+    if (itemsIdx == parseInt(itemsIdx, 10)) {
+      let itemSubPath = dot < 0 ? "" : itemsPath.substring(dot + 1);
+      this.__handleObservedPaths(itemSubPath);
+      let instIdx = this.__itemsIdxToInstIdx[itemsIdx];
+      let inst = this.__instances[instIdx];
+      if (inst) {
+        let itemPath = this.as + (itemSubPath ? "." + itemSubPath : "");
+        inst._setPendingPropertyOrPath(itemPath, value, false, true);
+        inst._flushProperties();
+      }
+      return true;
+    }
+  }
+  /**
+   * Returns the item associated with a given element stamped by
+   * this `dom-repeat`.
+   *
+   * Note, to modify sub-properties of the item,
+   * `modelForElement(el).set('item.<sub-prop>', value)`
+   * should be used.
+   *
+   * @param {!HTMLElement} el Element for which to return the item.
+   * @return {*} Item associated with the element.
+   */
+  itemForElement(el) {
+    let instance = this.modelForElement(el);
+    return instance && instance[this.as];
+  }
+  /**
+   * Returns the inst index for a given element stamped by this `dom-repeat`.
+   * If `sort` is provided, the index will reflect the sorted order (rather
+   * than the original array order).
+   *
+   * @param {!HTMLElement} el Element for which to return the index.
+   * @return {?number} Row index associated with the element (note this may
+   *   not correspond to the array index if a user `sort` is applied).
+   */
+  indexForElement(el) {
+    let instance = this.modelForElement(el);
+    return instance && instance[this.indexAs];
+  }
+  /**
+   * Returns the template "model" associated with a given element, which
+   * serves as the binding scope for the template instance the element is
+   * contained in. A template model
+   * should be used to manipulate data associated with this template instance.
+   *
+   * Example:
+   *
+   *   let model = modelForElement(el);
+   *   if (model.index < 10) {
+   *     model.set('item.checked', true);
+   *   }
+   *
+   * @param {!HTMLElement} el Element for which to return a template model.
+   * @return {TemplateInstanceBase} Model representing the binding scope for
+   *   the element.
+   */
+  modelForElement(el) {
+    return modelForElement(this.template, el);
+  }
+};
+customElements.define(DomRepeat.is, DomRepeat);
+
+// ../../../node_modules/@polymer/polymer/lib/elements/dom-if.js
+var DomIfBase = class extends PolymerElement {
+  // Not needed to find template; can be removed once the analyzer
+  // can find the tag name from customElements.define call
+  static get is() {
+    return "dom-if";
+  }
+  static get template() {
+    return null;
+  }
+  static get properties() {
+    return {
+      /**
+       * Fired whenever DOM is added or removed/hidden by this template (by
+       * default, rendering occurs lazily).  To force immediate rendering, call
+       * `render`.
+       *
+       * @event dom-change
+       */
+      /**
+       * A boolean indicating whether this template should stamp.
+       */
+      if: {
+        type: Boolean,
+        observer: "__debounceRender"
+      },
+      /**
+       * When true, elements will be removed from DOM and discarded when `if`
+       * becomes false and re-created and added back to the DOM when `if`
+       * becomes true.  By default, stamped elements will be hidden but left
+       * in the DOM when `if` becomes false, which is generally results
+       * in better performance.
+       */
+      restamp: {
+        type: Boolean,
+        observer: "__debounceRender"
+      },
+      /**
+       * When the global `suppressTemplateNotifications` setting is used, setting
+       * `notifyDomChange: true` will enable firing `dom-change` events on this
+       * element.
+       */
+      notifyDomChange: {
+        type: Boolean
+      }
+    };
+  }
+  constructor() {
+    super();
+    this.__renderDebouncer = null;
+    this._lastIf = false;
+    this.__hideTemplateChildren__ = false;
+    this.__template;
+    this._templateInfo;
+  }
+  __debounceRender() {
+    this.__renderDebouncer = Debouncer.debounce(
+      this.__renderDebouncer,
+      microTask,
+      () => this.__render()
+    );
+    enqueueDebouncer(this.__renderDebouncer);
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    const parent = wrap(this).parentNode;
+    if (!parent || parent.nodeType == Node.DOCUMENT_FRAGMENT_NODE && !wrap(parent).host) {
+      this.__teardownInstance();
+    }
+  }
+  /**
+   * @override
+   * @return {void}
+   */
+  connectedCallback() {
+    super.connectedCallback();
+    if (!hideElementsGlobally()) {
+      this.style.display = "none";
+    }
+    if (this.if) {
+      this.__debounceRender();
+    }
+  }
+  /**
+   * Ensures a template has been assigned to `this.__template`.  If it has not
+   * yet been, it querySelectors for it in its children and if it does not yet
+   * exist (e.g. in parser-generated case), opens a mutation observer and
+   * waits for it to appear (returns false if it has not yet been found,
+   * otherwise true).  In the `removeNestedTemplates` case, the "template" will
+   * be the `dom-if` element itself.
+   *
+   * @return {boolean} True when a template has been found, false otherwise
+   */
+  __ensureTemplate() {
+    if (!this.__template) {
+      const thisAsTemplate = (
+        /** @type {!HTMLTemplateElement} */
+        /** @type {!HTMLElement} */
+        this
+      );
+      let template = thisAsTemplate._templateInfo ? thisAsTemplate : (
+        /** @type {!HTMLTemplateElement} */
+        wrap(thisAsTemplate).querySelector("template")
+      );
+      if (!template) {
+        let observer = new MutationObserver(() => {
+          if (wrap(this).querySelector("template")) {
+            observer.disconnect();
+            this.__render();
+          } else {
+            throw new Error("dom-if requires a <template> child");
+          }
+        });
+        observer.observe(this, { childList: true });
+        return false;
+      }
+      this.__template = template;
+    }
+    return true;
+  }
+  /**
+   * Ensures a an instance of the template has been created and inserted. This
+   * method may return false if the template has not yet been found or if
+   * there is no `parentNode` to insert the template into (in either case,
+   * connection or the template-finding mutation observer firing will queue
+   * another render, causing this method to be called again at a more
+   * appropriate time).
+   *
+   * Subclasses should implement the following methods called here:
+   * - `__hasInstance`
+   * - `__createAndInsertInstance`
+   * - `__getInstanceNodes`
+   *
+   * @return {boolean} True if the instance was created, false otherwise.
+   */
+  __ensureInstance() {
+    let parentNode = wrap(this).parentNode;
+    if (!this.__hasInstance()) {
+      if (!parentNode) {
+        return false;
+      }
+      if (!this.__ensureTemplate()) {
+        return false;
+      }
+      this.__createAndInsertInstance(parentNode);
+    } else {
+      let children = this.__getInstanceNodes();
+      if (children && children.length) {
+        let lastChild = wrap(this).previousSibling;
+        if (lastChild !== children[children.length - 1]) {
+          for (let i = 0, n; i < children.length && (n = children[i]); i++) {
+            wrap(parentNode).insertBefore(n, this);
+          }
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Forces the element to render its content. Normally rendering is
+   * asynchronous to a provoking change. This is done for efficiency so
+   * that multiple changes trigger only a single render. The render method
+   * should be called if, for example, template rendering is required to
+   * validate application state.
+   *
+   * @return {void}
+   */
+  render() {
+    flush();
+  }
+  /**
+   * Performs the key rendering steps:
+   * 1. Ensure a template instance has been stamped (when true)
+   * 2. Remove the template instance (when false and restamp:true)
+   * 3. Sync the hidden state of the instance nodes with the if/restamp state
+   * 4. Fires the `dom-change` event when necessary
+   *
+   * @return {void}
+   */
+  __render() {
+    if (this.if) {
+      if (!this.__ensureInstance()) {
+        return;
+      }
+    } else if (this.restamp) {
+      this.__teardownInstance();
+    }
+    this._showHideChildren();
+    if ((!suppressTemplateNotifications || this.notifyDomChange) && this.if != this._lastIf) {
+      this.dispatchEvent(new CustomEvent("dom-change", {
+        bubbles: true,
+        composed: true
+      }));
+      this._lastIf = this.if;
+    }
+  }
+  // Ideally these would be annotated as abstract methods in an abstract class,
+  // but closure compiler is finnicky
+  /* eslint-disable valid-jsdoc */
+  /**
+   * Abstract API to be implemented by subclass: Returns true if a template
+   * instance has been created and inserted.
+   *
+   * @protected
+   * @return {boolean} True when an instance has been created.
+   */
+  __hasInstance() {
+  }
+  /**
+   * Abstract API to be implemented by subclass: Returns the child nodes stamped
+   * from a template instance.
+   *
+   * @protected
+   * @return {Array<Node>} Array of child nodes stamped from the template
+   * instance.
+   */
+  __getInstanceNodes() {
+  }
+  /**
+   * Abstract API to be implemented by subclass: Creates an instance of the
+   * template and inserts it into the given parent node.
+   *
+   * @protected
+   * @param {Node} parentNode The parent node to insert the instance into
+   * @return {void}
+   */
+  __createAndInsertInstance(parentNode) {
+  }
+  // eslint-disable-line no-unused-vars
+  /**
+   * Abstract API to be implemented by subclass: Removes nodes created by an
+   * instance of a template and any associated cleanup.
+   *
+   * @protected
+   * @return {void}
+   */
+  __teardownInstance() {
+  }
+  /**
+   * Abstract API to be implemented by subclass: Shows or hides any template
+   * instance childNodes based on the `if` state of the element and its
+   * `__hideTemplateChildren__` property.
+   *
+   * @protected
+   * @return {void}
+   */
+  _showHideChildren() {
+  }
+  /* eslint-enable valid-jsdoc */
+};
+var DomIfFast = class extends DomIfBase {
+  constructor() {
+    super();
+    this.__instance = null;
+    this.__syncInfo = null;
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * @override
+   * @return {boolean} True when an instance has been created.
+   */
+  __hasInstance() {
+    return Boolean(this.__instance);
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * @override
+   * @return {Array<Node>} Array of child nodes stamped from the template
+   * instance.
+   */
+  __getInstanceNodes() {
+    return this.__instance.templateInfo.childNodes;
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Stamps the template by calling `_stampTemplate` on the `__dataHost` of this
+   * element and then inserts the resulting nodes into the given `parentNode`.
+   *
+   * @override
+   * @param {Node} parentNode The parent node to insert the instance into
+   * @return {void}
+   */
+  __createAndInsertInstance(parentNode) {
+    const host = this.__dataHost || this;
+    if (strictTemplatePolicy) {
+      if (!this.__dataHost) {
+        throw new Error("strictTemplatePolicy: template owner not trusted");
+      }
+    }
+    const templateInfo = host._bindTemplate(
+      /** @type {!HTMLTemplateElement} */
+      this.__template,
+      true
+    );
+    templateInfo.runEffects = (runEffects, changedProps, hasPaths) => {
+      let syncInfo = this.__syncInfo;
+      if (this.if) {
+        if (syncInfo) {
+          this.__syncInfo = null;
+          this._showHideChildren();
+          changedProps = Object.assign(syncInfo.changedProps, changedProps);
+        }
+        runEffects(changedProps, hasPaths);
+      } else {
+        if (this.__instance) {
+          if (!syncInfo) {
+            syncInfo = this.__syncInfo = { runEffects, changedProps: {} };
+          }
+          if (hasPaths) {
+            for (const p in changedProps) {
+              const rootProp = root(p);
+              syncInfo.changedProps[rootProp] = this.__dataHost[rootProp];
+            }
+          } else {
+            Object.assign(syncInfo.changedProps, changedProps);
+          }
+        }
+      }
+    };
+    this.__instance = host._stampTemplate(
+      /** @type {!HTMLTemplateElement} */
+      this.__template,
+      templateInfo
+    );
+    wrap(parentNode).insertBefore(this.__instance, this);
+  }
+  /**
+   * Run effects for any properties that changed while the `if` was false.
+   *
+   * @return {void}
+   */
+  __syncHostProperties() {
+    const syncInfo = this.__syncInfo;
+    if (syncInfo) {
+      this.__syncInfo = null;
+      syncInfo.runEffects(syncInfo.changedProps, false);
+    }
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Remove the instance and any nodes it created.  Uses the `__dataHost`'s
+   * runtime `_removeBoundDom` method.
+   *
+   * @override
+   * @return {void}
+   */
+  __teardownInstance() {
+    const host = this.__dataHost || this;
+    if (this.__instance) {
+      host._removeBoundDom(this.__instance);
+      this.__instance = null;
+      this.__syncInfo = null;
+    }
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Shows or hides the template instance top level child nodes. For
+   * text nodes, `textContent` is removed while "hidden" and replaced when
+   * "shown."
+   *
+   * @override
+   * @return {void}
+   * @protected
+   * @suppress {visibility}
+   */
+  _showHideChildren() {
+    const hidden = this.__hideTemplateChildren__ || !this.if;
+    if (this.__instance && Boolean(this.__instance.__hidden) !== hidden) {
+      this.__instance.__hidden = hidden;
+      showHideChildren(hidden, this.__instance.templateInfo.childNodes);
+    }
+    if (!hidden) {
+      this.__syncHostProperties();
+    }
+  }
+};
+var DomIfLegacy = class extends DomIfBase {
+  constructor() {
+    super();
+    this.__ctor = null;
+    this.__instance = null;
+    this.__invalidProps = null;
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * @override
+   * @return {boolean} True when an instance has been created.
+   */
+  __hasInstance() {
+    return Boolean(this.__instance);
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * @override
+   * @return {Array<Node>} Array of child nodes stamped from the template
+   * instance.
+   */
+  __getInstanceNodes() {
+    return this.__instance.children;
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Stamps the template by creating a new instance of the templatized
+   * constructor (which is created lazily if it does not yet exist), and then
+   * inserts its resulting `root` doc fragment into the given `parentNode`.
+   *
+   * @override
+   * @param {Node} parentNode The parent node to insert the instance into
+   * @return {void}
+   */
+  __createAndInsertInstance(parentNode) {
+    if (!this.__ctor) {
+      this.__ctor = templatize(
+        /** @type {!HTMLTemplateElement} */
+        this.__template,
+        this,
+        {
+          // dom-if templatizer instances require `mutable: true`, as
+          // `__syncHostProperties` relies on that behavior to sync objects
+          mutableData: true,
+          /**
+           * @param {string} prop Property to forward
+           * @param {*} value Value of property
+           * @this {DomIfLegacy}
+           */
+          forwardHostProp: function(prop, value) {
+            if (this.__instance) {
+              if (this.if) {
+                this.__instance.forwardHostProp(prop, value);
+              } else {
+                this.__invalidProps = this.__invalidProps || /* @__PURE__ */ Object.create(null);
+                this.__invalidProps[root(prop)] = true;
+              }
+            }
+          }
+        }
+      );
+    }
+    this.__instance = new this.__ctor();
+    wrap(parentNode).insertBefore(this.__instance.root, this);
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Removes the instance and any nodes it created.
+   *
+   * @override
+   * @return {void}
+   */
+  __teardownInstance() {
+    if (this.__instance) {
+      let c$ = this.__instance.children;
+      if (c$ && c$.length) {
+        let parent = wrap(c$[0]).parentNode;
+        if (parent) {
+          parent = wrap(parent);
+          for (let i = 0, n; i < c$.length && (n = c$[i]); i++) {
+            parent.removeChild(n);
+          }
+        }
+      }
+      this.__invalidProps = null;
+      this.__instance = null;
+    }
+  }
+  /**
+   * Forwards any properties that changed while the `if` was false into the
+   * template instance and flushes it.
+   *
+   * @return {void}
+   */
+  __syncHostProperties() {
+    let props = this.__invalidProps;
+    if (props) {
+      this.__invalidProps = null;
+      for (let prop in props) {
+        this.__instance._setPendingProperty(prop, this.__dataHost[prop]);
+      }
+      this.__instance._flushProperties();
+    }
+  }
+  /**
+   * Implementation of abstract API needed by DomIfBase.
+   *
+   * Shows or hides the template instance top level child elements. For
+   * text nodes, `textContent` is removed while "hidden" and replaced when
+   * "shown."
+   *
+   * @override
+   * @protected
+   * @return {void}
+   * @suppress {visibility}
+   */
+  _showHideChildren() {
+    const hidden = this.__hideTemplateChildren__ || !this.if;
+    if (this.__instance && Boolean(this.__instance.__hidden) !== hidden) {
+      this.__instance.__hidden = hidden;
+      this.__instance._showHideChildren(hidden);
+    }
+    if (!hidden) {
+      this.__syncHostProperties();
+    }
+  }
+};
+var DomIf = fastDomIf ? DomIfFast : DomIfLegacy;
+customElements.define(DomIf.is, DomIf);
+
+// ../../../node_modules/@polymer/polymer/lib/elements/array-selector.js
+var ArraySelectorMixin = dedupingMixin((superClass) => {
+  let elementBase = ElementMixin(superClass);
+  class ArraySelectorMixin2 extends elementBase {
+    static get properties() {
+      return {
+        /**
+         * An array containing items from which selection will be made.
+         */
+        items: {
+          type: Array
+        },
+        /**
+         * When `true`, multiple items may be selected at once (in this case,
+         * `selected` is an array of currently selected items).  When `false`,
+         * only one item may be selected at a time.
+         */
+        multi: {
+          type: Boolean,
+          value: false
+        },
+        /**
+         * When `multi` is true, this is an array that contains any selected.
+         * When `multi` is false, this is the currently selected item, or `null`
+         * if no item is selected.
+         * @type {?Object|?Array<!Object>}
+         */
+        selected: { type: Object, notify: true },
+        /**
+         * When `multi` is false, this is the currently selected item, or `null`
+         * if no item is selected.
+         * @type {?Object}
+         */
+        selectedItem: { type: Object, notify: true },
+        /**
+         * When `true`, calling `select` on an item that is already selected
+         * will deselect the item.
+         */
+        toggle: { type: Boolean, value: false }
+      };
+    }
+    static get observers() {
+      return ["__updateSelection(multi, items.*)"];
+    }
+    constructor() {
+      super();
+      this.__lastItems = null;
+      this.__lastMulti = null;
+      this.__selectedMap = null;
+    }
+    __updateSelection(multi, itemsInfo) {
+      let path = itemsInfo.path;
+      if (path == JSCompiler_renameProperty("items", this)) {
+        let newItems = itemsInfo.base || [];
+        let lastItems = this.__lastItems;
+        let lastMulti = this.__lastMulti;
+        if (multi !== lastMulti) {
+          this.clearSelection();
+        }
+        if (lastItems) {
+          let splices = calculateSplices(newItems, lastItems);
+          this.__applySplices(splices);
+        }
+        this.__lastItems = newItems;
+        this.__lastMulti = multi;
+      } else if (itemsInfo.path == `${JSCompiler_renameProperty("items", this)}.splices`) {
+        this.__applySplices(itemsInfo.value.indexSplices);
+      } else {
+        let part = path.slice(`${JSCompiler_renameProperty("items", this)}.`.length);
+        let idx = parseInt(part, 10);
+        if (part.indexOf(".") < 0 && part == idx) {
+          this.__deselectChangedIdx(idx);
+        }
+      }
+    }
+    __applySplices(splices) {
+      let selected = this.__selectedMap;
+      for (let i = 0; i < splices.length; i++) {
+        let s = splices[i];
+        selected.forEach((idx, item) => {
+          if (idx < s.index) {
+          } else if (idx >= s.index + s.removed.length) {
+            selected.set(item, idx + s.addedCount - s.removed.length);
+          } else {
+            selected.set(item, -1);
+          }
+        });
+        for (let j = 0; j < s.addedCount; j++) {
+          let idx = s.index + j;
+          if (selected.has(this.items[idx])) {
+            selected.set(this.items[idx], idx);
+          }
+        }
+      }
+      this.__updateLinks();
+      let sidx = 0;
+      selected.forEach((idx, item) => {
+        if (idx < 0) {
+          if (this.multi) {
+            this.splice(JSCompiler_renameProperty("selected", this), sidx, 1);
+          } else {
+            this.selected = this.selectedItem = null;
+          }
+          selected.delete(item);
+        } else {
+          sidx++;
+        }
+      });
+    }
+    __updateLinks() {
+      this.__dataLinkedPaths = {};
+      if (this.multi) {
+        let sidx = 0;
+        this.__selectedMap.forEach((idx) => {
+          if (idx >= 0) {
+            this.linkPaths(
+              `${JSCompiler_renameProperty("items", this)}.${idx}`,
+              `${JSCompiler_renameProperty("selected", this)}.${sidx++}`
+            );
+          }
+        });
+      } else {
+        this.__selectedMap.forEach((idx) => {
+          this.linkPaths(
+            JSCompiler_renameProperty("selected", this),
+            `${JSCompiler_renameProperty("items", this)}.${idx}`
+          );
+          this.linkPaths(
+            JSCompiler_renameProperty("selectedItem", this),
+            `${JSCompiler_renameProperty("items", this)}.${idx}`
+          );
+        });
+      }
+    }
+    /**
+     * Clears the selection state.
+     * @override
+     * @return {void}
+     */
+    clearSelection() {
+      this.__dataLinkedPaths = {};
+      this.__selectedMap = /* @__PURE__ */ new Map();
+      this.selected = this.multi ? [] : null;
+      this.selectedItem = null;
+    }
+    /**
+     * Returns whether the item is currently selected.
+     *
+     * @override
+     * @param {*} item Item from `items` array to test
+     * @return {boolean} Whether the item is selected
+     */
+    isSelected(item) {
+      return this.__selectedMap.has(item);
+    }
+    /**
+     * Returns whether the item is currently selected.
+     *
+     * @override
+     * @param {number} idx Index from `items` array to test
+     * @return {boolean} Whether the item is selected
+     */
+    isIndexSelected(idx) {
+      return this.isSelected(this.items[idx]);
+    }
+    __deselectChangedIdx(idx) {
+      let sidx = this.__selectedIndexForItemIndex(idx);
+      if (sidx >= 0) {
+        let i = 0;
+        this.__selectedMap.forEach((idx2, item) => {
+          if (sidx == i++) {
+            this.deselect(item);
+          }
+        });
+      }
+    }
+    __selectedIndexForItemIndex(idx) {
+      let selected = this.__dataLinkedPaths[`${JSCompiler_renameProperty("items", this)}.${idx}`];
+      if (selected) {
+        return parseInt(selected.slice(`${JSCompiler_renameProperty("selected", this)}.`.length), 10);
+      }
+    }
+    /**
+     * Deselects the given item if it is already selected.
+     *
+     * @override
+     * @param {*} item Item from `items` array to deselect
+     * @return {void}
+     */
+    deselect(item) {
+      let idx = this.__selectedMap.get(item);
+      if (idx >= 0) {
+        this.__selectedMap.delete(item);
+        let sidx;
+        if (this.multi) {
+          sidx = this.__selectedIndexForItemIndex(idx);
+        }
+        this.__updateLinks();
+        if (this.multi) {
+          this.splice(JSCompiler_renameProperty("selected", this), sidx, 1);
+        } else {
+          this.selected = this.selectedItem = null;
+        }
+      }
+    }
+    /**
+     * Deselects the given index if it is already selected.
+     *
+     * @override
+     * @param {number} idx Index from `items` array to deselect
+     * @return {void}
+     */
+    deselectIndex(idx) {
+      this.deselect(this.items[idx]);
+    }
+    /**
+     * Selects the given item.  When `toggle` is true, this will automatically
+     * deselect the item if already selected.
+     *
+     * @override
+     * @param {*} item Item from `items` array to select
+     * @return {void}
+     */
+    select(item) {
+      this.selectIndex(this.items.indexOf(item));
+    }
+    /**
+     * Selects the given index.  When `toggle` is true, this will automatically
+     * deselect the item if already selected.
+     *
+     * @override
+     * @param {number} idx Index from `items` array to select
+     * @return {void}
+     */
+    selectIndex(idx) {
+      let item = this.items[idx];
+      if (!this.isSelected(item)) {
+        if (!this.multi) {
+          this.__selectedMap.clear();
+        }
+        this.__selectedMap.set(item, idx);
+        this.__updateLinks();
+        if (this.multi) {
+          this.push(JSCompiler_renameProperty("selected", this), item);
+        } else {
+          this.selected = this.selectedItem = item;
+        }
+      } else if (this.toggle) {
+        this.deselectIndex(idx);
+      }
+    }
+  }
+  return ArraySelectorMixin2;
+});
+var baseArraySelector = ArraySelectorMixin(PolymerElement);
+var ArraySelector = class extends baseArraySelector {
+  // Not needed to find template; can be removed once the analyzer
+  // can find the tag name from customElements.define call
+  static get is() {
+    return "array-selector";
+  }
+  static get template() {
+    return null;
+  }
+};
+customElements.define(ArraySelector.is, ArraySelector);
+
+// ../../../node_modules/@webcomponents/shadycss/entrypoints/custom-style-interface.js
+var customStyleInterface = new CustomStyleInterface();
+if (!window.ShadyCSS) {
+  window.ShadyCSS = {
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     * @param {string=} elementExtends
+     */
+    prepareTemplate(template, elementName, elementExtends) {
+    },
+    // eslint-disable-line no-unused-vars
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     */
+    prepareTemplateDom(template, elementName) {
+    },
+    // eslint-disable-line no-unused-vars
+    /**
+     * @param {!HTMLTemplateElement} template
+     * @param {string} elementName
+     * @param {string=} elementExtends
+     */
+    prepareTemplateStyles(template, elementName, elementExtends) {
+    },
+    // eslint-disable-line no-unused-vars
+    /**
+     * @param {Element} element
+     * @param {Object=} properties
+     */
+    styleSubtree(element, properties) {
+      customStyleInterface.processStyles();
+      updateNativeProperties(element, properties);
+    },
+    /**
+     * @param {Element} element
+     */
+    styleElement(element) {
+      customStyleInterface.processStyles();
+    },
+    /**
+     * @param {Object=} properties
+     */
+    styleDocument(properties) {
+      customStyleInterface.processStyles();
+      updateNativeProperties(document.body, properties);
+    },
+    /**
+     * @param {Element} element
+     * @param {string} property
+     * @return {string}
+     */
+    getComputedStyleValue(element, property) {
+      return getComputedStyleValue(element, property);
+    },
+    flushCustomStyles() {
+    },
+    nativeCss: nativeCssVariables,
+    nativeShadow,
+    cssBuild,
+    disableRuntime
+  };
+}
+window.ShadyCSS.CustomStyleInterface = customStyleInterface;
+
+// ../../../node_modules/@polymer/polymer/lib/elements/custom-style.js
+var attr = "include";
+var CustomStyleInterface2 = window.ShadyCSS.CustomStyleInterface;
+var CustomStyle = class extends HTMLElement {
+  constructor() {
+    super();
+    this._style = null;
+    CustomStyleInterface2.addCustomStyle(this);
+  }
+  /**
+   * Returns the light-DOM `<style>` child this element wraps.  Upon first
+   * call any style modules referenced via the `include` attribute will be
+   * concatenated to this element's `<style>`.
+   *
+   * @export
+   * @return {HTMLStyleElement} This element's light-DOM `<style>`
+   */
+  getStyle() {
+    if (this._style) {
+      return this._style;
+    }
+    const style = (
+      /** @type {HTMLStyleElement} */
+      this.querySelector("style")
+    );
+    if (!style) {
+      return null;
+    }
+    this._style = style;
+    const include = style.getAttribute(attr);
+    if (include) {
+      style.removeAttribute(attr);
+      style.textContent = cssFromModules(include) + style.textContent;
+    }
+    if (this.ownerDocument !== window.document) {
+      window.document.head.appendChild(this);
+    }
+    return this._style;
+  }
+};
+window.customElements.define("custom-style", CustomStyle);
+
+// ../../../node_modules/@polymer/polymer/lib/legacy/mutable-data-behavior.js
+var mutablePropertyChange2;
+(() => {
+  mutablePropertyChange2 = MutableData._mutablePropertyChange;
+})();
+
+// ../../../node_modules/@polymer/polymer/polymer-legacy.js
+var Base = LegacyElementMixin(HTMLElement).prototype;
+
+// ../../../node_modules/@polymer/iron-resizable-behavior/iron-resizable-behavior.js
+var ORPHANS = /* @__PURE__ */ new Set();
+var IronResizableBehavior = {
+  properties: {
+    /**
+     * The closest ancestor element that implements `IronResizableBehavior`.
+     */
+    _parentResizable: {
+      type: Object,
+      observer: "_parentResizableChanged"
+    },
+    /**
+     * True if this element is currently notifying its descendant elements of
+     * resize.
+     */
+    _notifyingDescendant: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    "iron-request-resize-notifications": "_onIronRequestResizeNotifications"
+  },
+  created: function() {
+    this._interestedResizables = [];
+    this._boundNotifyResize = this.notifyResize.bind(this);
+    this._boundOnDescendantIronResize = this._onDescendantIronResize.bind(this);
+  },
+  attached: function() {
+    this._requestResizeNotifications();
+  },
+  detached: function() {
+    if (this._parentResizable) {
+      this._parentResizable.stopResizeNotificationsFor(this);
+    } else {
+      ORPHANS.delete(this);
+      window.removeEventListener("resize", this._boundNotifyResize);
+    }
+    this._parentResizable = null;
+  },
+  /**
+   * Can be called to manually notify a resizable and its descendant
+   * resizables of a resize change.
+   */
+  notifyResize: function() {
+    if (!this.isAttached) {
+      return;
+    }
+    this._interestedResizables.forEach(function(resizable) {
+      if (this.resizerShouldNotify(resizable)) {
+        this._notifyDescendant(resizable);
+      }
+    }, this);
+    this._fireResize();
+  },
+  /**
+   * Used to assign the closest resizable ancestor to this resizable
+   * if the ancestor detects a request for notifications.
+   */
+  assignParentResizable: function(parentResizable) {
+    if (this._parentResizable) {
+      this._parentResizable.stopResizeNotificationsFor(this);
+    }
+    this._parentResizable = parentResizable;
+    if (parentResizable && parentResizable._interestedResizables.indexOf(this) === -1) {
+      parentResizable._interestedResizables.push(this);
+      parentResizable._subscribeIronResize(this);
+    }
+  },
+  /**
+   * Used to remove a resizable descendant from the list of descendants
+   * that should be notified of a resize change.
+   */
+  stopResizeNotificationsFor: function(target) {
+    var index = this._interestedResizables.indexOf(target);
+    if (index > -1) {
+      this._interestedResizables.splice(index, 1);
+      this._unsubscribeIronResize(target);
+    }
+  },
+  /**
+   * Subscribe this element to listen to iron-resize events on the given target.
+   *
+   * Preferred over target.listen because the property renamer does not
+   * understand to rename when the target is not specifically "this"
+   *
+   * @param {!HTMLElement} target Element to listen to for iron-resize events.
+   */
+  _subscribeIronResize: function(target) {
+    target.addEventListener("iron-resize", this._boundOnDescendantIronResize);
+  },
+  /**
+   * Unsubscribe this element from listening to to iron-resize events on the
+   * given target.
+   *
+   * Preferred over target.unlisten because the property renamer does not
+   * understand to rename when the target is not specifically "this"
+   *
+   * @param {!HTMLElement} target Element to listen to for iron-resize events.
+   */
+  _unsubscribeIronResize: function(target) {
+    target.removeEventListener(
+      "iron-resize",
+      this._boundOnDescendantIronResize
+    );
+  },
+  /**
+   * This method can be overridden to filter nested elements that should or
+   * should not be notified by the current element. Return true if an element
+   * should be notified, or false if it should not be notified.
+   *
+   * @param {HTMLElement} element A candidate descendant element that
+   * implements `IronResizableBehavior`.
+   * @return {boolean} True if the `element` should be notified of resize.
+   */
+  resizerShouldNotify: function(element) {
+    return true;
+  },
+  _onDescendantIronResize: function(event) {
+    if (this._notifyingDescendant) {
+      event.stopPropagation();
+      return;
+    }
+    if (!useShadow) {
+      this._fireResize();
+    }
+  },
+  _fireResize: function() {
+    this.fire("iron-resize", null, { node: this, bubbles: false });
+  },
+  _onIronRequestResizeNotifications: function(event) {
+    var target = (
+      /** @type {!EventTarget} */
+      dom(event).rootTarget
+    );
+    if (target === this) {
+      return;
+    }
+    target.assignParentResizable(this);
+    this._notifyDescendant(target);
+    event.stopPropagation();
+  },
+  _parentResizableChanged: function(parentResizable) {
+    if (parentResizable) {
+      window.removeEventListener("resize", this._boundNotifyResize);
+    }
+  },
+  _notifyDescendant: function(descendant) {
+    if (!this.isAttached) {
+      return;
+    }
+    this._notifyingDescendant = true;
+    descendant.notifyResize();
+    this._notifyingDescendant = false;
+  },
+  _requestResizeNotifications: function() {
+    if (!this.isAttached) {
+      return;
+    }
+    if (document.readyState === "loading") {
+      var _requestResizeNotifications = this._requestResizeNotifications.bind(this);
+      document.addEventListener(
+        "readystatechange",
+        function readystatechanged() {
+          document.removeEventListener("readystatechange", readystatechanged);
+          _requestResizeNotifications();
+        }
+      );
+    } else {
+      this._findParent();
+      if (!this._parentResizable) {
+        ORPHANS.forEach(function(orphan) {
+          if (orphan !== this) {
+            orphan._findParent();
+          }
+        }, this);
+        window.addEventListener("resize", this._boundNotifyResize);
+        this.notifyResize();
+      } else {
+        this._parentResizable._interestedResizables.forEach(function(resizable) {
+          if (resizable !== this) {
+            resizable._findParent();
+          }
+        }, this);
+      }
+    }
+  },
+  _findParent: function() {
+    this.assignParentResizable(null);
+    this.fire(
+      "iron-request-resize-notifications",
+      null,
+      { node: this, bubbles: true, cancelable: true }
+    );
+    if (!this._parentResizable) {
+      ORPHANS.add(this);
+    } else {
+      ORPHANS.delete(this);
+    }
+  }
+};
+export {
+  IronResizableBehavior
+};
+//# sourceMappingURL=@polymer_iron-resizable-behavior_iron-resizable-behavior__js.js.map