From 77eb824f1c691744cda5eece74a397f00e97c561 Mon Sep 17 00:00:00 2001
From: Marcin Lulek <info@webreactor.eu>
Date: Sat, 11 Mar 2017 02:06:28 +0100
Subject: [PATCH] polymer: add missing files

---
 .../polymer/lib/elements/array-selector.html  |  404 +++
 .../polymer/lib/elements/custom-style.html    |   73 +
 .../polymer/lib/elements/dom-bind.html        |  109 +
 .../polymer/lib/elements/dom-if.html          |  265 ++
 .../polymer/lib/elements/dom-module.html      |  136 +
 .../polymer/lib/elements/dom-repeat.html      |  683 +++++
 .../polymer/lib/legacy/class.html             |  339 +++
 .../lib/legacy/legacy-element-mixin.html      |  918 +++++++
 .../lib/legacy/mutable-data-behavior.html     |  150 ++
 .../polymer/lib/legacy/polymer-fn.html        |   47 +
 .../polymer/lib/legacy/polymer.dom.html       |  334 +++
 .../lib/legacy/templatizer-behavior.html      |  136 +
 .../polymer/lib/mixins/element-mixin.html     |  806 ++++++
 .../lib/mixins/gesture-event-listeners.html   |   57 +
 .../polymer/lib/mixins/mutable-data.html      |  180 ++
 .../lib/mixins/property-accessors.html        |  494 ++++
 .../polymer/lib/mixins/property-effects.html  | 2204 +++++++++++++++++
 .../polymer/lib/mixins/template-stamp.html    |  543 ++++
 .../polymer/lib/utils/array-splice.html       |  296 +++
 .../polymer/lib/utils/async.html              |  202 ++
 .../polymer/lib/utils/boot.html               |   51 +
 .../polymer/lib/utils/case-map.html           |   64 +
 .../polymer/lib/utils/debounce.html           |   91 +
 .../lib/utils/flattened-nodes-observer.html   |  242 ++
 .../polymer/lib/utils/flush.html              |   60 +
 .../polymer/lib/utils/gestures.html           |  822 ++++++
 .../polymer/lib/utils/import-href.html        |  108 +
 .../polymer/lib/utils/mixin.html              |   75 +
 .../polymer/lib/utils/path.html               |  270 ++
 .../polymer/lib/utils/render-status.html      |  120 +
 .../polymer/lib/utils/resolve-url.html        |  108 +
 .../polymer/lib/utils/style-gather.html       |  145 ++
 .../polymer/lib/utils/templatize.html         |  458 ++++
 .../polymer/lib/utils/unresolved.html         |   31 +
 .../entrypoints/webcomponents-ce-es5-index.js |   23 +
 .../webcomponents-hi-ce-es5-index.js          |   21 +
 .../webcomponentsjs/webcomponents-ce-es5.js   |   18 +
 .../webcomponents-es5-loader.js               |   52 +
 .../webcomponents-hi-ce-es5.js                |   16 +
 39 files changed, 11151 insertions(+)
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/array-selector.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/custom-style.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/dom-bind.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/dom-if.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/dom-module.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/elements/dom-repeat.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/class.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/legacy-element-mixin.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/mutable-data-behavior.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/polymer-fn.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/polymer.dom.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/legacy/templatizer-behavior.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/element-mixin.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/gesture-event-listeners.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/mutable-data.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/property-accessors.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/property-effects.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/mixins/template-stamp.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/array-splice.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/async.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/boot.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/case-map.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/debounce.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/flattened-nodes-observer.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/flush.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/gestures.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/import-href.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/mixin.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/path.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/render-status.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/resolve-url.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/style-gather.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/templatize.html
 create mode 100644 lib/polymer2/bower_components/polymer/lib/utils/unresolved.html
 create mode 100644 lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-ce-es5-index.js
 create mode 100644 lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-hi-ce-es5-index.js
 create mode 100644 lib/polymer2/bower_components/webcomponentsjs/webcomponents-ce-es5.js
 create mode 100644 lib/polymer2/bower_components/webcomponentsjs/webcomponents-es5-loader.js
 create mode 100644 lib/polymer2/bower_components/webcomponentsjs/webcomponents-hi-ce-es5.js

diff --git a/lib/polymer2/bower_components/polymer/lib/elements/array-selector.html b/lib/polymer2/bower_components/polymer/lib/elements/array-selector.html
new file mode 100644
index 00000000..5cf7c3c8
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/array-selector.html
@@ -0,0 +1,404 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../../polymer-element.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/array-splice.html">
+
+<script>
+(function() {
+  'use strict';
+
+  /**
+   * Element mixin for recording  dynamic associations between item paths in a
+   * master `items` array and a `selected` array such that path changes to the
+   * master array (at the host) element or elsewhere via data-binding) are
+   * correctly propagated to items in the selected array and vice-versa.
+   *
+   * The `items` property accepts an array of user data, and via the
+   * `select(item)` and `deselect(item)` API, updates the `selected` property
+   * which may be bound to other parts of the application, and any changes to
+   * sub-fields of `selected` item(s) will be kept in sync with items in the
+   * `items` array.  When `multi` is false, `selected` is a property
+   * representing the last selected item.  When `multi` is true, `selected`
+   * is an array of multiply selected items.
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   */
+  let ArraySelectorMixin = Polymer.dedupingMixin(superClass => {
+
+    return class extends superClass {
+
+      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.
+           */
+          selected: {
+            type: Object,
+            notify: true
+          },
+
+          /**
+           * When `multi` is false, this is the currently selected item, or `null`
+           * if no item is selected.
+           */
+          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 == 'items') {
+          // Case 1 - items array changed, so diff against previous array and
+          // deselect any removed items and adjust selected indices
+          let newItems = itemsInfo.base || [];
+          let lastItems = this.__lastItems;
+          let lastMulti = this.__lastMulti;
+          if (multi !== lastMulti) {
+            this.clearSelection();
+          }
+          if (lastItems) {
+            let splices = Polymer.ArraySplice.calculateSplices(newItems, lastItems);
+            this.__applySplices(splices);
+          }
+          this.__lastItems = newItems;
+          this.__lastMulti = multi;
+        } else if (itemsInfo.path == 'items.splices') {
+          // Case 2 - got specific splice information describing the array mutation:
+          // deselect any removed items and adjust selected indices
+          this.__applySplices(itemsInfo.value.indexSplices);
+        } else {
+          // Case 3 - an array element was changed, so deselect the previous
+          // item for that index if it was previously selected
+          let part = path.slice('items.'.length);
+          let idx = parseInt(part, 10);
+          if ((part.indexOf('.') < 0) && part == idx) {
+            this.__deselectChangedIdx(idx);
+          }
+        }
+      }
+
+      __applySplices(splices) {
+        let selected = this.__selectedMap;
+        // Adjust selected indices and mark removals
+        for (let i=0; i<splices.length; i++) {
+          let s = splices[i];
+          selected.forEach((idx, item) => {
+            if (idx < s.index) {
+              // no change
+            } else if (idx >= s.index + s.removed.length) {
+              // adjust index
+              selected.set(item, idx + s.addedCount - s.removed.length);
+            } else {
+              // remove index
+              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);
+            }
+          }
+        }
+        // Update linked paths
+        this.__updateLinks();
+        // Remove selected items that were removed from the items array
+        let sidx = 0;
+        selected.forEach((idx, item) => {
+          if (idx < 0) {
+            if (this.multi) {
+              this.splice('selected', 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('items.' + idx, 'selected.' + sidx++);
+            }
+          });
+        } else {
+          this.__selectedMap.forEach(idx => {
+            this.linkPaths('selected', 'items.' + idx);
+            this.linkPaths('selectedItem', 'items.' + idx);
+          });
+        }
+      }
+
+      /**
+       * Clears the selection state.
+       *
+       * @method clearSelection
+       */
+      clearSelection() {
+        // Unbind previous selection
+        this.__dataLinkedPaths = {};
+        // The selected map stores 3 pieces of information:
+        // key: items array object
+        // value: items array index
+        // order: selected array index
+        this.__selectedMap = new Map();
+        // Initialize selection
+        this.selected = this.multi ? [] : null
+        this.selectedItem = null;
+      }
+
+      /**
+       * Returns whether the item is currently selected.
+       *
+       * @method isSelected
+       * @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.
+       *
+       * @method isSelected
+       * @param {*} 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((idx, item) => {
+            if (sidx == i++) {
+              this.deselect(item);
+            }
+          });
+        }
+      }
+
+      __selectedIndexForItemIndex(idx) {
+        let selected = this.__dataLinkedPaths['items.' + idx];
+        if (selected) {
+          return parseInt(selected.slice('selected.'.length), 10);
+        }
+      }
+
+      /**
+       * Deselects the given item if it is already selected.
+       *
+       * @method deselect
+       * @param {*} item Item from `items` array to deselect
+       */
+      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('selected', sidx, 1);
+          } else {
+            this.selected = this.selectedItem = null;
+          }
+        }
+      }
+
+      /**
+       * Deselects the given index if it is already selected.
+       *
+       * @method deselect
+       * @param {number} idx Index from `items` array to deselect
+       */
+      deselectIndex(idx) {
+        this.deselect(this.items[idx]);
+      }
+
+      /**
+       * Selects the given item.  When `toggle` is true, this will automatically
+       * deselect the item if already selected.
+       *
+       * @method select
+       * @param {*} item Item from `items` array to select
+       */
+      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.
+       *
+       * @method select
+       * @param {number} idx Index from `items` array to select
+       */
+      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('selected', item);
+          } else {
+            this.selected = this.selectedItem = item;
+          }
+        } else if (this.toggle) {
+          this.deselectIndex(idx);
+        }
+      }
+
+    }
+
+  });
+
+  // export mixin
+  Polymer.ArraySelectorMixin = ArraySelectorMixin;
+
+  /**
+   * Element implementing the `Polymer.ArraySelector` mixin, which records
+   * dynamic associations between item paths in a master `items` array and a
+   * `selected` array such that path changes to the master array (at the host)
+   * element or elsewhere via data-binding) are correctly propagated to items
+   * in the selected array and vice-versa.
+   *
+   * The `items` property accepts an array of user data, and via the
+   * `select(item)` and `deselect(item)` API, updates the `selected` property
+   * which may be bound to other parts of the application, and any changes to
+   * sub-fields of `selected` item(s) will be kept in sync with items in the
+   * `items` array.  When `multi` is false, `selected` is a property
+   * representing the last selected item.  When `multi` is true, `selected`
+   * is an array of multiply selected items.
+   *
+   * Example:
+   *
+   * ```html
+   * <dom-module id="employee-list">
+   *
+   *   <template>
+   *
+   *     <div> Employee list: </div>
+   *     <template is="dom-repeat" id="employeeList" items="{{employees}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *         <button on-click="toggleSelection">Select</button>
+   *     </template>
+   *
+   *     <array-selector id="selector" items="{{employees}}" selected="{{selected}}" multi toggle></array-selector>
+   *
+   *     <div> Selected employees: </div>
+   *     <template is="dom-repeat" items="{{selected}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *     </template>
+   *
+   *   </template>
+   *
+   * </dom-module>
+   * ```
+   *
+   * ```js
+   * Polymer({
+   *   is: 'employee-list',
+   *   ready() {
+   *     this.employees = [
+   *         {first: 'Bob', last: 'Smith'},
+   *         {first: 'Sally', last: 'Johnson'},
+   *         ...
+   *     ];
+   *   },
+   *   toggleSelection(e) {
+   *     let item = this.$.employeeList.itemForElement(e.target);
+   *     this.$.selector.select(item);
+   *   }
+   * });
+   * ```
+   *
+   * @polymerElement
+   * @extends Polymer.Element
+   * @mixes Polymer.ArraySelectorMixin
+   * @memberof Polymer
+   * @summary Custom element that links paths between an input `items` array and
+   *   an output `selected` item or array based on calls to its selection API.
+   */
+  class ArraySelector extends ArraySelectorMixin(Polymer.Element) {
+    // 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' }
+  }
+  customElements.define(ArraySelector.is, ArraySelector);
+  Polymer.ArraySelector = ArraySelector;
+
+})();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/elements/custom-style.html b/lib/polymer2/bower_components/polymer/lib/elements/custom-style.html
new file mode 100644
index 00000000..8aae908d
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/custom-style.html
@@ -0,0 +1,73 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../../../shadycss/custom-style-interface.html">
+<link rel="import" href="../utils/style-gather.html">
+<script>
+(function() {
+  'use strict';
+
+  const attr = 'include';
+
+  const CustomStyleInterface = window.ShadyCSS.CustomStyleInterface;
+
+  /**
+   * Custom element for defining styles in the main document that can take
+   * advantage of several special features of Polymer's styling system:
+   *
+   * - Document styles defined in a custom-style are shimmed to ensure they
+   *   do not leak into local DOM when running on browsers without native
+   *   Shadow DOM.
+   * - Custom properties used by Polymer's shim for cross-scope styling may
+   *   be defined in an custom-style. Use the :root selector to define custom
+   *   properties that apply to all custom elements.
+   *
+   * To use, simply wrap an inline `<style>` tag in the main document whose
+   * CSS uses these features with a `<custom-style>` element.
+   *
+   * @extends HTMLElement
+   * @memberof Polymer
+   * @summary Custom element for defining styles in the main document that can
+   *   take advantage of Polymer's style scoping and custom properties shims.
+   */
+  class CustomStyle extends HTMLElement {
+    constructor() {
+      super();
+      this._style = null;
+      CustomStyleInterface.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>`.
+     *
+     * @return {HTMLStyleElement} This element's light-DOM `<style>`
+     */
+    getStyle() {
+      if (this._style) {
+        return this._style;
+      }
+      const style = this.querySelector('style');
+      if (!style) {
+        return;
+      }
+      this._style = style;
+      const include = style.getAttribute(attr);
+      if (include) {
+        style.removeAttribute(attr);
+        style.textContent = Polymer.StyleGather.cssFromModules(include) + style.textContent;
+      }
+      return this._style;
+    }
+  }
+
+  window.customElements.define('custom-style', CustomStyle);
+  Polymer.CustomStyle = CustomStyle;
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/elements/dom-bind.html b/lib/polymer2/bower_components/polymer/lib/elements/dom-bind.html
new file mode 100644
index 00000000..d08ca0e3
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/dom-bind.html
@@ -0,0 +1,109 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../mixins/property-effects.html">
+
+<script>
+
+  (function() {
+    'use strict';
+
+    const domBindBase = Polymer.OptionalMutableData(Polymer.PropertyEffects(HTMLElement));
+
+    /**
+     * Custom element to allow using Polymer's template features (data binding,
+     * declarative event listeners, etc.) in the main document without defining
+     * a new custom element.
+     *
+     * `<template>` tags utilizing bindings may be wrapped with the `<dom-bind>`
+     * element, which will immediately stamp the wrapped template into the main
+     * document and bind elements to the `dom-bind` element itself as the
+     * binding scope.
+     *
+     * @extends HTMLElement
+     * @mixes Polymer.PropertyEffects
+     * @memberof Polymer
+     * @summary Custom element to allow using Polymer's template features (data
+     *   binding, declarative event listeners, etc.) in the main document.
+     */
+    class DomBind extends domBindBase {
+
+      static get observedAttributes() { return ['mutable-data'] }
+
+      // assumes only one observed attribute
+      attributeChangedCallback() {
+        this.mutableData = true;
+      }
+
+      connectedCallback() {
+        this.render();
+      }
+
+      disconnectedCallback() {
+        this.__removeChildren();
+      }
+
+      __insertChildren() {
+        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.
+       */
+      render() {
+        let template;
+        if (!this.__children) {
+          template = template || this.querySelector('template');
+          if (!template) {
+            // Wait until childList changes and template should be there by then
+            let observer = new MutationObserver(() => {
+              template = this.querySelector('template');
+              if (template) {
+                observer.disconnect();
+                this.render(template);
+              } else {
+                throw new Error('dom-bind requires a <template> child');
+              }
+            })
+            observer.observe(this, {childList: true});
+            return;
+          }
+          this._bindTemplate(template);
+          this.root = this._stampTemplate(template);
+          this.__children = [];
+          for (let n=this.root.firstChild; n; n=n.nextSibling) {
+            this.__children[this.__children.length] = n;
+          }
+          this._flushProperties();
+        }
+        this.__insertChildren();
+        this.dispatchEvent(new CustomEvent('dom-change', {
+          bubbles: true,
+          composed: true
+        }));
+      }
+
+    }
+
+    customElements.define('dom-bind', DomBind);
+
+  })();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/elements/dom-if.html b/lib/polymer2/bower_components/polymer/lib/elements/dom-if.html
new file mode 100644
index 00000000..842e5a65
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/dom-if.html
@@ -0,0 +1,265 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../../polymer-element.html">
+<link rel="import" href="../utils/templatize.html">
+<link rel="import" href="../utils/debounce.html">
+<link rel="import" href="../utils/flush.html">
+
+<script>
+
+(function() {
+  'use strict';
+
+  /**
+   * The `<dom-if>` element will stamp a light-dom `<template>` child when
+   * the `if` property becomes truthy, and the template can use Polymer
+   * data-binding and declarative event features when used in the context of
+   * a Polymer element's template.
+   *
+   * When `if` becomes falsey, the stamped content is hidden but not
+   * removed from dom. When `if` subsequently becomes truthy again, the content
+   * is simply re-shown. This approach is used due to its favorable performance
+   * characteristics: the expense of creating template content is paid only
+   * once and lazily.
+   *
+   * Set the `restamp` property to true to force the stamped content to be
+   * created / destroyed when the `if` condition changes.
+   *
+   * @polymerElement
+   * @extends Polymer.Element
+   * @memberof Polymer
+   * @summary Custom element that conditionally stamps and hides or removes
+   *   template content based on a boolean flag.
+   */
+  class DomIf extends Polymer.Element {
+
+    // 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'
+        }
+
+      }
+
+    }
+
+    constructor() {
+      super();
+      this.__renderDebouncer = null;
+      this.__invalidProps = null;
+      this.__instance = null;
+    }
+
+    __debounceRender() {
+      // Render is async for 2 reasons:
+      // 1. To eliminate dom creation trashing if user code thrashes `if` in the
+      //    same turn. This was more common in 1.x where a compound computed
+      //    property could result in the result changing multiple times, but is
+      //    mitigated to a large extent by batched property processing in 2.x.
+      // 2. To avoid double object propagation when a bag including values bound
+      //    to the `if` property as well as one or more hostProps could enqueue
+      //    the <dom-if> to flush before the <template>'s host property
+      //    forwarding. In that scenario creating an instance would result in
+      //    the host props being set once, and then the enqueued changes on the
+      //    template would set properties a second time, potentially causing an
+      //    object to be set to an instance more than once.  Creating the
+      //    instance async from flushing data ensures this doesn't happen. If
+      //    we wanted a sync option in the future, simply having <dom-if> flush
+      //    (or clear) its template's pending host properties before creating
+      //    the instance would also avoid the problem.
+      this.__renderDebouncer = Polymer.Debouncer.debounce(
+            this.__renderDebouncer
+          , Polymer.Async.microTask
+          , () => this.__render());
+      Polymer.enqueueDebouncer(this.__renderDebouncer);
+    }
+
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      if (!this.parentNode ||
+          (this.parentNode.nodeType == Node.DOCUMENT_FRAGMENT_NODE &&
+           !this.parentNode.host)) {
+        this.__teardownInstance();
+      }
+    }
+
+    connectedCallback() {
+      super.connectedCallback();
+      if (this.if) {
+        this.__debounceRender();
+      }
+    }
+
+    /**
+     * 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.
+     */
+    render() {
+      Polymer.flush();
+    }
+
+    __render() {
+      if (this.if) {
+        if (!this.__ensureInstance()) {
+          // No template found yet
+          return;
+        }
+        this._showHideChildren();
+      } else if (this.restamp) {
+        this.__teardownInstance();
+      }
+      if (!this.restamp && this.__instance) {
+        this._showHideChildren();
+      }
+      if (this.if != this._lastIf) {
+        this.dispatchEvent(new CustomEvent('dom-change', {
+          bubbles: true,
+          composed: true
+        }));
+        this._lastIf = this.if;
+      }
+    }
+
+    __ensureInstance() {
+      let parentNode = this.parentNode;
+      // Guard against element being detached while render was queued
+      if (parentNode) {
+        if (!this.__ctor) {
+          let template = this.querySelector('template');
+          if (!template) {
+            // Wait until childList changes and template should be there by then
+            let observer = new MutationObserver(() => {
+              if (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.__ctor = Polymer.Templatize.templatize(template, this, {
+            // dom-if templatizer instances require `mutable: true`, as
+            // `__syncHostProperties` relies on that behavior to sync objects
+            mutableData: true,
+            forwardHostProp: function(prop, value) {
+              if (this.__instance) {
+                if (this.if) {
+                  this.__instance.forwardHostProp(prop, value);
+                } else {
+                  // If we have an instance but are squelching host property
+                  // forwarding due to if being false, note the invalidated
+                  // properties so `__syncHostProperties` can sync them the next
+                  // time `if` becomes true
+                  this.__invalidProps = this.__invalidProps || Object.create(null);
+                  this.__invalidProps[Polymer.Path.root(prop)] = true;
+                }
+              }
+            }
+          });
+        }
+        if (!this.__instance) {
+          this.__instance = new this.__ctor();
+          parentNode.insertBefore(this.__instance.root, this);
+        } else {
+          this.__syncHostProperties();
+          let c$ = this.__instance.children;
+          if (c$ && c$.length) {
+            // Detect case where dom-if was re-attached in new position
+            let lastChild = this.previousSibling;
+            if (lastChild !== c$[c$.length-1]) {
+              for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
+                parentNode.insertBefore(n, this);
+              }
+            }
+          }
+        }
+      }
+      return true;
+    }
+
+    __syncHostProperties() {
+      let props = this.__invalidProps;
+      if (props) {
+        for (let prop in props) {
+          this.__instance._setPendingProperty(prop, this.__dataHost[prop]);
+        }
+        this.__invalidProps = null;
+        this.__instance._flushProperties();
+      }
+    }
+
+    __teardownInstance() {
+      if (this.__instance) {
+        let c$ = this.__instance.children;
+        if (c$ && c$.length) {
+          // use first child parent, for case when dom-if may have been detached
+          let parent = c$[0].parentNode;
+          for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
+            parent.removeChild(n);
+          }
+        }
+        this.__instance = null;
+        this.__invalidProps = null;
+      }
+    }
+
+    _showHideChildren() {
+      let hidden = this.__hideTemplateChildren__ || !this.if;
+      if (this.__instance) {
+        this.__instance._showHideChildren(hidden);
+      }
+    }
+
+  }
+
+  customElements.define(DomIf.is, DomIf);
+
+  Polymer.DomIf = DomIf;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/elements/dom-module.html b/lib/polymer2/bower_components/polymer/lib/elements/dom-module.html
new file mode 100644
index 00000000..467b8573
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/dom-module.html
@@ -0,0 +1,136 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/resolve-url.html">
+<script>
+(function() {
+  'use strict';
+
+  let modules = {};
+  let lcModules = {};
+  function findModule(id) {
+    return modules[id] || lcModules[id.toLowerCase()];
+  }
+
+  function styleOutsideTemplateCheck(inst) {
+    if (inst.querySelector('style')) {
+      console.warn('dom-module %s has style outside template', inst.id);
+    }
+  }
+
+  /**
+   * The `dom-module` element registers the dom it contains to the name given
+   * by the module's id attribute. It provides a unified database of dom
+   * accessible via its static `import` API.
+   *
+   * A key use case of `dom-module` is for providing custom element `<template>`s
+   * via HTML imports that are parsed by the native HTML parser, that can be
+   * relocated during a bundling pass and still looked up by `id`.
+   *
+   * Example:
+   *
+   *     <dom-module id="foo">
+   *       <img src="stuff.png">
+   *     </dom-module>
+   *
+   * Then in code in some other location that cannot access the dom-module above
+   *
+   *     let img = document.createElement('dom-module').import('foo', 'img');
+   *
+   * @extends HTMLElement
+   * @memberof Polymer
+   * @summary Custom element that provides a registry of relocatable DOM content
+   *   by `id` that is agnostic to bundling.
+   */
+  class DomModule extends HTMLElement {
+
+    static get observedAttributes() { return ['id'] }
+
+    /**
+     * Retrieves the dom specified by `selector` in the module specified by
+     * `id`. For example, this.import('foo', 'img');
+     * @method register
+     * @param {string} id
+     * @param {string=} selector
+     * @return {Element} Returns the dom which matches `selector` in the module
+     * at the specified `id`.
+     */
+    static import(id, selector) {
+      if (id) {
+        let m = findModule(id);
+        if (m && selector) {
+          return m.querySelector(selector);
+        }
+        return m;
+      }
+      return null;
+    }
+
+    attributeChangedCallback(name, old, value) {
+      if (old !== value) {
+        this.register();
+      }
+    }
+
+    /**
+     * The absolute URL of the original location of this `dom-module`.
+     *
+     * This value will differ from this element's `ownerDocument` in the
+     * following ways:
+     * - Takes into account any `assetpath` attribute added during bundling
+     *   to indicate the original location relative to the bundled location
+     * - Uses the HTMLImports polyfill's `importForElement` API to ensure
+     *   the path is relative to the import document's location since
+     *   `ownerDocument` is not currently polyfilled
+     */
+    get assetpath() {
+      // Don't override existing assetpath.
+      if (!this.__assetpath) {
+        // note: assetpath set via an attribute must be relative to this
+        // element's location; accomodate polyfilled HTMLImports
+        const owner = window.HTMLImports && HTMLImports.importForElement ?
+          HTMLImports.importForElement(this) || document : this.ownerDocument;
+        const url = Polymer.ResolveUrl.resolveUrl(
+          this.getAttribute('assetpath') || '', owner.baseURI);
+        this.__assetpath = Polymer.ResolveUrl.pathFromUrl(url);
+      }
+      return this.__assetpath;
+    }
+
+    /**
+     * Registers the dom-module at a given id. This method should only be called
+     * when a dom-module is imperatively created. For
+     * example, `document.createElement('dom-module').register('foo')`.
+     * @method register
+     * @param {string=} id The id at which to register the dom-module.
+     */
+    register(id) {
+      id = id || this.id;
+      if (id) {
+        this.id = id;
+        // store id separate from lowercased id so that
+        // in all cases mixedCase id will stored distinctly
+        // and lowercase version is a fallback
+        modules[id] = this;
+        lcModules[id.toLowerCase()] = this;
+        styleOutsideTemplateCheck(this);
+      }
+    }
+  }
+
+  DomModule.prototype['modules'] = modules;
+
+  customElements.define('dom-module', DomModule);
+
+  // export
+  Polymer.DomModule = DomModule;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/elements/dom-repeat.html b/lib/polymer2/bower_components/polymer/lib/elements/dom-repeat.html
new file mode 100644
index 00000000..0b7ee3f5
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/elements/dom-repeat.html
@@ -0,0 +1,683 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../../polymer-element.html">
+<link rel="import" href="../utils/templatize.html">
+<link rel="import" href="../utils/debounce.html">
+<link rel="import" href="../utils/flush.html">
+<link rel="import" href="../mixins/mutable-data.html">
+
+<script>
+(function() {
+  'use strict';
+
+  /**
+   * The `<dom-repeat>` element will automatically stamp and binds one instance
+   * of template content to each object in a user-provided array.
+   * `dom-repeat` accepts an `items` property, and one instance of the template
+   * is stamped for each item into the DOM at the location of the `dom-repeat`
+   * element.  The `item` property will be set on each instance's binding
+   * scope, thus templates should bind to sub-properties of `item`.
+   *
+   * Example:
+   *
+   * ```html
+   * <dom-module id="employee-list">
+   *
+   *   <template>
+   *
+   *     <div> Employee list: </div>
+   *     <template is="dom-repeat" items="{{employees}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *     </template>
+   *
+   *   </template>
+   *
+   *   <script>
+   *     Polymer({
+   *       is: 'employee-list',
+   *       ready: function() {
+   *         this.employees = [
+   *             {first: 'Bob', last: 'Smith'},
+   *             {first: 'Sally', last: 'Johnson'},
+   *             ...
+   *         ];
+   *       }
+   *     });
+   *   < /script>
+   *
+   * </dom-module>
+   * ```
+   *
+   * Notifications for changes to items sub-properties will be forwarded to template
+   * instances, which will update via the normal structured data notification system.
+   *
+   * Mutations to the `items` array itself should me made using the Array
+   * mutation API's on `Polymer.Base` (`push`, `pop`, `splice`, `shift`,
+   * `unshift`), and template instances will be kept in sync with the data in the
+   * array.
+   *
+   * Events caught by event handlers within the `dom-repeat` template will be
+   * decorated with a `model` property, which represents the binding scope for
+   * each template instance.  The model is an instance of Polymer.Base, and should
+   * be used to manipulate data on the instance, for example
+   * `event.model.set('item.checked', true);`.
+   *
+   * Alternatively, the model for a template instance for an element stamped by
+   * a `dom-repeat` can be obtained using the `modelForElement` API on the
+   * `dom-repeat` that stamped it, for example
+   * `this.$.domRepeat.modelForElement(event.target).set('item.checked', true);`.
+   * This may be useful for manipulating instance data of event targets obtained
+   * by event handlers on parents of the `dom-repeat` (event delegation).
+   *
+   * A view-specific filter/sort may be applied to each `dom-repeat` by supplying a
+   * `filter` and/or `sort` property.  This may be a string that names a function on
+   * the host, or a function may be assigned to the property directly.  The functions
+   * should implemented following the standard `Array` filter/sort API.
+   *
+   * In order to re-run the filter or sort functions based on changes to sub-fields
+   * of `items`, the `observe` property may be set as a space-separated list of
+   * `item` sub-fields that should cause a re-filter/sort when modified.  If
+   * the filter or sort function depends on properties not contained in `items`,
+   * the user should observe changes to those properties and call `render` to update
+   * the view based on the dependency change.
+   *
+   * For example, for an `dom-repeat` with a filter of the following:
+   *
+   * ```js
+   * isEngineer: function(item) {
+   *     return item.type == 'engineer' || item.manager.type == 'engineer';
+   * }
+   * ```
+   *
+   * Then the `observe` property should be configured as follows:
+   *
+   * ```html
+   * <template is="dom-repeat" items="{{employees}}"
+   *           filter="isEngineer" observe="type manager.type">
+   * ```
+   *
+   * @polymerElement
+   * @memberof Polymer
+   * @extends Polymer.Element
+   * @mixes Polymer.MutableData
+   * @summary Custom element for stamping instance of a template bound to
+   *   items in an array.
+   */
+  class DomRepeat extends Polymer.OptionalMutableData(Polymer.Element) {
+
+    // 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() {
+
+      /**
+       * Fired whenever DOM is added or removed by this template (by
+       * default, rendering occurs lazily).  To force immediate rendering, call
+       * `render`.
+       *
+       * @event dom-change
+       */
+      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
+         * for the inst.  If `sort` is provided, the index will reflect the
+         * sorted order (rather than the original array order).
+         */
+        indexAs: {
+          type: String,
+          value: 'index'
+        },
+
+        /**
+         * The name of the variable to add to the binding scope with the index
+         * for the inst.  If `sort` is provided, the index will reflect the
+         * sorted order (rather than the original array order).
+         */
+        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 after a change to observed item
+         * properties that must pass before the filter or sort is re-run.
+         * This is useful in rate-limiting shuffing 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: true,
+          readOnly: true
+        },
+
+        /**
+         * 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 will be created and rendered
+         * incrementally at each animation frame therof until all instances have
+         * been rendered.
+         */
+        initialCount: {
+          type: Number,
+          observer: '__initializeChunking'
+        },
+
+        /**
+         * When `initialCount` is used, this property defines a frame rate to
+         * target by throttling the number of instances rendered each frame to
+         * not exceed the budget for the target frame rate.  Setting this to a
+         * higher number will allow lower latency and higher throughput for
+         * things like event handlers, but will result in a longer time for the
+         * remaining items to complete rendering.
+         */
+        targetFramerate: {
+          type: Number,
+          value: 20
+        },
+
+        _targetFrameTime: {
+          type: Number,
+          computed: '__computeFrameTime(targetFramerate)'
+        }
+
+      }
+
+    }
+
+    static get observers() {
+      return [ '__itemsChanged(items.*)' ]
+    }
+
+    constructor() {
+      super();
+      this.__instances = [];
+      this.__limit = Infinity;
+      this.__pool = [];
+      this.__renderDebouncer = null;
+      this.__itemsIdxToInstIdx = {};
+      this.__chunkCount = null;
+      this.__lastChunkTime = null;
+      this.__needFullRefresh = false;
+      this.__sortFn = null;
+      this.__filterFn = null;
+      this.__observePaths = null;
+      this.__ctor = null;
+    }
+
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this.__isDetached = true;
+      for (let i=0; i<this.__instances.length; i++) {
+        this.__detachInstance(i);
+      }
+    }
+
+    connectedCallback() {
+      super.connectedCallback();
+      // only perform attachment if the element was previously detached.
+      if (this.__isDetached) {
+        this.__isDetached = false;
+        let parent = this.parentNode;
+        for (let i=0; i<this.__instances.length; i++) {
+          this.__attachInstance(i, parent);
+        }
+      }
+    }
+
+    __ensureTemplatized() {
+      // Templatizing (generating the instance constructor) needs to wait
+      // until ready, since won't have its template content handed back to
+      // it until then
+      if (!this.__ctor) {
+        let template = this.template = this.querySelector('template');
+        if (!template) {
+          // // Wait until childList changes and template should be there by then
+          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;
+        }
+        // Template instance props that should be excluded from forwarding
+        let instanceProps = {};
+        instanceProps[this.as] = true;
+        instanceProps[this.indexAs] = true;
+        instanceProps[this.itemsIndexAs] = true;
+        this.__ctor = Polymer.Templatize.templatize(template, this, {
+          mutableData: this.mutableData,
+          parentModel: true,
+          instanceProps: instanceProps,
+          forwardHostProp: function(prop, value) {
+            let i$ = this.__instances;
+            for (let i=0, inst; (i<i$.length) && (inst=i$[i]); i++) {
+              inst.forwardHostProp(prop, value);
+            }
+          },
+          notifyInstanceProp: function(inst, prop, value) {
+            if (Polymer.Path.matches(this.as, prop)) {
+              let idx = inst[this.itemsIndexAs];
+              if (prop == this.as) {
+                this.items[idx] = value;
+              }
+              let path = Polymer.Path.translate(this.as, 'items.' + idx, prop);
+              this.notifyPath(path, value);
+            }
+          }
+        });
+      }
+      return true;
+    }
+
+    __getMethodHost() {
+      // Technically this should be the owner of the outermost template.
+      // In shadow dom, this is always getRootNode().host, but we can
+      // approximate this via cooperation with our dataHost always setting
+      // `_methodHost` as long as there were bindings (or id's) on this
+      // instance causing it to get a dataHost.
+      return this.__dataHost._methodHost || this.__dataHost;
+    }
+
+    __sortChanged(sort) {
+      let methodHost = this.__getMethodHost();
+      this.__sortFn = sort && (typeof sort == 'function' ? sort :
+        function() { return methodHost[sort].apply(methodHost, arguments); });
+      this.__needFullRefresh = true;
+      if (this.items) {
+        this.__debounceRender(this.__render);
+      }
+    }
+
+    __filterChanged(filter) {
+      let methodHost = this.__getMethodHost();
+      this.__filterFn = filter && (typeof filter == 'function' ? filter :
+        function() { return methodHost[filter].apply(methodHost, arguments); });
+      this.__needFullRefresh = true;
+      if (this.items) {
+        this.__debounceRender(this.__render);
+      }
+    }
+
+    __computeFrameTime(rate) {
+      return Math.ceil(1000/rate);
+    }
+
+    __initializeChunking() {
+      if (this.initialCount) {
+        this.__limit = this.initialCount;
+        this.__chunkCount = this.initialCount;
+        this.__lastChunkTime = performance.now();
+      }
+    }
+
+    __tryRenderChunk() {
+      // Debounced so that multiple calls through `_render` between animation
+      // frames only queue one new rAF (e.g. array mutation & chunked render)
+      if (this.items && this.__limit < this.items.length) {
+        this.__debounceRender(this.__requestRenderChunk);
+      }
+    }
+
+    __requestRenderChunk() {
+      requestAnimationFrame(()=>this.__renderChunk());
+    }
+
+    __renderChunk() {
+      // Simple auto chunkSize throttling algorithm based on feedback loop:
+      // measure actual time between frames and scale chunk count by ratio
+      // of target/actual frame time
+      let currChunkTime = performance.now();
+      let ratio = this._targetFrameTime / (currChunkTime - this.__lastChunkTime);
+      this.__chunkCount = Math.round(this.__chunkCount * ratio) || 1;
+      this.__limit += this.__chunkCount;
+      this.__lastChunkTime = currChunkTime;
+      this.__debounceRender(this.__render);
+    }
+
+    __observeChanged() {
+      this.__observePaths = this.observe &&
+        this.observe.replace('.*', '.').split(' ');
+    }
+
+    __itemsChanged(change) {
+      if (this.items && !Array.isArray(this.items)) {
+        console.warn('dom-repeat expected array for `items`, found', this.items);
+      }
+      // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
+      // path to that instance synchronously (retuns false for non-item paths)
+      if (!this.__handleItemPath(change.path, change.value)) {
+        // Otherwise, the array was reset ('items') or spliced ('items.splices'),
+        // so queue a full refresh
+        this.__needFullRefresh = true;
+        this.__initializeChunking();
+        this.__debounceRender(this.__render);
+      }
+    }
+
+    __handleObservedPaths(path) {
+      if (this.__observePaths) {
+        path = path.substring(path.indexOf('.') + 1);
+        let paths = this.__observePaths;
+        for (let i=0; i<paths.length; i++) {
+          if (path.indexOf(paths[i]) === 0) {
+            this.__needFullRefresh = true;
+            this.__debounceRender(this.__render, this.delay);
+            return true;
+          }
+        }
+      }
+    }
+
+    /**
+     * @param {function()} fn
+     * @param {number=} delay
+     */
+    __debounceRender(fn, delay) {
+      this.__renderDebouncer = Polymer.Debouncer.debounce(
+            this.__renderDebouncer
+          , delay > 0 ? Polymer.Async.timeOut.after(delay) : Polymer.Async.microTask
+          , fn.bind(this));
+      Polymer.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.
+     */
+    render() {
+      // Queue this repeater, then flush all in order
+      this.__needFullRefresh = true;
+      this.__debounceRender(this.__render);
+      Polymer.flush();
+    }
+
+    __render() {
+      if (!this.__ensureTemplatized()) {
+        // No template found yet
+        return;
+      }
+      this.__applyFullRefresh();
+      // Reset the pool
+      // TODO(kschaaf): Reuse pool across turns and nested templates
+      // Now that objects/arrays are re-evaluated when set, we can safely
+      // reuse pooled instances across turns, however we still need to decide
+      // semantics regarding how long to hold, how many to hold, etc.
+      this.__pool.length = 0;
+      // Set rendered item count
+      this._setRenderedItemCount(this.__instances.length);
+      // Notify users
+      this.dispatchEvent(new CustomEvent('dom-change', {
+        bubbles: true,
+        composed: true
+      }));
+      // Check to see if we need to render more items
+      this.__tryRenderChunk();
+    }
+
+    __applyFullRefresh() {
+      const items = this.items || [];
+      let isntIdxToItemsIdx = new Array(items.length);
+      for (let i=0; i<items.length; i++) {
+        isntIdxToItemsIdx[i] = i;
+      }
+      // Apply user filter
+      if (this.__filterFn) {
+        isntIdxToItemsIdx = isntIdxToItemsIdx.filter((i, idx, array) =>
+          this.__filterFn(items[i], idx, array));
+      }
+      // Apply user sort
+      if (this.__sortFn) {
+        isntIdxToItemsIdx.sort((a, b) => this.__sortFn(items[a], items[b]));
+      }
+      // items->inst map kept for item path forwarding
+      const itemsIdxToInstIdx = this.__itemsIdxToInstIdx = {};
+      let instIdx = 0;
+      // Generate instances and assign items
+      const limit = Math.min(isntIdxToItemsIdx.length, this.__limit);
+      for (; instIdx<limit; instIdx++) {
+        let inst = this.__instances[instIdx];
+        let itemIdx = isntIdxToItemsIdx[instIdx];
+        let item = items[itemIdx];
+        itemsIdxToInstIdx[itemIdx] = instIdx;
+        if (inst && instIdx < this.__limit) {
+          inst._setPendingProperty(this.as, item);
+          inst._setPendingProperty(this.indexAs, instIdx);
+          inst._setPendingProperty(this.itemsIndexAs, itemIdx);
+          inst._flushProperties();
+        } else {
+          this.__insertInstance(item, instIdx, itemIdx);
+        }
+      }
+      // Remove any extra instances from previous state
+      for (let i=this.__instances.length-1; i>=instIdx; i--) {
+        this.__detachAndRemoveInstance(i);
+      }
+    }
+
+    __detachInstance(idx) {
+      let inst = this.__instances[idx];
+      for (let i=0; i<inst.children.length; i++) {
+        let el = inst.children[i];
+        inst.root.appendChild(el);
+      }
+      return inst;
+    }
+
+    __attachInstance(idx, parent) {
+      let inst = this.__instances[idx];
+      parent.insertBefore(inst.root, this);
+    }
+
+    __detachAndRemoveInstance(idx) {
+      let inst = this.__detachInstance(idx);
+      if (inst) {
+        this.__pool.push(inst);
+      }
+      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) {
+      let inst = this.__pool.pop();
+      if (inst) {
+        // TODO(kschaaf): If the pool is shared across turns, hostProps
+        // need to be re-set to reused instances in addition to item
+        inst._setPendingProperty(this.as, item);
+        inst._setPendingProperty(this.indexAs, instIdx);
+        inst._setPendingProperty(this.itemsIndexAs, itemIdx);
+        inst._flushProperties();
+      } else {
+        inst = this.__stampInstance(item, instIdx, itemIdx);
+      }
+      let beforeRow = this.__instances[instIdx + 1];
+      let beforeNode = beforeRow ? beforeRow.children[0] : this;
+      this.parentNode.insertBefore(inst.root, beforeNode);
+      this.__instances[instIdx] = inst;
+      return inst;
+    }
+
+    // Implements extension point from Templatize mixin
+    _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); // 'items.'.length == 6
+      let dot = itemsPath.indexOf('.');
+      let itemsIdx = dot < 0 ? itemsPath : itemsPath.substring(0, dot);
+      // If path was index into array...
+      if (itemsIdx == parseInt(itemsIdx, 10)) {
+        let itemSubPath = dot < 0 ? '' : itemsPath.substring(dot+1);
+        // See if the item subpath should trigger a full refresh...
+        if (!this.__handleObservedPaths(itemSubPath)) {
+          // If not, forward to the instance for that index
+          let instIdx = this.__itemsIdxToInstIdx[itemsIdx];
+          let inst = this.__instances[instIdx];
+          if (inst) {
+            let itemPath = this.as + (itemSubPath ? '.' + itemSubPath : '');
+            // This is effectively `notifyPath`, but avoids some of the overhead
+            // of the public API
+            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.
+     *
+     * @method itemForElement
+     * @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).
+     *
+     * @method indexForElement
+     * @param {HTMLElement} el Element for which to return the index.
+     * @return {*} 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 is an instance of `Polymer.Base`, and
+     * 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);
+     *   }
+     *
+     * @method modelForElement
+     * @param {HTMLElement} el Element for which to return a template model.
+     * @return {TemplateInstanceBase} Model representing the binding scope for
+     *   the element.
+     */
+    modelForElement(el) {
+      return Polymer.Templatize.modelForElement(this.template, el);
+    }
+
+  }
+
+  customElements.define(DomRepeat.is, DomRepeat);
+
+  Polymer.DomRepeat = DomRepeat;
+
+})();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/class.html b/lib/polymer2/bower_components/polymer/lib/legacy/class.html
new file mode 100644
index 00000000..7411d4bb
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/class.html
@@ -0,0 +1,339 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="legacy-element-mixin.html">
+<script>
+
+  (function() {
+
+    'use strict';
+
+    let LegacyElementMixin = Polymer.LegacyElementMixin;
+
+    let metaProps = {
+      attached: true,
+      detached: true,
+      ready: true,
+      created: true,
+      beforeRegister: true,
+      registered: true,
+      attributeChanged: true,
+      // meta objects
+      behaviors: true,
+      hostAttributes: true,
+      properties: true,
+      observers: true,
+      listeners: true
+    }
+
+    /**
+     * Applies a "legacy" behavior or array of behaviors to the provided class.
+     *
+     * Note: this method will automatically also apply the `Polymer.LegacyElementMixin`
+     * to ensure that any legacy behaviors can rely on legacy Polymer API on
+     * the underlying element.
+     *
+     * @param {Object|Array} behaviors Behavior object or array of behaviors
+     * @param {HTMLElement} klass Element class
+     * @memberof Polymer
+     */
+    function mixinBehaviors(behaviors, klass) {
+      if (!behaviors) {
+        return klass;
+      }
+      // NOTE: ensure the bahevior is extending a class with
+      // legacy element api. This is necessary since behaviors expect to be able
+      // to access 1.x legacy api.
+      klass = LegacyElementMixin(klass);
+      if (!Array.isArray(behaviors)) {
+        behaviors = [behaviors];
+      }
+      let superBehaviors = klass.behaviors;
+      // get flattened, deduped list of behaviors *not* already on super class
+      behaviors = flattenBehaviors(behaviors, null, superBehaviors);
+      // mixin new behaviors
+      klass = _mixinBehaviors(behaviors, klass);
+      if (superBehaviors) {
+        behaviors = superBehaviors.concat(behaviors);
+      }
+      klass.behaviors = behaviors;
+      return klass;
+    }
+
+    // NOTE:
+    // 1.x
+    // Behaviors were mixed in *in reverse order* and de-duped on the fly.
+    // The rule was that behavior properties were copied onto the element
+    // prototype if and only if the property did not already exist.
+    // Given: Polymer{ behaviors: [A, B, C, A, B]}, property copy order was:
+    // (1), B, (2), A, (3) C. This means prototype properties win over
+    // B properties win over A win over C. This mirrors what would happen
+    // with inheritance if element extended B extended A extended C.
+    //
+    // Again given, Polymer{ behaviors: [A, B, C, A, B]}, the resulting
+    // `behaviors` array was [C, A, B].
+    // Behavior lifecycle methods were called in behavior array order
+    // followed by the element, e.g. (1) C.created, (2) A.created,
+    // (3) B.created, (4) element.created. There was no support for
+    // super, and "super-behavior" methods were callable only by name).
+    //
+    // 2.x
+    // Behaviors are made into proper mixins which live in the
+    // element's prototype chain. Behaviors are placed in the element prototype
+    // eldest to youngest and de-duped youngest to oldest:
+    // So, first [A, B, C, A, B] becomes [C, A, B] then,
+    // the element prototype becomes (oldest) (1) Polymer.Element, (2) class(C),
+    // (3) class(A), (4) class(B), (5) class(Polymer({...})).
+    // Result:
+    // This means element properties win over B properties win over A win
+    // over C. (same as 1.x)
+    // If lifecycle is called (super then me), order is
+    // (1) C.created, (2) A.created, (3) B.created, (4) element.created
+    // (again same as 1.x)
+    function _mixinBehaviors(behaviors, klass) {
+      for (let i=0; i<behaviors.length; i++) {
+        let b = behaviors[i];
+        if (b) {
+          klass = Array.isArray(b) ? _mixinBehaviors(b, klass) :
+            GenerateClassFromInfo(b, klass);
+        }
+      }
+      return klass;
+    }
+
+    /**
+     * @param {Array} behaviors
+     * @param {Array=} list
+     * @param {Array=} exclude
+     */
+    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 {
+            // dedup
+            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 GenerateClassFromInfo(info, Base) {
+
+      let registered = false;
+
+      class PolymerGenerated extends Base {
+
+        static get properties() {
+          return info.properties;
+        }
+
+        static get observers() {
+          return info.observers;
+        }
+
+        static get template() {
+          // get template first from any imperative set in `info._template`
+          return info._template ||
+            // next look in dom-module associated with this element's is.
+            Polymer.DomModule.import(this.is, 'template') ||
+            // next look for superclass template (note: use superclass symbol
+            // to ensure correct `this.is`)
+            Base.template ||
+            // finally fall back to `_template` in element's protoype.
+            this.prototype._template;
+        }
+
+        created() {
+          super.created();
+          if (info.created) {
+            info.created.call(this);
+          }
+        }
+
+        _registered() {
+          if (!registered) {
+            super._registered();
+            // call `registered` only if it was not called for *this* constructor
+            registered = true;
+            if (info.registered) {
+              info.registered.call(Object.getPrototypeOf(this));
+            }
+          }
+        }
+
+        _applyListeners() {
+          super._applyListeners();
+          if (info.listeners) {
+            for (let l in info.listeners) {
+              this._addMethodEventListenerToNode(this, l, info.listeners[l]);
+            }
+          }
+        }
+
+        // note: exception to "super then me" rule;
+        // do work before calling super so that super attributes
+        // only apply if not already set.
+        _ensureAttributes() {
+          if (info.hostAttributes) {
+            for (let a in info.hostAttributes) {
+              this._ensureAttribute(a, info.hostAttributes[a]);
+            }
+          }
+          super._ensureAttributes();
+        }
+
+        ready() {
+          super.ready();
+          if (info.ready) {
+            info.ready.call(this);
+          }
+        }
+
+        attached() {
+          super.attached();
+          if (info.attached) {
+            info.attached.call(this);
+          }
+        }
+
+        detached() {
+          super.detached();
+          if (info.detached) {
+            info.detached.call(this);
+          }
+        }
+
+        attributeChanged(name, old, value) {
+          super.attributeChanged(name, old, value);
+          if (info.attributeChanged) {
+            info.attributeChanged.call(this, name, old, value);
+          }
+       }
+      }
+
+      PolymerGenerated.generatedFrom =  info
+
+      for (let p in info) {
+        // NOTE: cannot copy `metaProps` methods onto prototype at least because
+        // `super.ready` must be called and is not included in the user fn.
+        if (!(p in metaProps)) {
+          let pd = Object.getOwnPropertyDescriptor(info, p);
+          if (pd) {
+            Object.defineProperty(PolymerGenerated.prototype, p, pd);
+          }
+        }
+      }
+
+      return PolymerGenerated;
+    }
+
+    /**
+     * Generates a class that extends `Polymer.LegacyElement` based on the
+     * provided info object.  Metadata objects on the `info` object
+     * (`properties`, `observers`, `listeners`, `behaviors`, `is`) are used
+     * for Polymer's meta-programming systems, and any functions are copied
+     * to the generated class.
+     *
+     * Valid "metadata" values are as follows:
+     *
+     * `is`: String providing the tag name to register the element under. In
+     * addition, if a `dom-module` with the same id exists, the first template
+     * in that `dom-module` will be stamped into the shadow root of this element,
+     * with support for declarative event listeners (`on-...`), Polymer data
+     * bindings (`[[...]]` and `{{...}}`), and id-based node finding into
+     * `this.$`.
+     *
+     * `properties`: Object describing property-related metadata used by Polymer
+     * features (key: property names, value: object containing property metadata).
+     * Valid keys in per-property metadata include:
+     * - `type` (String|Number|Object|Array|...): Used by
+     *   `attributeChangedCallback` to determine how string-based attributes
+     *   are deserialized to JavaScript property values.
+     * - `notify` (boolean): Causes a change in the property to fire a
+     *   non-bubbling event called `<property>-changed`. Elements that have
+     *   enabled two-way binding to the property use this event to observe changes.
+     * - `readOnly` (boolean): Creates a getter for the property, but no setter.
+     *   To set a read-only property, use the private setter method
+     *   `_setProperty(property, value)`.
+     * - `observer` (string): Observer method name that will be called when
+     *   the property changes. The arguments of the method are
+     *   `(value, previousValue)`.
+     * - `computed` (string): String describing method and dependent properties
+     *   for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
+     *   Computed properties are read-only by default and can only be changed
+     *   via the return value of the computing method.
+     *
+     * `observers`: Array of strings describing multi-property observer methods
+     *  and their dependent properties (e.g. `'observeABC(a, b, c)'`).
+     *
+     * `listeners`: Object describing event listeners to be added to each
+     *  instance of this element (key: event name, value: method name).
+     *
+     * `behaviors`: Array of additional `info` objects containing metadata
+     * and callbacks in the same format as the `info` object here which are
+     * merged into this element.
+     *
+     * `hostAttributes`: Object listing attributes to be applied to the host
+     *  once created (key: attribute name, value: attribute value).  Values
+     *  are serialized based on the type of the value.  Host attributes should
+     *  generally be limited to attributes such as `tabIndex` and `aria-...`.
+     *  Attributes in `hostAttributes` are only applied if a user-supplied
+     *  attribute is not already present (attributes in markup override
+     *  `hostAttributes`).
+     *
+     * In addition, the following Polymer-specific callbacks may be provided:
+     * - `registered`: called after first instance of this element,
+     * - `created`: called during `constructor`
+     * - `attached`: called during `connectedCallback`
+     * - `detached`: called during `disconnectedCallback`
+     * - `ready`: called before first `attached`, after all properties of
+     *   this element have been propagated to its template and all observers
+     *   have run
+     *
+     * @param {Object} info Object containing Polymer metadata and functions
+     *   to become class methods.
+     * @return {Polymer.LegacyElement} Generated class
+     * @memberof Polymer
+     */
+    Polymer.Class = function(info) {
+      if (!info) {
+        console.warn('Polymer.Class requires `info` argument');
+      }
+      let klass = GenerateClassFromInfo(info, info.behaviors ?
+        // note: mixinBehaviors ensures `LegacyElementMixin`.
+        mixinBehaviors(info.behaviors, HTMLElement) :
+        LegacyElementMixin(HTMLElement));
+      // decorate klass with registration info
+      klass.is = info.is;
+      // behaviors on prototype for BC...
+      klass.prototype.behaviors = klass.behaviors;
+      // NOTE: while we could call `beforeRegister` here to maintain
+      // some BC, the state of the element at this point is not as it was in 1.0
+      // In 1.0, the method was called *after* mixing prototypes together
+      // but before processing of meta-objects. Since this is now done
+      // in 1 step via `GenerateClassFromInfo`, this is no longer possible.
+      // However, *most* work (not setting `is`) that was previously done in
+      // `beforeRegister` should be possible in `registered`.
+      return klass;
+    }
+
+    Polymer.mixinBehaviors = mixinBehaviors;
+
+  })();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/legacy-element-mixin.html b/lib/polymer2/bower_components/polymer/lib/legacy/legacy-element-mixin.html
new file mode 100644
index 00000000..6272b1ce
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/legacy-element-mixin.html
@@ -0,0 +1,918 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../../../shadycss/apply-shim.html">
+<link rel="import" href="../mixins/element-mixin.html">
+<link rel="import" href="../mixins/gesture-event-listeners.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/import-href.html">
+<link rel="import" href="../utils/render-status.html">
+<link rel="import" href="../utils/unresolved.html">
+<link rel="import" href="polymer.dom.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  let styleInterface = window.ShadyCSS;
+
+  /**
+   * Element class mixin that provides Polymer's "legacy" API intended to be
+   * backward-compatible to the greatest extent possible with the API
+   * found on the Polymer 1.x `Polymer.Base` prototype applied to all elements
+   * defined using the `Polymer({...})` function.
+   *
+   * @polymerMixin
+   * @mixes Polymer.ElementMixin
+   * @mixes Polymer.GestureEventListeners
+   * @property isAttached {boolean} Set to `true` in this element's
+   *   `connectedCallback` and `false` in `disconnectedCallback`
+   * @memberof Polymer
+   * @summary Element class mixin that provides Polymer's "legacy" API
+   */
+  Polymer.LegacyElementMixin = Polymer.dedupingMixin(function(base) {
+
+    const legacyElementBase = Polymer.GestureEventListeners(Polymer.ElementMixin(base));
+
+    /**
+     * Map of simple names to touch action names
+     * @dict
+     */
+    const DIRECTION_MAP = {
+      'x': 'pan-x',
+      'y': 'pan-y',
+      'none': 'none',
+      'all': 'auto'
+    };
+
+    return class LegacyElement extends legacyElementBase {
+
+      constructor() {
+        super();
+        this.created();
+      }
+
+      /**
+       * Legacy callback called during the `constructor`, for overriding
+       * by the user.
+       */
+      created() {}
+
+      connectedCallback() {
+        super.connectedCallback();
+        this.isAttached = true;
+        this.attached();
+      }
+
+      /**
+       * Legacy callback called during `connectedCallback`, for overriding
+       * by the user.
+       */
+      attached() {}
+
+      disconnectedCallback() {
+        super.disconnectedCallback();
+        this.isAttached = false;
+        this.detached();
+      }
+
+      /**
+       * Legacy callback called during `disconnectedCallback`, for overriding
+       * by the user.
+       */
+      detached() {}
+
+      attributeChangedCallback(name, old, value) {
+        if (old !== value) {
+          super.attributeChangedCallback(name, old, value);
+          this.attributeChanged(name, old, value);
+        }
+      }
+
+      /**
+       * Legacy callback called during `attributeChangedChallback`, for overriding
+       * by the user.
+       */
+      attributeChanged() {}
+
+      /**
+       * Overrides the default `Polymer.PropertyEffects` implementation to
+       * add support for one-time `registration` callback.
+       *
+       * @override
+       */
+      _initializeProperties() {
+        this._registered();
+        super._initializeProperties();
+      }
+
+      /**
+       * 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
+       */
+      _registered() {}
+
+      /**
+       * Overrides the default `Polymer.PropertyEffects` implementation to
+       * add support for installing `hostAttributes` and `listeners`.
+       *
+       * @override
+       */
+      ready() {
+        this._ensureAttributes();
+        this._applyListeners();
+        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
+       */
+      _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 asychronously so as not to
+       * block render.
+       * @protected
+       */
+      _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} Serialized value
+       */
+      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
+       */
+      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 refect.
+       */
+      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.
+       */
+      serializeValueToAttribute(value, attribute, node) {
+        this._valueToNodeAttribute(node || this, value, attribute);
+      }
+
+      /**
+       * Copies own properties (including accessor descriptors) from a source
+       * object to a target object.
+       *
+       * @method extend
+       * @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.
+       */
+      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`.
+       *
+       * @method mixin
+       * @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.
+       */
+      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.
+       */
+      chainObject(object, inherited) {
+        if (object && inherited && object !== inherited) {
+          object.__proto__ = inherited;
+        }
+        return object;
+      }
+
+      /* **** Begin Template **** */
+
+      /**
+       * Calls `importNode` on the `content` of the `template` specified and
+       * returns a document fragment containing the imported content.
+       *
+       * @method instanceTemplate
+       * @param {HTMLTemplateElement} template HTML template element to instance.
+       * @return {DocumentFragment} Document fragment containing the imported
+       *   template content.
+      */
+      instanceTemplate(template) {
+        let dom = /** @type {DocumentFragment} */
+          (document.importNode(template._content || template.content, true));
+        return dom;
+      }
+
+      /* **** Begin Events **** */
+
+      /**
+       * Dispatches a custom event with an optional detail value.
+       *
+       * @method fire
+       * @param {string} type Name of event type.
+       * @param {*=} detail Detail value containing event-specific
+       *   payload.
+       * @param {Object=} 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.
+       */
+      fire(type, detail, options) {
+        options = options || {};
+        detail = (detail === null || detail === undefined) ? {} : detail;
+        let event = new Event(type, {
+          bubbles: options.bubbles === undefined ? true : options.bubbles,
+          cancelable: Boolean(options.cancelable),
+          composed: options.composed === undefined ? true: options.composed
+        });
+        event.detail = detail;
+        let node = options.node || this;
+        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.
+       *
+       * @method listen
+       * @param {Element} 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.
+       */
+      listen(node, eventName, methodName) {
+        node = node || this;
+        let hbl = this.__boundListeners ||
+          (this.__boundListeners = 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(
+            node, eventName, methodName, this);
+        }
+      }
+
+      /**
+       * Convenience method to remove an event listener from a given element,
+       * late bound to a named method on this element.
+       *
+       * @method unlisten
+       * @param {Element} 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.
+       */
+      unlisten(node, eventName, methodName) {
+        node = node || this;
+        let bl = this.__boundListeners && this.__boundListeners.get(node);
+        let key = eventName + methodName;
+        let handler = bl && bl[key];
+        if (handler) {
+          this._removeEventListenerFromNode(node, eventName, handler);
+          bl[key] = 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
+       *
+       * @method setScrollDirection
+       * @param {String=} direction Direction to allow scrolling
+       * Defaults to `all`.
+       * @param {HTMLElement=} node Element to apply scroll direction setting.
+       * Defaults to `this`.
+       */
+      setScrollDirection(direction, node) {
+        Polymer.Gestures.setTouchAction(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)`.
+       *
+       * @method $$
+       * @param {string} slctr Selector to run on this local DOM scope
+       * @return {Element} Element found by the selector, or null if not found.
+       */
+      $$(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`.
+       */
+      get domHost() {
+        let root = this.getRootNode();
+        return (root instanceof DocumentFragment) ? root.host : root;
+      }
+
+      /**
+       * Force this element to distribute its children to its local dom.
+       * This is necessary only when ShadyDOM is used and only in cases that
+       * are not automatically handled. For example,
+       * a user should call `distributeContent` if distribution has been
+       * invalidated due to an element being added or removed from the shadowRoot
+       * that contains an insertion point (<slot>) inside its subtree.
+       * @method distributeContent
+       */
+      distributeContent() {
+        if (window.ShadyDOM && this.shadowRoot) {
+          this.shadowRoot.forceRender();
+        }
+      }
+
+      /**
+       * 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.
+       *
+       * @method getEffectiveChildNodes
+       * @return {Array<Node>} List of effctive child nodes.
+       */
+      getEffectiveChildNodes() {
+        return Polymer.dom(this).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.
+       * @method queryDistributedElements
+       * @param {string} selector Selector to run.
+       * @return {Array<Node>} List of distributed elements that match selector.
+       */
+      queryDistributedElements(selector) {
+        return Polymer.dom(this).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>`.
+       *
+       * @method getEffectiveChildren
+       * @return {Array<Node>} List of effctive children.
+       */
+      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>.
+       *
+       * @method getEffectiveTextContent
+       * @return {string} List of effctive children.
+       */
+      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.
+       * @method queryEffectiveChildren
+       * @param {string} selector Selector to run.
+       * @return {Object<Node>} First effective child node that matches selector.
+       */
+      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.
+       * @method queryEffectiveChildren
+       * @param {string} selector Selector to run.
+       * @return {Array<Node>} List of effective child nodes that match selector.
+       */
+      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.
+       *
+       * @method getContentChildNodes
+       * @param {String=} slctr CSS selector to choose the desired
+       *   `<slot>`.  Defaults to `content`.
+       * @return {Array<Node>} List of distributed nodes for the `<slot>`.
+       */
+      getContentChildNodes(slctr) {
+        let content = this.root.querySelector(slctr || 'slot');
+        return content ? Polymer.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.
+       *
+       * @method getContentChildNodes
+       * @param {String=} slctr CSS selector to choose the desired
+       *   `<content>`.  Defaults to `content`.
+       * @return {Array<HTMLElement>} List of distributed nodes for the
+       *   `<slot>`.
+       */
+      getContentChildren(slctr) {
+        return this.getContentChildNodes(slctr).filter(function(n) {
+          return (n.nodeType === Node.ELEMENT_NODE);
+        });
+      }
+
+      /**
+       * Checks whether an element is in this element's light DOM tree.
+       *
+       * @method isLightDescendant
+       * @param {?Node} node The element to be checked.
+       * @return {Boolean} true if node is in this element's light DOM tree.
+       */
+      isLightDescendant(node) {
+        return this !== node && this.contains(node) &&
+            this.getRootNode() === node.getRootNode();
+      }
+
+      /**
+       * Checks whether an element is in this element's local DOM tree.
+       *
+       * @method isLocalDescendant
+       * @param {HTMLElement=} node The element to be checked.
+       * @return {boolean} true if node is in this element's local DOM tree.
+       */
+      isLocalDescendant(node) {
+        return this.root === node.getRootNode();
+      }
+
+      // NOTE: should now be handled by ShadyCss library.
+      scopeSubtree(container, shouldObserve) { // eslint-disable-line no-unused-vars
+      }
+
+      /**
+       * Returns the computed style value for the given property.
+       * @param {String} property
+       * @return {String} the computed value
+       */
+      getComputedStyleValue(property) {
+        return styleInterface.getComputedStyleValue(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);
+       *     }
+       *
+       * @method debounce
+       * @param {String} jobName String to indentify the debounce job.
+       * @param {function()} 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`
+       */
+      debounce(jobName, callback, wait) {
+        this._debouncers = this._debouncers || {};
+        return this._debouncers[jobName] = Polymer.Debouncer.debounce(
+              this._debouncers[jobName]
+            , wait > 0 ? Polymer.Async.timeOut.after(wait) : Polymer.Async.microTask
+            , callback.bind(this));
+      }
+
+      /**
+       * Returns whether a named debouncer is active.
+       *
+       * @method isDebouncerActive
+       * @param {String} jobName The name of the debouncer started with `debounce`
+       * @return {boolean} Whether the debouncer is active (has not yet fired).
+       */
+      isDebouncerActive(jobName) {
+        this._debouncers = this._debouncers || {};
+        let debouncer = this._debouncers[jobName];
+        return !!(debouncer && debouncer.isActive());
+      }
+
+      /**
+       * Immediately calls the debouncer `callback` and inactivates it.
+       *
+       * @method flushDebouncer
+       * @param {String} jobName The name of the debouncer started with `debounce`
+       */
+      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.
+       *
+       * @method cancelDebouncer
+       * @param {String} jobName The name of the debouncer started with `debounce`
+       */
+      cancelDebouncer(jobName) {
+        this._debouncers = this._debouncers || {}
+        let debouncer = this._debouncers[jobName];
+        if (debouncer) {
+          debouncer.cancel();
+        }
+      }
+
+      /**
+       * Runs a callback function asyncronously.
+       *
+       * By default (if no waitTime is specified), async callbacks are run at
+       * microtask timing, which will occur before paint.
+       *
+       * @method async
+       * @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.
+       */
+      async(callback, waitTime) {
+        return waitTime > 0 ? Polymer.Async.timeOut.run(callback.bind(this), waitTime) :
+            ~Polymer.Async.microTask.run(callback.bind(this));
+      }
+
+      /**
+       * Cancels an async operation started with `async`.
+       *
+       * @method cancelAsync
+       * @param {number} handle Handle returned from original `async` call to
+       *   cancel.
+       */
+      cancelAsync(handle) {
+        handle < 0 ? Polymer.Async.microTask.cancel(~handle) :
+            Polymer.Async.timeOut.cancel(handle);
+      }
+
+      // other
+
+      /**
+       * Convenience method for creating an element and configuring it.
+       *
+       * @method create
+       * @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.
+       */
+      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;
+      }
+
+      /**
+       * Convenience method for importing an HTML document imperatively.
+       *
+       * This method creates a new `<link rel="import">` element with
+       * the provided URL and appends it to the document to start loading.
+       * In the `onload` callback, the `import` property of the `link`
+       * element will contain the imported document contents.
+       *
+       * @method importHref
+       * @param {string} href URL to document to load.
+       * @param {Function} onload Callback to notify when an import successfully
+       *   loaded.
+       * @param {Function} onerror Callback to notify when an import
+       *   unsuccessfully loaded.
+       * @param {boolean} optAsync True if the import should be loaded `async`.
+       *   Defaults to `false`.
+       * @return {HTMLLinkElement} The link element for the URL to be loaded.
+       */
+      importHref(href, onload, onerror, optAsync) { // eslint-disable-line no-unused-vars
+        let loadFn = onload ? onload.bind(this) : null;
+        let errorFn = onerror ? onerror.bind(this) : null;
+        return Polymer.importHref(href, loadFn, errorFn, optAsync);
+      }
+
+      /**
+       * Polyfill for Element.prototype.matches, which is sometimes still
+       * prefixed.
+       *
+       * @method elementMatches
+       * @param {string} selector Selector to test.
+       * @param {Element=} node Element to test the selector against.
+       * @return {boolean} Whether the element matches the selector.
+       */
+      elementMatches(selector, node) {
+        return Polymer.dom.matchesSelector(node || this, selector);
+      }
+
+      /**
+       * Toggles an HTML attribute on or off.
+       *
+       * @method toggleAttribute
+       * @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.
+       * @param {HTMLElement=} node Node to target.  Defaults to `this`.
+       */
+      toggleAttribute(name, bool, node) {
+        node = node || this;
+        if (arguments.length == 1) {
+          bool = !node.hasAttribute(name);
+        }
+        if (bool) {
+          node.setAttribute(name, '');
+        } else {
+          node.removeAttribute(name);
+        }
+      }
+
+
+      /**
+       * Toggles a CSS class on or off.
+       *
+       * @method toggleClass
+       * @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 {HTMLElement=} node Node to target.  Defaults to `this`.
+       */
+      toggleClass(name, bool, node) {
+        node = 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 {HTMLElement=} node Element to apply the transform to.
+       * Defaults to `this`
+       */
+      transform(transformText, node) {
+        node = node || this;
+        node.style.webkitTransform = transformText;
+        node.style.transform = transformText;
+      }
+
+      /**
+       * Cross-platform helper for setting an element's CSS `translate3d`
+       * property.
+       *
+       * @method translate3d
+       * @param {number} x X offset.
+       * @param {number} y Y offset.
+       * @param {number} z Z offset.
+       * @param {HTMLElement=} node Element to apply the transform to.
+       * Defaults to `this`.
+       */
+      translate3d(x, y, z, node) {
+        node = 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**.
+       *
+       * @method arrayDelete
+       * @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.
+       */
+      arrayDelete(arrayOrPath, item) {
+        let index;
+        if (Array.isArray(arrayOrPath)) {
+          index = arrayOrPath.indexOf(item);
+          if (index >= 0) {
+            return arrayOrPath.splice(index, 1);
+          }
+        } else {
+          let arr = Polymer.Path.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
+       */
+      _logger(level, args) {
+        // accept ['foo', 'bar'] and [['foo', 'bar']]
+        if (Array.isArray(args) && args.length === 1) {
+          args = args[0];
+        }
+        switch(level) {
+          case 'log':
+          case 'warn':
+          case 'error':
+            console[level](...args);
+        }
+      }
+
+      /**
+       * Facades `console.log` as an override point.
+       *
+       * @param {...*} var_args Array of strings or objects to log
+       */
+      _log(...args) {
+        this._logger('log', args);
+      }
+
+      /**
+       * Facades `console.warn` as an override point.
+       *
+       * @param {...*} var_args Array of strings or objects to log
+       */
+      _warn(...args) {
+        this._logger('warn', args);
+      }
+
+      /**
+       * Facades `console.error` as an override point.
+       *
+       * @param {...*} var_args Array of strings or objects to log
+       */
+      _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 {...*} var_args Array of strings or objects to log
+       * @return {string} String with formatting information for `console`
+       *   logging.
+       */
+      _logf(...args) {
+        return ['[%s::%s]', this.is, ...args];
+      }
+
+    }
+
+  });
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/mutable-data-behavior.html b/lib/polymer2/bower_components/polymer/lib/legacy/mutable-data-behavior.html
new file mode 100644
index 00000000..7a1d5294
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/mutable-data-behavior.html
@@ -0,0 +1,150 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../mixins/mutable-data.html">
+
+<script>
+(function() {
+  'use strict';
+
+  let mutablePropertyChange = Polymer.MutableData._mutablePropertyChange;
+
+  /**
+   * Legacy element behavior to skip strict dirty-checking for objects and arrays,
+   * (always consider them to be "dirty") for use on legacy API Polymer elements.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will cause Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * In order to make the dirty check strategy configurable, see
+   * `Polymer.OptionalMutableDataBehavior`.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse as opposed to using strict dirty checking with immutable
+   * patterns or Polymer's path notification API.
+   *
+   * @polymerBehavior
+   * @memberof Polymer
+   * @summary Behavior to skip strict dirty-checking for objects and
+   *   arrays
+   */
+  Polymer.MutableDataBehavior = {
+
+    /**
+     * Overrides `Polymer.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);
+    }
+  };
+
+  /**
+   * Legacy element behavior to add the optional ability to skip strict
+   * dirty-checking for objects and arrays (always consider them to be
+   * "dirty") by setting a `mutable-data` attribute on an element instance.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will allow Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * While this behavior adds the ability to forgo Object/Array dirty checking,
+   * the `mutableData` flag defaults to false and must be set on the instance.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse by relying on `mutableData: true` as opposed to using
+   * strict dirty checking with immutable patterns or Polymer's path notification
+   * API.
+   *
+   * @polymerBehavior
+   * @memberof Polymer
+   * @summary Behavior to optionally skip strict dirty-checking for objects and
+   *   arrays
+   */
+  Polymer.OptionalMutableDataBehavior = {
+
+    properties: {
+      /**
+       * 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 `Polymer.PropertyEffects` to skip strict equality checking
+     * for Objects and Arrays.
+     *
+     * 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);
+    }
+  };
+
+})();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/polymer-fn.html b/lib/polymer2/bower_components/polymer/lib/legacy/polymer-fn.html
new file mode 100644
index 00000000..29258b55
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/polymer-fn.html
@@ -0,0 +1,47 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="class.html">
+
+<script>
+
+  (function() {
+    'use strict';
+
+    /**
+     * Legacy class factory and registration helper for defining Polymer
+     * elements.
+     *
+     * This method is equivalent to
+     * `customElements.define(info.is, Polymer.Class(info));`
+     *
+     * See `Polymer.Class` for details on valid legacy metadata format for `info`.
+     *
+     * @function Polymer
+     * @param {Object} info Object containing Polymer metadata and functions
+     *   to become class methods.
+     * @return {Polymer.LegacyElement} Generated class
+     */
+    window.Polymer._polymerFn = function(info) {
+      // if input is a `class` (aka a function with a prototype), use the prototype
+      // remember that the `constructor` will never be called
+      let klass;
+      if (typeof info === 'function') {
+        klass = info;
+      } else {
+        klass = Polymer.Class(info);
+      }
+      customElements.define(klass.is, klass);
+      return klass;
+    };
+
+  })();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/polymer.dom.html b/lib/polymer2/bower_components/polymer/lib/legacy/polymer.dom.html
new file mode 100644
index 00000000..8e9e8958
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/polymer.dom.html
@@ -0,0 +1,334 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/flattened-nodes-observer.html">
+<link rel="import" href="../utils/flush.html">
+<script>
+(function() {
+  'use strict';
+
+  const p = Element.prototype;
+  const normalizedMatchesSelector = p.matches || p.matchesSelector ||
+    p.mozMatchesSelector || p.msMatchesSelector ||
+    p.oMatchesSelector || p.webkitMatchesSelector;
+
+  /**
+   * Cross-platform `element.matches` shim.
+   *
+   * @function matchesSelector
+   * @memberof Polymer.dom
+   * @param {Node} node Node to check selector against
+   * @param {string} selector Selector to match
+   * @return {boolean} True if node matched selector
+   */
+  const matchesSelector = function(node, selector) {
+    return normalizedMatchesSelector.call(node, selector);
+  }
+
+  /**
+   * Node API wrapper class returned from `Polymer.dom.(target)` when
+   * `target` is a `Node`.
+   */
+  class DomApi {
+
+    constructor(node) {
+      this.node = node;
+    }
+
+    /**
+     * Returns an instance of `Polymer.FlattenedNodesObserver` that
+     * listens for node changes on this element.
+     *
+     * @param {Function} callback Called when direct or distributed children
+     *   of this element changes
+     * @return {Polymer.FlattenedNodesObserver} Observer instance
+     */
+    observeNodes(callback) {
+      return new Polymer.FlattenedNodesObserver(this.node, callback);
+    }
+
+    /**
+     * Disconnects an observer previously created via `observeNodes`
+     *
+     * @param {Polymer.FlattenedNodesObserver} observerHandle Observer instance
+     *   to disconnect.
+     */
+    unobserveNodes(observerHandle) {
+      observerHandle.disconnect();
+    }
+
+    /**
+     * Provided as a backwards-compatible API only.  This method does nothing.
+     */
+    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.
+     */
+    deepContains(node) {
+      if (this.node.contains(node)) {
+        return true;
+      }
+      let n = node;
+      let doc = node.ownerDocument;
+      // walk from node to `this` or `document`
+      while (n && n !== doc && n !== this.node) {
+        // use logical parentnode, or native ShadowRoot host
+        n = n.parentNode || n.host;
+      }
+      return n === this.node;
+    }
+
+    /**
+     * Returns the root node of this node.  Equivalent to `getRoodNode()`.
+     *
+     * @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.
+     */
+    getOwnerRoot() {
+      return 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
+     */
+    getDistributedNodes() {
+      return (this.node.localName === 'slot') ?
+        this.node.assignedNodes({flatten: true}) :
+        [];
+    }
+
+    /**
+     * Returns an array of all slots this element was distributed to.
+     *
+     * @return {Array<HTMLSlotElement>} Description
+     */
+    getDestinationInsertionPoints() {
+      let ip$ = [];
+      let n = this.node.assignedSlot;
+      while (n) {
+        ip$.push(n);
+        n = 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 doc.importNode(node, deep);
+    }
+
+    /**
+     * Returns a flattened list of all child nodes and nodes distributed
+     * to child slots.
+     *
+     * @return {type} Description
+     */
+    getEffectiveChildNodes() {
+      return Polymer.FlattenedNodesObserver.getFlattenedNodes(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
+     */
+    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
+     */
+    get activeElement() {
+      let node = this.node;
+      return node._activeElement !== undefined ? node._activeElement : node.activeElement;
+    }
+  }
+
+  function forwardMethods(proto, methods) {
+    for (let i=0; i < methods.length; i++) {
+      let method = methods[i];
+      proto[method] = 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() {
+          return this.node[name];
+        },
+        configurable: true
+      });
+    }
+  }
+
+  function forwardProperties(proto, properties) {
+    for (let i=0; i < properties.length; i++) {
+      let name = properties[i];
+      Object.defineProperty(proto, name, {
+        get: function() {
+          return this.node[name];
+        },
+        set: function(value) {
+          this.node[name] = value;
+        },
+        configurable: true
+      });
+    }
+  }
+
+  forwardMethods(DomApi.prototype, [
+    'cloneNode', 'appendChild', 'insertBefore', 'removeChild',
+    'replaceChild', 'setAttribute', 'removeAttribute',
+    'querySelector', 'querySelectorAll'
+  ]);
+
+  forwardReadOnlyProperties(DomApi.prototype, [
+    'parentNode', 'firstChild', 'lastChild',
+    'nextSibling', 'previousSibling', 'firstElementChild',
+    'lastElementChild', 'nextElementSibling', 'previousElementSibling',
+    'childNodes', 'children', 'classList'
+  ]);
+
+  forwardProperties(DomApi.prototype, [
+    'textContent', 'innerHTML'
+  ]);
+
+
+  /**
+   * Event API wrapper class returned from `Polymer.dom.(target)` when
+   * `target` is an `Event`.
+   */
+  class EventApi {
+    constructor(event) {
+      this.event = event;
+    }
+
+    /**
+     * Returns the first node on the `composedPath` of this event.
+     *
+     * @return {Node} The node this event was dispatched to
+     */
+    get rootTarget() {
+      return this.event.composedPath()[0];
+    }
+
+    /**
+     * Returns the local (re-targeted) target for this event.
+     *
+     * @return {Node} The local (re-targeted) target for this event.
+     */
+    get localTarget() {
+      return this.event.target;
+    }
+
+    /**
+     * Returns the `composedPath` for this event.
+     */
+    get path() {
+      return this.event.composedPath();
+    }
+  }
+
+  /**
+   * Legacy DOM and Event manipulation API wrapper factory used to abstract
+   * differences between native Shadow DOM and "Shady DOM" when polyfilling on
+   * older browsers.
+   *
+   * Note that in Polymer 2.x use of `Polymer.dom` is no longer required and
+   * in the majority of cases simply facades directly to the standard native
+   * API.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @param {Node|Event} obj Node or event to operate on
+   * @return {DomApi|EventApi} Wrapper providing either node API or event API
+   */
+  Polymer.dom = function(obj) {
+    obj = obj || document;
+    let ctor = obj instanceof Event ? EventApi : DomApi;
+    if (!obj.__domApi) {
+      obj.__domApi = new ctor(obj);
+    }
+    return obj.__domApi;
+  };
+
+  Polymer.dom.matchesSelector = matchesSelector;
+
+  /**
+   * Forces several classes of asynchronously queued tasks to flush:
+   * - Debouncers added via `Polymer.enqueueDebouncer`
+   * - ShadyDOM distribution
+   *
+   * This method facades to `Polymer.flush`.
+   *
+   * @memberof Polymer.dom
+   */
+  Polymer.dom.flush = Polymer.flush;
+
+  /**
+   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
+   *
+   * This method facades to `Polymer.enqueueDebouncer`.
+   *
+   * @memberof Polymer.dom
+   * @param {Polymer.Debouncer} debouncer Debouncer to enqueue
+   */
+  Polymer.dom.addDebouncer = Polymer.enqueueDebouncer;
+
+  // expose BC settings.
+  let settings = Polymer.Settings || {};
+  settings.useShadow = !(window.ShadyDOM);
+  settings.useNativeCSSProperties =
+    Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss);
+  settings.useNativeCustomElements =
+    !(window.customElements.polyfillWrapFlushCallback);
+  Polymer.Settings = settings;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/legacy/templatizer-behavior.html b/lib/polymer2/bower_components/polymer/lib/legacy/templatizer-behavior.html
new file mode 100644
index 00000000..653e52e5
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/legacy/templatizer-behavior.html
@@ -0,0 +1,136 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../utils/templatize.html">
+
+<script>
+  (function() {
+    'use strict';
+
+    /**
+     * The `Polymer.Templatizer` behavior adds methods to generate instances of
+     * templates that are each managed by an anonymous `Polymer.PropertyEffects`
+     * instance where data-bindings in the stamped template content are bound to
+     * accessors on itself.
+     *
+     * This behavior is provided in Polymer 2.x as a hybrid-element convenience
+     * only.  For non-hybrid usage, the `Polymer.Templatize` library
+     * should be used instead.
+     *
+     * Example:
+     *
+     *     // Get a template from somewhere, e.g. light DOM
+     *     let template = this.querySelector('template');
+     *     // Prepare the template
+     *     this.templatize(template);
+     *     // Instance the template with an initial data model
+     *     let instance = this.stamp({myProp: 'initial'});
+     *     // Insert the instance's DOM somewhere, e.g. light DOM
+     *     Polymer.dom(this).appendChild(instance.root);
+     *     // Changing a property on the instance will propagate to bindings
+     *     // in the template
+     *     instance.myProp = 'new value';
+     *
+     * Users of `Templatizer` may need to implement the following abstract
+     * API's to determine how properties and paths from the host should be
+     * forwarded into to instances:
+     *
+     *     _forwardHostPropV2: function(prop, value)
+     *
+     * Likewise, users may implement these additional abstract API's to determine
+     * how instance-specific properties that change on the instance should be
+     * forwarded out to the host, if necessary.
+     *
+     *     _notifyInstancePropV2: function(inst, prop, value)
+     *
+     * In order to determine which properties are instance-specific and require
+     * custom notification via `_notifyInstanceProp`, define an `_instanceProps`
+     * object containing keys for each instance prop, for example:
+     *
+     *     _instanceProps: {
+     *       item: true,
+     *       index: true
+     *     }
+     *
+     * Any properties used in the template that are not defined in _instanceProp
+     * will be forwarded out to the Templatize `owner` automatically.
+     *
+     * Users may also implement the following abstract function to show or
+     * hide any DOM generated using `stamp`:
+     *
+     *     _showHideChildren: function(shouldHide)
+     *
+     * Note that some callbacks are suffixed with `V2` in the Polymer 2.x behavior
+     * as the implementations will need to differ from the callbacks required
+     * by the 1.x Templatizer API due to changes in the `TemplateInstance` API
+     * between versions 1.x and 2.x.
+     *
+     * @polymerBehavior
+     * @memberof Polymer
+     */
+    let Templatizer = {
+
+      /**
+       * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
+       * for the provided template.  This method should be called once per
+       * template to prepare an element for stamping the template, followed
+       * by `stamp` to create new instances of the template.
+       *
+       * @param {HTMLTemplateElement} template Template to prepare
+       * @param {Boolean=} mutableData When `true`, the generated class will skip
+       *   strict dirty-checking for objects and arrays (always consider them to
+       *   be "dirty"). Defaults to false.
+       * @return {TemplateInstance} Description
+       */
+      templatize(template, mutableData) {
+        this._templatizerTemplate = template;
+        this.ctor = Polymer.Templatize.templatize(template, this, {
+          mutableData: Boolean(mutableData),
+          parentModel: this._parentModel,
+          instanceProps: this._instanceProps,
+          forwardHostProp: this._forwardHostPropV2,
+          notifyInstanceProp: this._notifyInstancePropV2
+        });
+      },
+
+      /**
+       * Creates an instance of the template prepared by `templatize`.  The object
+       * returned is an instance of the anonymous class generated by `templatize`
+       * whose `root` property is a document fragment containing newly cloned
+       * template content, and which has property accessors corresponding to
+       * properties referenced in template bindings.
+       *
+       * @param {Object=} model Object containing initial property values to
+       *   populate into the template bindings.
+       */
+      stamp(model) {
+        return new this.ctor(model);
+      },
+
+      /**
+       * Returns the template "model" (`TemplateInstance`) 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.
+       *
+       * @method modelForElement
+       * @param {HTMLElement} el Element for which to return a template model.
+       * @return {TemplateInstanceBase} Model representing the binding scope for
+       *   the element.
+       */
+      modelForElement(el) {
+        return Polymer.Templatize.modelForElement(this._templatizerTemplate, el);
+      }
+    };
+
+    Polymer.Templatizer = Templatizer;
+
+  })();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/element-mixin.html b/lib/polymer2/bower_components/polymer/lib/mixins/element-mixin.html
new file mode 100644
index 00000000..3c8c9890
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/element-mixin.html
@@ -0,0 +1,806 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/case-map.html">
+<link rel="import" href="../utils/style-gather.html">
+<link rel="import" href="../utils/resolve-url.html">
+<link rel="import" href="../elements/dom-module.html">
+<link rel="import" href="property-effects.html">
+
+<script>
+(function() {
+  'use strict';
+  /**
+   * @typedef Object<string, {
+   *   value: *,
+   *   type: (Function | undefined),
+   *   readOnly: (boolean | undefined),
+   *   computed: (string | undefined),
+   *   reflectToAttribute: (boolean | undefined),
+   *   notify: (boolean | undefined),
+   *   observer: (string | undefined)
+   * }>)
+   */
+  let PolymerElementProperties; // eslint-disable-line no-unused-vars
+
+  /** @record */
+  let PolymerElementConstructor = function(){}; // eslint-disable-line no-unused-vars
+  /** @type {(string | undefined)} */
+  PolymerElementConstructor.is;
+  /** @type {(string | undefined)} */
+  PolymerElementConstructor.extends;
+  /** @type {(!PolymerElementProperties | undefined)} */
+  PolymerElementConstructor.properties;
+  /** @type {(!Array<string> | undefined)} */
+  PolymerElementConstructor.observers;
+  /** @type {(!HTMLTemplateElement | string | undefined)} */
+  PolymerElementConstructor.template;
+
+  /**
+   * Element class mixin that provides the core API for Polymer's meta-programming
+   * features including template stamping, data-binding, attribute deserialization,
+   * and property change observation.
+   *
+   * Subclassers may provide the following static getters to return metadata
+   * used to configure Polymer's features for the class:
+   *
+   * - `static get is()`: When the template is provided via a `dom-module`,
+   *   users should return the `dom-module` id from a static `is` getter.  If
+   *   no template is needed or the template is provided directly via the
+   *   `template` getter, there is no need to define `is` for the element.
+   *
+   * - `static get template()`: Users may provide the template directly (as
+   *   opposed to via `dom-module`) by implementing a static `template` getter.
+   *   The getter may return an `HTMLTemplateElement` or a string, which will
+   *   automatically be parsed into a template.
+   *
+   * - `static get properties()`: Should return an object describing
+   *   property-related metadata used by Polymer features (key: property name
+   *   value: object containing property metadata). Valid keys in per-property
+   *   metadata include:
+   *   - `type` (String|Number|Object|Array|...): Used by
+   *     `attributeChangedCallback` to determine how string-based attributes
+   *     are deserialized to JavaScript property values.
+   *   - `notify` (boolean): Causes a change in the property to fire a
+   *     non-bubbling event called `<property>-changed`. Elements that have
+   *     enabled two-way binding to the property use this event to observe changes.
+   *   - `readOnly` (boolean): Creates a getter for the property, but no setter.
+   *     To set a read-only property, use the private setter method
+   *     `_setProperty(property, value)`.
+   *   - `observer` (string): Observer method name that will be called when
+   *     the property changes. The arguments of the method are
+   *     `(value, previousValue)`.
+   *   - `computed` (string): String describing method and dependent properties
+   *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
+   *     Computed properties are read-only by default and can only be changed
+   *     via the return value of the computing method.
+   *
+   * - `static get observers()`: Array of strings describing multi-property
+   *   observer methods and their dependent properties (e.g.
+   *   `'observeABC(a, b, c)'`).
+   *
+   * The base class provides default implementations for the following standard
+   * custom element lifecycle callbacks; users may override these, but should
+   * call the super method to ensure
+   * - `constructor`: Run when the element is created or upgraded
+   * - `connectedCallback`: Run each time the element is connected to the
+   *   document
+   * - `disconnectedCallback`: Run each time the element is disconnected from
+   *   the document
+   * - `attributeChangedCallback`: Run each time an attribute in
+   *   `observedAttributes` is set or removed (note: this element's default
+   *   `observedAttributes` implementation will automatically return an array
+   *   of dash-cased attributes based on `properties`)
+   *
+   * @polymerMixin
+   * @mixes Polymer.PropertyEffects
+   * @memberof Polymer
+   * @property rootPath {string} Set to the value of `Polymer.rootPath`,
+   *   which defaults to the main document path
+   * @property importPath {string} Set to the value of the class's static
+   *   `importPath` property, which defaults to the path of this element's
+   *   `dom-module` (when `is` is used), but can be overridden for other
+   *   import strategies.
+   * @summary Element class mixin that provides the core API for Polymer's
+   * meta-programming features.
+   */
+  Polymer.ElementMixin = Polymer.dedupingMixin(function(base) {
+
+    const polymerElementBase = Polymer.PropertyEffects(base);
+
+    let caseMap = Polymer.CaseMap;
+
+    /**
+     * Returns the `properties` object specifically on `klass`. Use for:
+     * (1) super chain mixes togther to make `propertiesForClass` which is
+     * then used to make `observedAttributes`.
+     * (2) properties effects and observers are created from it at `finalize` time.
+     * @param {HTMLElement} klass
+     * @private
+     */
+    function ownPropertiesForClass(klass) {
+      if (!klass.hasOwnProperty(
+        goog.reflect.objectProperty('__ownProperties', klass))) {
+        klass.__ownProperties =
+          klass.hasOwnProperty(goog.reflect.objectProperty('properties', klass)) ?
+          klass.properties : {};
+      }
+      return klass.__ownProperties;
+    }
+
+    /**
+     * Returns the `observers` array specifically on `klass`. Use for
+     * setting up observers.
+     * @param {HTMLElement} klass
+     * @private
+     */
+    function ownObserversForClass(klass) {
+      if (!klass.hasOwnProperty(
+        goog.reflect.objectProperty('__ownObservers', klass))) {
+        klass.__ownObservers =
+          klass.hasOwnProperty(goog.reflect.objectProperty('observers', klass)) ?
+          klass.observers : [];
+      }
+      return klass.__ownObservers;
+    }
+
+    /**
+     * Mixes `props` into `flattenedProps` but upgrades shorthand type
+     * syntax to { type: Type}.
+     * @param {Object} flattenedProps
+     * @param {Object} props
+     * @private
+     */
+    function flattenProperties(flattenedProps, props) {
+      for (let p in props) {
+        let o = props[p];
+        if (typeof o == 'function') {
+          o = { type: o };
+        }
+        flattenedProps[p] = o;
+      }
+      return flattenedProps;
+    }
+
+    /**
+     * Returns a flattened list of properties mixed together from the chain of all
+     * constructor's `config.properties`. This list is used to create
+     * (1) observedAttributes,
+     * (2) class property default values
+     * @param {HTMLElement} klass
+     * @return {PolymerElementProperties}
+     * @private
+     */
+    function propertiesForClass(klass) {
+      if (!klass.hasOwnProperty(
+        goog.reflect.objectProperty('__classProperties', klass))) {
+        klass.__classProperties =
+        flattenProperties({}, ownPropertiesForClass(klass));
+        let superCtor = Object.getPrototypeOf(klass.prototype).constructor;
+        if (superCtor.prototype instanceof PolymerElement) {
+          klass.__classProperties = Object.assign(
+            Object.create(propertiesForClass(superCtor)),
+            klass.__classProperties);
+        }
+      }
+      return klass.__classProperties;
+    }
+
+    /**
+     * Returns a list of properties with default values.
+     * This list is created as an optimization since it is a subset of
+     * the list returned from `propertiesForClass`.
+     * This list is used in `_initializeProperties` to set property defaults.
+     * @param {HTMLElement} klass
+     * @return {PolymerElementProperties}
+     * @private
+     */
+    function propertyDefaultsForClass(klass) {
+      if (!klass.hasOwnProperty(
+        goog.reflect.objectProperty('__classPropertyDefaults', klass))) {
+        klass.__classPropertyDefaults = null;
+        let props = propertiesForClass(klass);
+        for (let p in props) {
+          let info = props[p];
+          if ('value' in info) {
+            klass.__classPropertyDefaults = klass.__classPropertyDefaults || {};
+            klass.__classPropertyDefaults[p] = info;
+          }
+        }
+      }
+      return klass.__classPropertyDefaults;
+    }
+
+    /**
+     * Returns true if a `klass` has finalized. Called in `ElementClass.finalize()`
+     * @param {HTMLElement} klass
+     * @private
+     */
+    function hasClassFinalized(klass) {
+      return klass.hasOwnProperty(goog.reflect.objectProperty('__finalized', klass));
+    }
+
+    /**
+     * Called by `ElementClass.finalize()`. Ensures this `klass` and
+     * *all superclasses* are finalized by traversing the prototype chain
+     * and calling `klass.finalize()`.
+     * @param {HTMLElement} klass
+     * @private
+     */
+    function finalizeClassAndSuper(klass) {
+      let proto = klass.prototype;
+      let superCtor = Object.getPrototypeOf(proto).constructor;
+      if (superCtor.prototype instanceof PolymerElement) {
+        superCtor.finalize();
+      }
+      finalizeClass(klass);
+    }
+
+    /**
+     * Configures a `klass` based on a staic `klass.config` object and
+     * a `template`. This includes creating accessors and effects
+     * for properties in `config` and the `template` as well as preparing the
+     * `template` for stamping.
+     */
+    function finalizeClass(klass) {
+      klass.__finalized = true;
+      let proto = klass.prototype;
+      if (klass.hasOwnProperty(
+        goog.reflect.objectProperty('is', klass)) && klass.is) {
+        Polymer.telemetry.register(proto);
+      }
+      let props = ownPropertiesForClass(klass);
+      if (props) {
+        finalizeProperties(proto, props);
+      }
+      let observers = ownObserversForClass(klass);
+      if (observers) {
+        finalizeObservers(proto, observers, props);
+      }
+      // note: create "working" template that is finalized at instance time
+      let template = klass.template;
+      if (template) {
+        if (typeof template === 'string') {
+          let t = document.createElement('template');
+          t.innerHTML = template;
+          template = t;
+        } else {
+          template = template.cloneNode(true);
+        }
+        proto._template = template;
+      }
+    }
+
+    /**
+     * Configures a `proto` based on a `properties` object.
+     * Leverages `PropertyEffects` to create property accessors and effects
+     * supporting, observers, reflecting to attributes, change notification,
+     * computed properties, and read only properties.
+     * @param {HTMLElement} proto
+     * @param {Object} properties
+     * @private
+     */
+    function finalizeProperties(proto, properties) {
+      for (let p in properties) {
+        createPropertyFromConfig(proto, p, properties[p], properties);
+      }
+    }
+
+    /**
+     * Configures a `proto` based on a `observers` array.
+     * Leverages `PropertyEffects` to create observers.
+     * @param {HTMLElement} proto
+     * @param {Array} observers
+     * @private
+     */
+    function finalizeObservers(proto, observers, dynamicProperties) {
+      for (let i=0; i < observers.length; i++) {
+        proto._createMethodObserver(observers[i], dynamicProperties);
+      }
+    }
+
+    /**
+     * Creates effects for a property.
+     *
+     * Note, once a property has been set to
+     * `readOnly`, `computed`, `reflectToAttribute`, or `notify`
+     * these values may not be changed. For example, a subclass cannot
+     * alter these settings. However, additional `observers` may be added
+     * by subclasses.
+     *
+     * The info object should may contain property metadata as follows:
+     *
+     * * `type`: {function} type to which an attribute matching the property
+     * is deserialized. Note the property is camel-cased from a dash-cased
+     * attribute. For example, 'foo-bar' attribute is dersialized to a
+     * property named 'fooBar'.
+     *
+     * * `readOnly`: {boolean} creates a readOnly property and
+     * makes a private setter for the private of the form '_setFoo' for a
+     * property 'foo',
+     *
+     * * `computed`: {string} creates a computed property. A computed property
+     * also automatically is set to `readOnly: true`. The value is calculated
+     * by running a method and arguments parsed from the given string. For
+     * example 'compute(foo)' will compute a given property when the
+     * 'foo' property changes by executing the 'compute' method. This method
+     * must return the computed value.
+     *
+     * * `reflectToAttriute`: {boolean} If true, the property value is reflected
+     * to an attribute of the same name. Note, the attribute is dash-cased
+     * so a property named 'fooBar' is reflected as 'foo-bar'.
+     *
+     * * `notify`: {boolean} sends a non-bubbling notification event when
+     * the property changes. For example, a property named 'foo' sends an
+     * event named 'foo-changed' with `event.detail` set to the value of
+     * the property.
+     *
+     * * observer: {string} name of a method that runs when the property
+     * changes. The arguments of the method are (value, previousValue).
+     *
+     * Note: Users may want control over modifying property
+     * effects via subclassing. For example, a user might want to make a
+     * reflectToAttribute property not do so in a subclass. We've chosen to
+     * disable this because it leads to additional complication.
+     * For example, a readOnly effect generates a special setter. If a subclass
+     * disables the effect, the setter would fail unexpectedly.
+     * Based on feedback, we may want to try to make effects more malleable
+     * and/or provide an advanced api for manipulating them.
+     * Also consider adding warnings when an effect cannot be changed.
+     *
+     * @param {HTMLElement} proto
+     * @param {string} name Name of the property.
+     * @param {object} info Info object from which to create property effects.
+     * Supported keys:
+     * @param {object} allProps Flattened map of all properties defined in this
+     *   element (including inherited properties)
+     * @private
+     */
+    function createPropertyFromConfig(proto, name, info, allProps) {
+      // computed forces readOnly...
+      if (info.computed) {
+        info.readOnly = true;
+      }
+      // Note, since all computed properties are readOnly, this prevents
+      // adding additional computed property effects (which leads to a confusing
+      // setup where multiple triggers for setting a property)
+      // While we do have `hasComputedEffect` this is set on the property's
+      // dependencies rather than itself.
+      if (info.computed  && !proto._hasReadOnlyEffect(name)) {
+        proto._createComputedProperty(name, info.computed, allProps);
+      }
+      if (info.readOnly && !proto._hasReadOnlyEffect(name)) {
+        proto._createReadOnlyProperty(name, !info.computed);
+      }
+      if (info.reflectToAttribute && !proto._hasReflectEffect(name)) {
+        proto._createReflectedProperty(name);
+      }
+      if (info.notify && !proto._hasNotifyEffect(name)) {
+        proto._createNotifyingProperty(name);
+      }
+      // always add observer
+      if (info.observer) {
+        proto._createPropertyObserver(name, info.observer, allProps[info.observer]);
+      }
+    }
+
+    /**
+     * Configures an element `proto` to function with a given `template`.
+     * The element name `is` and extends `ext` must be specified for ShadyCSS
+     * style scoping.
+     * @param {HTMLElement} proto
+     * @param {HTMLTemplateElement} template
+     * @param {string} baseURI URL against which to resolve urls in
+     * style element cssText.
+     * @param {string} is
+     * @param {string} ext
+     * @private
+     */
+    function finalizeTemplate(proto, template, baseURI, is, ext) {
+      // support `include="module-name"`
+      let cssText =
+        Polymer.StyleGather.cssFromTemplate(template, baseURI) +
+        Polymer.StyleGather.cssFromModuleImports(is);
+      if (cssText) {
+        let style = document.createElement('style');
+        style.textContent = cssText;
+        template.content.insertBefore(style, template.content.firstChild);
+      }
+      if (window.ShadyCSS) {
+        window.ShadyCSS.prepareTemplate(template, is, ext);
+      }
+      proto._bindTemplate(template, propertiesForClass(proto.constructor));
+    }
+
+    /**
+     * @polymerMixinClass
+     * @unrestricted
+     */
+    class PolymerElement extends polymerElementBase {
+
+      /**
+       * Standard Custom Elements V1 API.  The default implementation returns
+       * a list of dash-cased attributes based on a flattening of all properties
+       * declared in `static get properties()` for this element and any
+       * superclasses.
+       *
+       * @return {Array} Observed attribute list
+       */
+      static get observedAttributes() {
+        if (!this.hasOwnProperty(goog.reflect.objectProperty('__observedAttributes', this))) {
+          let list = [];
+          let properties = propertiesForClass(this);
+          for (let prop in properties) {
+            list.push(Polymer.CaseMap.camelToDashCase(prop));
+          }
+          this.__observedAttributes = list;
+        }
+        return this.__observedAttributes;
+      }
+
+      /**
+       * Called automatically when the first element instance is created to
+       * ensure that class finalization work has been completed.
+       * May be called by users to eagerly perform class finalization work
+       * prior to the creation of the first element instance.
+       *
+       * Class finalization work generally includes meta-programming such as
+       * creating property accessors and any property effect metadata needed for
+       * the features used.
+       *
+       * @public
+       */
+      static finalize() {
+        if (!hasClassFinalized(this)) {
+          finalizeClassAndSuper(this);
+        }
+      }
+
+      /**
+       * Returns the template stamped into this element's shadow root.
+       *
+       * If a `static get is()` getter is defined, the default implementation
+       * will return the first `<template>` in a `dom-module` whose `id`
+       * matches this element's `is`.
+       *
+       * Users may override this getter to return an arbitrary template
+       * (in which case the `is` getter is unnecessary). The template returned
+       * may be either an `HTMLTemplateElement` or a string that will be
+       * automatically parsed into a template.
+       *
+       * Note that when subclassing, if the super class overrode the default
+       * implementation and the subclass would like to provide an alternate
+       * template via a `dom-module`, it should override this getter and
+       * return `Polymer.DomModule.import(this.is, 'template')`.
+       *
+       * If a subclass would like to modify the super class template, it should
+       * clone it rather than modify it in place.  If the getter does expensive
+       * work such as cloning/modifying a template, it should memoize the
+       * template for maximum performance:
+       *
+       *   let memoizedTemplate;
+       *   class MySubClass extends MySuperClass {
+       *     static get template() {
+       *       if (!memoizedTemplate) {
+       *         memoizedTemplate = super.template.cloneNode(true);
+       *         let subContent = document.createElement('div');
+       *         subContent.textContent = 'This came from MySubClass';
+       *         memoizedTemplate.content.appendChild(subContent);
+       *       }
+       *       return memoizedTemplate;
+       *     }
+       *   }
+       *
+       * @returns {HTMLTemplateElement|string}
+       */
+      static get template() {
+        if (!this.hasOwnProperty(goog.reflect.objectProperty('_template', this))) {
+          this._template = Polymer.DomModule.import(this.is, 'template') ||
+            // note: implemented so a subclass can retrieve the super
+            // template; call the super impl this way so that `this` points
+            // to the superclass.
+            Object.getPrototypeOf(this.prototype).constructor.template;
+        }
+        return this._template;
+      }
+
+      /**
+       * Path matching the url from which the element was imported.
+       * This path is used to resolve url's in template style cssText.
+       * The `importPath` property is also set on element instances and can be
+       * used to create bindings relative to the import path.
+       * Defaults to the path matching the url containing a `dom-module` element
+       * matching this element's static `is` property.
+       * Note, this path should contain a trailing `/`.
+       *
+       * @returns {string}
+       */
+      static get importPath() {
+        if (!this.hasOwnProperty(goog.reflect.objectProperty('_importPath', this))) {
+            const module = Polymer.DomModule.import(this.is);
+            this._importPath = module ? module.assetpath : '' ||
+            Object.getPrototypeOf(this.prototype).constructor.importPath;
+        }
+        return this._importPath;
+      }
+
+      constructor() {
+        super();
+        Polymer.telemetry.instanceCount++;
+        // Stamp template
+        if (this._template) {
+          this.root = this._stampTemplate(this._template);
+        } else {
+          this.root = this;
+        }
+      }
+
+      /**
+       * Overrides the default `Polymer.PropertyAccessors` to ensure class
+       * metaprogramming related to property accessors and effects has
+       * completed (calls `finalize`).
+       *
+       * It also initializes any property defaults provided via `value` in
+       * `properties` metadata.
+       *
+       * @override
+       */
+      _initializeProperties() {
+        this.constructor.finalize();
+        const importPath = this.constructor.importPath;
+        // note: finalize template when we have access to `localName` to
+        // avoid dependence on `is` for polyfilling styling.
+        if (this._template && !this._template.__polymerFinalized) {
+          this._template.__polymerFinalized = true;
+          const baseURI =
+            importPath ? Polymer.ResolveUrl.resolveUrl(importPath) : '';
+          finalizeTemplate(this.__proto__, this._template, baseURI,
+            this.localName);
+        }
+        super._initializeProperties();
+        // set path defaults
+        this.rootPath = Polymer.rootPath;
+        this.importPath = importPath;
+        // apply property defaults...
+        let p$ = propertyDefaultsForClass(this.constructor);
+        if (!p$) {
+          return;
+        }
+        for (let p in p$) {
+          let info = p$[p];
+          if (!this._isPropertyPending(p)) {
+            let value = typeof info.value == 'function' ?
+              info.value.call(this) :
+              info.value;
+            if (this._hasPropertyEffect(p)) {
+              this._setProperty(p, value)
+            } else {
+              this[p] = value;
+            }
+          }
+        }
+      }
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `connectedCallback`.
+       *
+       * The default implementation enables the property effects system and
+       * flushes any pending properties, and updates shimmed CSS properties
+       * when using the ShadyCSS scoping/custom properties polyfill.
+       *
+       * @override
+       */
+      connectedCallback() {
+        if (window.ShadyCSS) {
+          window.ShadyCSS.styleElement(this);
+        }
+        this._flushProperties();
+      }
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `disconnectedCallback`.
+       *
+       * @override
+       */
+      disconnectedCallback() {}
+
+      /**
+       * Implements `PropertyEffects`'s `_readyClients` call. Attaches
+       * element dom by calling `_attachDom` with the dom stamped from the
+       * element's template via `_stampTemplate`. Note that this allows
+       * client dom to be attached to the element prior to any observers
+       * running.
+       *
+       * @override
+       */
+      _readyClients() {
+        super._readyClients();
+        if (this._template) {
+          this.root = this._attachDom(this.root);
+        }
+      }
+
+
+      /**
+       * Attaches an element's stamped dom to itself. By default,
+       * this method creates a `shadowRoot` and adds the dom to it.
+       * However, this method may be overridden to allow an element
+       * to put its dom in another location.
+       *
+       * @method _attachDom
+       * @throws {Error}
+       * @suppress {missingReturn}
+       * @param {NodeList} dom to attach to the element.
+       * @return {Node} node to which the dom has been attached.
+       */
+      _attachDom(dom) {
+        if (this.attachShadow) {
+          if (dom) {
+            if (!this.shadowRoot) {
+              this.attachShadow({mode: 'open'});
+            }
+            this.shadowRoot.appendChild(dom);
+            return this.shadowRoot;
+          }
+        } else {
+          throw new Error('ShadowDOM not available. ' +
+            // TODO(sorvell): move to compile-time conditional when supported
+          'Polymer.Element can create dom as children instead of in ' +
+          'ShadowDOM by setting `this.root = this;\` before \`ready\`.');
+        }
+      }
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `attributeChangedCallback`.
+       *
+       * By default, attributes declared in `properties` metadata are
+       * deserialized using their `type` information to properties of the
+       * same name.  "Dash-cased" attributes are deserialzed to "camelCase"
+       * properties.
+       *
+       * @override
+       */
+      attributeChangedCallback(name, old, value) {
+        if (old !== value) {
+          let property = caseMap.dashToCamelCase(name);
+          let type = propertiesForClass(this.constructor)[property].type;
+          if (!this._hasReadOnlyEffect(property)) {
+            this._attributeToProperty(name, value, type);
+          }
+        }
+      }
+
+      /**
+       * When using the ShadyCSS scoping and custom property shim, causes all
+       * shimmed styles in this element (and its subtree) to be updated
+       * based on current custom property values.
+       *
+       * The optional parameter overrides inline custom property styles with an
+       * object of properties where the keys are CSS properties, and the values
+       * are strings.
+       *
+       * Example: `this.updateStyles({'--color': 'blue'})`
+       *
+       * These properties are retained unless a value of `null` is set.
+       *
+       * @param {Object=} properties Bag of custom property key/values to
+       *   apply to this element.
+       */
+      updateStyles(properties) {
+        if (window.ShadyCSS) {
+          window.ShadyCSS.styleSubtree(this, properties);
+        }
+      }
+
+      /**
+       * Rewrites a given URL relative to a base URL. The base URL defaults to
+       * the original location of the document containing the `dom-module` for
+       * this element. This method will return the same URL before and after
+       * bundling.
+       *
+       * @param {string} url URL to resolve.
+       * @param {string=} base Optional base URL to resolve against, defaults
+       * to the element's `importPath`
+       * @return {string} Rewritten URL relative to base
+       */
+      resolveUrl(url, base) {
+        if (!base && this.importPath) {
+          base = Polymer.ResolveUrl.resolveUrl(this.importPath);
+        }
+        return Polymer.ResolveUrl.resolveUrl(url, base);
+      }
+
+    }
+
+    return PolymerElement;
+  });
+
+  /**
+   * Provides basic tracking of element definitions (registrations) and
+   * instance counts.
+   *
+   * @namespace
+   */
+  Polymer.telemetry = {
+    /**
+     * Total number of Polymer element instances created.
+     * @type {number}
+     */
+    instanceCount: 0,
+    /**
+     * Array of Polymer element classes that have been finalized.
+     * @type {Array<Polymer.Element>}
+     */
+    registrations: [],
+    /**
+     * @private
+     */
+    _regLog: function(prototype) {
+      console.log('[' + prototype.is + ']: registered')
+    },
+    /**
+     * Registers a class prototype for telemetry purposes.
+     * @protected
+     */
+    register: function(prototype) {
+      this.registrations.push(prototype);
+      Polymer.log && this._regLog(prototype);
+    },
+    /**
+     * Logs all elements registered with an `is` to the console.
+     * @public
+     */
+    dumpRegistrations: function() {
+      this.registrations.forEach(this._regLog);
+    }
+  };
+
+  /**
+   * When using the ShadyCSS scoping and custom property shim, causes all
+   * shimmed `styles` (via `custom-style`) in the document (and its subtree)
+   * to be updated based on current custom property values.
+   *
+   * The optional parameter overrides inline custom property styles with an
+   * object of properties where the keys are CSS properties, and the values
+   * are strings.
+   *
+   * Example: `Polymer.updateStyles({'--color': 'blue'})`
+   *
+   * These properties are retained unless a value of `null` is set.
+   *
+   * @param {Object=} properties Bag of custom property key/values to
+   *   apply to the document.
+   */
+  Polymer.updateStyles = function(props) {
+    if (window.ShadyCSS) {
+      window.ShadyCSS.styleDocument(props);
+    }
+  };
+
+  /**
+   * Globally settable property that is automatically assigned to
+   * `Polymer.ElementMixin` instances, useful for binding in templates to
+   * make URL's relative to an application's root.  Defaults to the main
+   * document URL, but can be overridden by users.  It may be useful to set
+   * `Polymer.rootPath` to provide a stable application mount path when
+   * using client side routing.
+   *
+   * @memberof Polymer
+   */
+  Polymer.rootPath = Polymer.rootPath ||
+    Polymer.ResolveUrl.pathFromUrl(document.baseURI || window.location.href);
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/gesture-event-listeners.html b/lib/polymer2/bower_components/polymer/lib/mixins/gesture-event-listeners.html
new file mode 100644
index 00000000..714cddac
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/gesture-event-listeners.html
@@ -0,0 +1,57 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/gestures.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  const gestures = Polymer.Gestures;
+
+  /**
+   * Element class mixin that provides API for adding Polymer's cross-platform
+   * gesture events to nodes.
+   *
+   * The API is designed to be compatible with override points implemented
+   * in `Polymer.TemplateStamp` such that declarative event listeners in
+   * templates will support gesture events when this mixin is applied along with
+   * `Polymer.TemplateStamp`.
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   * @summary Element class mixin that provides API for adding Polymer's cross-platform
+   * gesture events to nodes
+   */
+  Polymer.GestureEventListeners = Polymer.dedupingMixin(function(superClass) {
+
+    return class GestureEventListeners extends superClass {
+
+      _addEventListenerToNode(node, eventName, handler) {
+        if (!gestures.addListener(node, eventName, handler) &&
+          super._addEventListenerToNode) {
+          super._addEventListenerToNode(node, eventName, handler);
+        }
+      }
+
+      _removeEventListenerFromNode(node, eventName, handler) {
+        if (!gestures.removeListener(node, eventName, handler) &&
+          super._removeEventListenerFromNode) {
+          super._removeEventListenerFromNode(node, eventName, handler);
+        }
+      }
+
+    }
+
+  });
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/mutable-data.html b/lib/polymer2/bower_components/polymer/lib/mixins/mutable-data.html
new file mode 100644
index 00000000..2cfe3d54
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/mutable-data.html
@@ -0,0 +1,180 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<script>
+(function() {
+  'use strict';
+
+  // Common implementation for mixin & behavior
+  function mutablePropertyChange(inst, property, value, old, mutableData) {
+    let isObject;
+    if (mutableData) {
+      isObject = (typeof value === 'object' && value !== null);
+      // Pull `old` for Objects from temp cache, but treat `null` as a primitive
+      if (isObject) {
+        old = inst.__dataTemp[property];
+      }
+    }
+    // Strict equality check, but return false for NaN===NaN
+    let shouldChange = (old !== value && (old === old || value === value));
+    // Objects are stored in temporary cache (cleared at end of
+    // turn), which is used for dirty-checking
+    if (isObject && shouldChange) {
+      inst.__dataTemp[property] = value;
+    }
+    return shouldChange;
+  }
+
+  /**
+   * Element class mixin to skip strict dirty-checking for objects and arrays
+   * (always consider them to be "dirty"), for use on elements utilizing
+   * `Polymer.PropertyEffects`
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will cause Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * In order to make the dirty check strategy configurable, see
+   * `Polymer.OptionalMutableData`.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse as opposed to using strict dirty checking with immutable
+   * patterns or Polymer's path notification API.
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   * @summary Element class mixin to skip strict dirty-checking for objects
+   *   and arrays
+   */
+  Polymer.MutableData = (superClass) => {
+
+    return class MutableData extends superClass {
+      /**
+       * Overrides `Polymer.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);
+      }
+
+    }
+
+  };
+
+  /**
+   * Element class mixin to add the optional ability to skip strict
+   * dirty-checking for objects and arrays (always consider them to be
+   * "dirty") by setting a `mutable-data` attribute on an element instance.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will allow Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * While this mixin adds the ability to forgo Object/Array dirty checking,
+   * the `mutableData` flag defaults to false and must be set on the instance.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse by relying on `mutableData: true` as opposed to using
+   * strict dirty checking with immutable patterns or Polymer's path notification
+   * API.
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   * @summary Element class mixin to optionally skip strict dirty-checking
+   *   for objects and arrays
+   */
+  Polymer.OptionalMutableData = (superClass) => {
+
+    return class OptionalMutableData extends superClass {
+
+      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 `Polymer.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);
+      }
+    }
+
+  };
+
+  // Export for use by legacy behavior
+  Polymer.MutableData._mutablePropertyChange = mutablePropertyChange;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/property-accessors.html b/lib/polymer2/bower_components/polymer/lib/mixins/property-accessors.html
new file mode 100644
index 00000000..6555968e
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/property-accessors.html
@@ -0,0 +1,494 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/case-map.html">
+<link rel="import" href="../utils/async.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  let caseMap = Polymer.CaseMap;
+
+  let microtask = Polymer.Async.microTask;
+
+  // Save map of native properties; this forms a blacklist or properties
+  // that won't have their values "saved" by `saveAccessorValue`, since
+  // reading from an HTMLElement accessor from the context of a prototype throws
+  const nativeProperties = {};
+  let proto = HTMLElement.prototype;
+  while (proto) {
+    let props = Object.getOwnPropertyNames(proto);
+    for (let i=0; i<props.length; i++) {
+      nativeProperties[props[i]] = true;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  /**
+   * Used to save the value of a property that will be overridden with
+   * an accessor. If the `model` is a prototype, the values will be saved
+   * in `__dataProto`, and it's up to the user (or downstream mixin) to
+   * decide how/when to set these values back into the accessors.
+   * If `model` is already an instance (it has a `__data` property), then
+   * the value will be set as a pending property, meaning the user should
+   * call `_invalidateProperties` or `_flushProperties` to take effect
+   *
+   * @param {Object} model Prototype or instance
+   * @param {string} property Name of property
+   * @private
+   */
+  function saveAccessorValue(model, property) {
+    // Don't read/store value for any native properties since they could throw
+    if (!nativeProperties[property]) {
+      let value = model[property];
+      if (value !== undefined) {
+        if (model.__data) {
+          // Adding accessor to instance; update the property
+          // It is the user's responsibility to call _flushProperties
+          model._setPendingProperty(property, value);
+        } else {
+          // Adding accessor to proto; save proto's value for instance-time use
+          if (!model.__dataProto) {
+            model.__dataProto = {};
+          } else if (!model.hasOwnProperty(goog.reflect.objectProperty('__dataProto', model))) {
+            model.__dataProto = Object.create(model.__dataProto);
+          }
+          model.__dataProto[property] = value;
+        }
+      }
+    }
+  }
+
+  /**
+   * Element class mixin that provides basic meta-programming for creating one
+   * or more property accessors (getter/setter pair) that enqueue an async
+   * (batched) `_propertiesChanged` callback.
+   *
+   * For basic usage of this mixin, simply declare attributes to observe via
+   * the standard `static get observedAttributes()`, implement `_propertiesChanged`
+   * on the class, and then call `MyClass.createPropertiesForAttributes()` once
+   * on the class to generate property accessors for each observed attribute
+   * prior to instancing.  Any `observedAttributes` will automatically be
+   * deserialized via `attributeChangedCallback` and set to the associated
+   * property using `dash-case`-to-`camelCase` convention.
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   * @summary Element class mixin for reacting to property changes from
+   *   generated property accessors.
+   */
+  Polymer.PropertyAccessors = Polymer.dedupingMixin(function(superClass) {
+
+    return class PropertyAccessors extends superClass {
+
+      /**
+       * Generates property accessors for all attributes in the standard
+       * static `observedAttributes` array.
+       *
+       * Attribute names are mapped to property names using the `dash-case` to
+       * `camelCase` convention
+       *
+       */
+      static createPropertiesForAttributes() {
+        let a$ = this.observedAttributes;
+        for (let i=0; i < a$.length; i++) {
+          this.prototype._createPropertyAccessor(caseMap.dashToCamelCase(a$[i]));
+        }
+      }
+
+      constructor() {
+        super();
+        this._initializeProperties();
+      }
+
+      attributeChangedCallback(name, old, value) {
+        if (old !== value) {
+          this._attributeToProperty(name, value);
+        }
+      }
+
+      /**
+       * Initializes the local storage for property accessors.
+       *
+       * Provided as an override point for performing any setup work prior
+       * to initializing the property accessor system.
+       *
+       * @protected
+       */
+      _initializeProperties() {
+        this.__serializing = false;
+        this.__dataCounter = 0;
+        this.__dataInvalid = false;
+        // initialize data with prototype values saved when creating accessors
+        this.__data = {};
+        this.__dataPending = null;
+        this.__dataOld = null;
+        if (this.__dataProto) {
+          this._initializeProtoProperties(this.__dataProto);
+        }
+      }
+
+      /**
+       * Called at instance time with bag of properties that were overwritten
+       * by accessors on the prototype when accessors were created.
+       *
+       * The default implementation sets these properties back into the
+       * setter at instance time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param {Object} props Bag of property values that were overwritten
+       *   when creating property accessors.
+       * @protected
+       */
+      _initializeProtoProperties(props) {
+        for (let p in props) {
+          this._setProperty(p, props[p]);
+        }
+      }
+
+      /**
+       * Ensures the element has the given attribute. If it does not,
+       * assigns the given value to the attribute.
+       *
+       *
+       * @method _ensureAttribute
+       * @param {string} attribute Name of attribute to ensure is set.
+       * @param {string} value of the attribute.
+       */
+      _ensureAttribute(attribute, value) {
+        if (!this.hasAttribute(attribute)) {
+          this._valueToNodeAttribute(this, value, attribute);
+        }
+      }
+
+      /**
+       * Deserializes an attribute to its associated property.
+       *
+       * This method calls the `_deserializeValue` method to convert the string to
+       * a typed value.
+       *
+       * @method _attributeToProperty
+       * @param {string} attribute Name of attribute to deserialize.
+       * @param {string} value of the attribute.
+       * @param {*} type type to deserialize to.
+       */
+      _attributeToProperty(attribute, value, type) {
+        // Don't deserialize back to property if currently reflecting
+        if (!this.__serializing) {
+          let property = caseMap.dashToCamelCase(attribute);
+          this[property] = this._deserializeValue(value, type);
+        }
+      }
+
+      /**
+       * Serializes a property to its associated attribute.
+       *
+       * @method _propertyToAttribute
+       * @param {string} property Property name to reflect.
+       * @param {string=} attribute Attribute name to reflect.
+       * @param {*=} value Property value to refect.
+       */
+      _propertyToAttribute(property, attribute, value) {
+        this.__serializing = true;
+        value = (arguments.length < 3) ? this[property] : value;
+        this._valueToNodeAttribute(this, value,
+          attribute || caseMap.camelToDashCase(property));
+        this.__serializing = false;
+      }
+
+      /**
+       * Sets a typed value to an HTML attribute on a node.
+       *
+       * This method calls the `_serializeValue` method to convert the typed
+       * value to a string.  If the `_serializeValue` method returns `undefined`,
+       * the attribute will be removed (this is the default for boolean
+       * type `false`).
+       *
+       * @method _valueToNodeAttribute
+       * @param {Element} node Element to set attribute to.
+       * @param {*} value Value to serialize.
+       * @param {string} attribute Attribute name to serialize to.
+       */
+      _valueToNodeAttribute(node, value, attribute) {
+        let str = this._serializeValue(value);
+        if (str === undefined) {
+          node.removeAttribute(attribute);
+        } else {
+          node.setAttribute(attribute, str);
+        }
+      }
+
+      /**
+       * Converts a typed JavaScript value to a string.
+       *
+       * This method is called by Polymer when setting JS property values to
+       * HTML attributes.  Users may override this method on Polymer element
+       * prototypes to provide serialization for custom types.
+       *
+       * @method _serializeValue
+       * @param {*} value Property value to serialize.
+       * @return {string | undefined} String serialized from the provided property value.
+       */
+      _serializeValue(value) {
+        /* eslint-disable no-fallthrough */
+        switch (typeof value) {
+          case 'boolean':
+            return value ? '' : undefined;
+
+          case 'object':
+            if (value instanceof Date) {
+              return value.toString();
+            } else if (value) {
+              try {
+                return JSON.stringify(value);
+              } catch(x) {
+                return '';
+              }
+            }
+
+          default:
+            return value != null ? value.toString() : undefined;
+        }
+      }
+
+      /**
+       * Converts a string to a typed JavaScript value.
+       *
+       * This method is called by Polymer when reading HTML attribute values to
+       * JS properties.  Users may override this method on Polymer element
+       * prototypes to provide deserialization for custom `type`s.  Note,
+       * the `type` argument is the value of the `type` field provided in the
+       * `properties` configuration object for a given property, and is
+       * by convention the constructor for the type to deserialize.
+       *
+       * Note: The return value of `undefined` is used as a sentinel value to
+       * indicate the attribute should be removed.
+       *
+       * @method _deserializeValue
+       * @param {string} value Attribute value to deserialize.
+       * @param {*} type Type to deserialize the string to.
+       * @return {*} Typed value deserialized from the provided string.
+       */
+      _deserializeValue(value, type) {
+        /**
+         * @type {*}
+         */
+        let outValue;
+        switch (type) {
+          case Number:
+            outValue = Number(value);
+            break;
+
+          case Boolean:
+            outValue = (value !== null);
+            break;
+
+          case Object:
+            try {
+              outValue = JSON.parse(value);
+            } catch(x) {
+              // allow non-JSON literals like Strings and Numbers
+            }
+            break;
+
+          case Array:
+            try {
+              outValue = JSON.parse(value);
+            } catch(x) {
+              outValue = null;
+              console.warn('Polymer::Attributes: couldn`t decode Array as JSON');
+            }
+            break;
+
+          case Date:
+            outValue = new Date(value);
+            break;
+
+          case String:
+          default:
+            outValue = value;
+            break;
+        }
+
+        return outValue;
+      }
+      /* eslint-enable no-fallthrough */
+
+      /**
+       * Creates a setter/getter pair for the named property with its own
+       * local storage.  The getter returns the value in the local storage,
+       * and the setter calls `_setProperty`, which updates the local storage
+       * for the property and enqueues a `_propertiesChanged` callback.
+       *
+       * This method may be called on a prototype or an instance.  Calling
+       * this method may overwrite a property value that already exists on
+       * the prototype/instance by creating the accessor.  When calling on
+       * a prototype, any overwritten values are saved in `__dataProto`,
+       * and it is up to the subclasser to decide how/when to set those
+       * properties back into the accessor.  When calling on an instance,
+       * the overwritten value is set via `_setPendingProperty`, and the
+       * user should call `_invalidateProperties` or `_flushProperties`
+       * for the values to take effect.
+       *
+       * @param {string} property Name of the property
+       * @param {boolean=} readOnly When true, no setter is created; the
+       *   protected `_setProperty` function must be used to set the property
+       * @protected
+       */
+      _createPropertyAccessor(property, readOnly) {
+        saveAccessorValue(this, property);
+        Object.defineProperty(this, property, {
+          get: function() {
+            return this.__data[property];
+          },
+          set: readOnly ? function() { } : function(value) {
+            this._setProperty(property, value);
+          }
+        });
+      }
+
+      /**
+       * Updates the local storage for a property (via `_setPendingProperty`)
+       * and enqueues a `_proeprtiesChanged` callback.
+       *
+       * @param {string} property Name of the property
+       * @param {*} value Value to set
+       * @protected
+       */
+      _setProperty(property, value) {
+        if (this._setPendingProperty(property, value)) {
+          this._invalidateProperties();
+        }
+      }
+
+      /**
+       * Updates the local storage for a property, records the previous value,
+       * and adds it to the set of "pending changes" that will be passed to the
+       * `_propertiesChanged` callback.  This method does not enqueue the
+       * `_propertiesChanged` callback.
+       *
+       * @param {string} property Name of the property
+       * @param {*} value Value to set
+       * @protected
+       */
+      _setPendingProperty(property, value) {
+        let old = this.__data[property];
+        if (this._shouldPropertyChange(property, value, old)) {
+          if (!this.__dataPending) {
+            this.__dataPending = {};
+            this.__dataOld = {};
+          }
+          // Ensure old is captured from the last turn
+          if (!(property in this.__dataOld)) {
+            this.__dataOld[property] = old;
+          }
+          this.__data[property] = value;
+          this.__dataPending[property] = value;
+          return true;
+        }
+      }
+
+      /**
+       * Returns true if the specified property has a pending change.
+       *
+       * @param {string} prop Property name
+       * @return {boolean} True if property has a pending change
+       * @protected
+       */
+      _isPropertyPending(prop) {
+        return this.__dataPending && (prop in this.__dataPending);
+      }
+
+      /**
+       * Marks the properties as invalid, and enqueues an async
+       * `_propertiesChanged` callback.
+       *
+       * @protected
+       */
+      _invalidateProperties() {
+        if (!this.__dataInvalid) {
+          this.__dataInvalid = true;
+          microtask.run(() => {
+            if (this.__dataInvalid) {
+              this.__dataInvalid = false;
+              this._flushProperties();
+            }
+          });
+        }
+      }
+
+      /**
+       * Calls the `_propertiesChanged` callback with the current set of
+       * pending changes (and old values recorded when pending changes were
+       * set), and resets the pending set of changes.
+       *
+       * @protected
+       */
+      _flushProperties() {
+        let oldProps = this.__dataOld;
+        let changedProps = this.__dataPending;
+        this.__dataPending = null;
+        this.__dataCounter++;
+        this._propertiesChanged(this.__data, changedProps, oldProps);
+        this.__dataCounter--;
+      }
+
+      /**
+       * Callback called when any properties with accessors created via
+       * `_createPropertyAccessor` have been set.
+       *
+       * @param {Object} currentProps Bag of all current accessor values
+       * @param {Object} changedProps Bag of properties changed since the last
+       *   call to `_propertiesChanged`
+       * @param {Object} oldProps Bag of previous values for each property
+       *   in `changedProps`
+       * @protected
+       */
+      _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
+      }
+
+      /**
+       * Method called to determine whether a property value should be
+       * considered as a change and cause the `_propertiesChanged` callback
+       * to be enqueued.
+       *
+       * The default implementation returns `true` for primitive types if a
+       * strict equality check fails, and returns `true` for all Object/Arrays.
+       * The method always returns false for `NaN`.
+       *
+       * Override this method to e.g. provide stricter checking for
+       * Objects/Arrays when using immutable patterns.
+       *
+       * @param {string} property Property name
+       * @param {*} value New property value
+       * @param {*} old Previous property value
+       * @return {boolean} Whether the property should be considered a change
+       *   and enqueue a `_proeprtiesChanged` callback
+       * @protected
+       */
+      _shouldPropertyChange(property, value, old) {
+        return (
+          // Strict equality check
+          (old !== value &&
+           // This ensures (old==NaN, value==NaN) always returns false
+           (old === old || value === value))
+        );
+      }
+
+    }
+
+  });
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/property-effects.html b/lib/polymer2/bower_components/polymer/lib/mixins/property-effects.html
new file mode 100644
index 00000000..de11cd4d
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/property-effects.html
@@ -0,0 +1,2204 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/path.html">
+<!-- for notify, reflect -->
+<link rel="import" href="../utils/case-map.html">
+<link rel="import" href="property-accessors.html">
+<!-- for annotated effects -->
+<link rel="import" href="template-stamp.html">
+
+
+<script>
+(function() {
+
+  'use strict';
+
+  const CaseMap = Polymer.CaseMap;
+
+  // Monotonically increasing unique ID used for de-duping effects triggered
+  // from multiple properties in the same turn
+  let dedupeId = 0;
+
+  // Property effect types; effects are stored on the prototype using these keys
+  const TYPES = {
+    ANY: '__propertyEffects',
+    COMPUTE: '__computeEffects',
+    REFLECT: '__reflectEffects',
+    NOTIFY: '__notifyEffects',
+    PROPAGATE: '__propagateEffects',
+    OBSERVE: '__observeEffects',
+    READ_ONLY: '__readOnly'
+  }
+
+  /**
+   * Ensures that the model has an own-property map of effects for the given type.
+   * The model may be a prototype or an instance.
+   *
+   * Property effects are stored as arrays of effects by property in a map,
+   * by named type on the model. e.g.
+   *
+   *   __computeEffects: {
+   *     foo: [ ... ],
+   *     bar: [ ... ]
+   *   }
+   *
+   * If the model does not yet have an effect map for the type, one is created
+   * and returned.  If it does, but it is not an own property (i.e. the
+   * prototype had effects), the the map is deeply cloned and the copy is
+   * set on the model and returned, ready for new effects to be added.
+   *
+   * @param {Object} model Prototype or instance
+   * @param {string} type Property effect type
+   * @return {Object} The own-property map of effects for the given type
+   * @private
+   */
+  function ensureOwnEffectMap(model, type) {
+    let effects = model[type];
+    if (!effects) {
+      effects = model[type] = {};
+    } else if (!model.hasOwnProperty(type)) {
+      effects = model[type] = Object.create(model[type]);
+      for (let p in effects) {
+        let protoFx = effects[p];
+        let instFx = effects[p] = Array(protoFx.length);
+        for (let i=0; i<protoFx.length; i++) {
+          instFx[i] = protoFx[i];
+        }
+      }
+    }
+    return effects;
+  }
+
+  // -- effects ----------------------------------------------
+
+  /**
+   * Runs all effects of a given type for the given set of property changes
+   * on an instance.
+   *
+   * @param {Object} inst The instance with effects to run
+   * @param {string} type Type of effect to run
+   * @param {Object} props Bag of current property changes
+   * @param {Object=} oldProps Bag of previous values for changed properties
+   * @private
+   */
+  function runEffects(inst, effects, props, oldProps, hasPaths) {
+    if (effects) {
+      let ran;
+      let id = dedupeId++;
+      for (let prop in props) {
+        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths)) {
+          ran = true;
+        }
+      }
+      return ran;
+    }
+  }
+
+  /**
+   * Runs a list of effects for a given property.
+   *
+   * @param {Object} inst The instance with effects to run
+   * @param {Array} effects Array of effects
+   * @param {number} id Effect run id used for de-duping effects
+   * @param {string} prop Name of changed property
+   * @param {*} value Value of changed property
+   * @param {*} old Previous value of changed property
+   * @private
+   */
+  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths) {
+    let ran;
+    let rootProperty = hasPaths ? Polymer.Path.root(prop) : prop;
+    let fxs = effects[rootProperty];
+    if (fxs) {
+      for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
+        if ((!fx.info || fx.info.lastRun !== dedupeId) &&
+            (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
+          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths);
+          if (fx.info) {
+            fx.info.lastRun = dedupeId;
+          }
+          ran = true;
+        }
+      }
+    }
+    return ran;
+  }
+
+  /**
+   * Determines whether a property/path that has changed matches the trigger
+   * criteria for an effect.  A trigger is a descriptor with the following
+   * structure, which matches the descriptors returned from `parseArg`.
+   * e.g. for `foo.bar.*`:
+   * ```
+   * trigger: {
+   *   name: 'a.b',
+   *   structured: true,
+   *   wildcard: true
+   * }
+   * ```
+   * If no trigger is given, the path is deemed to match.
+   *
+   * @param {string} path Path or property that changed
+   * @param {Object} trigger Descriptor
+   * @return {boolean} Whether the path matched the trigger
+   */
+  function pathMatchesTrigger(path, trigger) {
+    if (trigger) {
+      let triggerPath = trigger.name;
+      return (triggerPath == path) ||
+        (trigger.structured && Polymer.Path.isAncestor(triggerPath, path)) ||
+        (trigger.wildcard && Polymer.Path.isDescendant(triggerPath, path));
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * Implements the "observer" effect.
+   *
+   * Calls the method with `info.methodName` on the instance, passing the
+   * new and old values.
+   *
+   * @param {Object} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runObserverEffect(inst, property, props, oldProps, info) {
+    let fn = inst[info.methodName];
+    let changedProp = info.property;
+    if (fn) {
+      fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);
+    } else {
+      console.warn('observer method `' + info.methodName + '` not defined');
+    }
+  }
+
+  /**
+   * Runs "notify" effects for a set of changed properties.
+   *
+   * This method differs from the generic `runEffects` method in that it
+   * will dispatch path notification events in the case that the property
+   * changed was a path and the root property for that path didn't have a
+   * "notify" effect.  This is to maintain 1.0 behavior that did not require
+   * `notify: true` to ensure object sub-property notifications were
+   * sent.
+   *
+   * @param {Element} inst The instance with effects to run
+   * @param {Object} props Bag of current property changes
+   * @param {Object} oldProps Bag of previous values for changed properties
+   * @private
+   */
+  function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {
+    // Notify
+    let fxs = inst.__notifyEffects;
+    let notified;
+    let id = dedupeId++;
+    // Try normal notify effects; if none, fall back to try path notification
+    for (let prop in notifyProps) {
+      if (notifyProps[prop]) {
+        if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {
+          notified = true;
+        } else if (hasPaths && notifyPath(inst, prop, props)) {
+          notified = true;
+        }
+      }
+    }
+    // Flush host if we actually notified and host was batching
+    let host;
+    if (notified && (host = inst.__dataHost) && host._flushProperties) {
+      host._flushProperties();
+    }
+  }
+
+  /**
+   * Dispatches {property}-changed events with path information in the detail
+   * object to indicate a sub-path of the property was changed.
+   *
+   * @param {Element} inst The element from which to fire the event
+   * @param {string} path The path that was changed
+   * @param {*} value
+   * @private
+   */
+  function notifyPath(inst, path, props) {
+    let rootProperty = Polymer.Path.root(path);
+    if (rootProperty !== path) {
+      let eventName = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
+      dispatchNotifyEvent(inst, eventName, props[path], path);
+      return true;
+    }
+  }
+
+  /**
+   * Dispatches {property}-changed events to indicate a property (or path)
+   * changed.
+   *
+   * @param {Element} inst The element from which to fire the event
+   * @param {string} eventName The name of the event to send ('{property}-changed')
+   * @param {*} value The value of the changed property
+   * @param {string | null | undefined} path If a sub-path of this property changed, the path
+   *   that changed (optional).
+   * @private
+   */
+  function dispatchNotifyEvent(inst, eventName, value, path) {
+    let detail = {
+      value: value,
+      queueProperty: true
+    };
+    if (path) {
+      detail.path = path;
+    }
+    inst.dispatchEvent(new CustomEvent(eventName, { detail }));
+  }
+
+  /**
+   * Implements the "notify" effect.
+   *
+   * Dispatches a non-bubbling event named `info.eventName` on the instance
+   * with a detail object containing the new `value`.
+   *
+   * @param {Element} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {
+    let rootProperty = hasPaths ? Polymer.Path.root(property) : property;
+    let path = rootProperty != property ? property : null;
+    let value = path ? Polymer.Path.get(inst, path) : inst.__data[property];
+    if (path && value === undefined) {
+      value = props[property];  // specifically for .splices
+    }
+    dispatchNotifyEvent(inst, info.eventName, value, path);
+  }
+
+  /**
+   * Adds a 2-way binding notification event listener to the node specified
+   *
+   * @param {Object} node Child element to add listener to
+   * @param {Object} inst Host element instance to handle notification event
+   * @param {Object} info Listener metadata stored via addAnnotatedListener
+   * @private
+   */
+  function addNotifyListener(node, inst, info) {
+    node.addEventListener(info.event, function(e) {
+      handleNotification(e, inst, info.property, info.path, info.negate);
+    });
+  }
+
+  /**
+   * Handler function for 2-way notification events. Receives context
+   * information captured in the `addNotifyListener` closure from the
+   * `__notifyListeners` metadata.
+   *
+   * Sets the value of the notified property to the host property or path.  If
+   * the event contained path information, translate that path to the host
+   * scope's name for that path first.
+   *
+   * @param {Event} e Notification event (e.g. '<property>-changed')
+   * @param {Object} inst Host element instance handling the notification event
+   * @param {string} property Child element property that was bound
+   * @param {string} path Host property/path that was bound
+   * @param {boolean} negate Whether the binding was negated
+   * @private
+   */
+  function handleNotification(e, inst, property, path, negate) {
+    let value;
+    let targetPath = e.detail && e.detail.path;
+    if (targetPath) {
+      path = Polymer.Path.translate(property, path, targetPath);
+      value = e.detail && e.detail.value;
+    } else {
+      value = e.target[property];
+    }
+    value = negate ? !value : value;
+    setPropertyFromNotification(inst, path, value, e);
+  }
+
+  /**
+   * Called by 2-way binding notification event listeners to set a property
+   * or path to the host based on a notification from a bound child.
+   *
+   * @param {string} path Path on this instance to set
+   * @param {*} value Value to set to given path
+   * @protected
+   */
+  function setPropertyFromNotification(inst, path, value, event) {
+    let detail = event.detail;
+    if (detail && detail.queueProperty) {
+      if (!inst.__readOnly || !inst.__readOnly[path]) {
+        inst._setPendingPropertyOrPath(path, value, true, Boolean(detail.path));
+      }
+    } else {
+      inst.set(path, value);
+    }
+  }
+
+  /**
+   * Implements the "reflect" effect.
+   *
+   * Sets the attribute named `info.attrName` to the given property value.
+   *
+   * @param {Object} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runReflectEffect(inst, property, props, oldProps, info) {
+    let value = inst.__data[property];
+    if (Polymer.sanitizeDOMValue) {
+      value = Polymer.sanitizeDOMValue(value, info.attrName, 'attribute', inst);
+    }
+    inst._propertyToAttribute(property, info.attrName, value);
+  }
+
+  /**
+   * Runs "computed" effects for a set of changed properties.
+   *
+   * This method differs from the generic `runEffects` method in that it
+   * continues to run computed effects based on the output of each pass until
+   * there are no more newly computed properties.  This ensures that all
+   * properties that will be computed by the initial set of changes are
+   * computed before other effects (binding propagation, observers, and notify)
+   * run.
+   *
+   * @param {Element} inst The instance the effect will be run on
+   * @param {Object} changedProps Bag of changed properties
+   * @param {Object} oldProps Bag of previous values for changed properties
+   * @private
+   */
+  function runComputedEffects(inst, changedProps, oldProps, hasPaths) {
+    let computeEffects = inst.__computeEffects;
+    if (computeEffects) {
+      let inputProps = changedProps;
+      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {
+        Object.assign(oldProps, inst.__dataOld);
+        Object.assign(changedProps, inst.__dataPending);
+        inputProps = inst.__dataPending;
+        inst.__dataPending = null;
+      }
+    }
+  }
+
+  /**
+   * Implements the "computed property" effect by running the method with the
+   * values of the arguments specified in the `info` object and setting the
+   * return value to the computed property specified.
+   *
+   * @param {Object} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runComputedEffect(inst, property, props, oldProps, info) {
+    let result = runMethodEffect(inst, property, props, oldProps, info);
+    let computedProp = info.methodInfo;
+    if (inst.__propertyEffects && inst.__propertyEffects[computedProp]) {
+      inst._setPendingProperty(computedProp, result, true);
+    } else {
+      inst[computedProp] = result;
+    }
+  }
+
+  /**
+   * Computes path changes based on path links set up using the `linkPaths`
+   * API.
+   *
+   * @param {Element} inst The instance whose props are changing
+   * @param {Object} changedProps Bag of changed properties
+   * @private
+   */
+  function computeLinkedPaths(inst, changedProps, hasPaths) {
+    let links;
+    if (hasPaths && (links = inst.__dataLinkedPaths)) {
+      const cache = inst.__dataTemp;
+      let link;
+      for (let a in links) {
+        let b = links[a];
+        for (let path in changedProps) {
+          if (Polymer.Path.isDescendant(a, path)) {
+            link = Polymer.Path.translate(a, b, path);
+            cache[link] = changedProps[link] = changedProps[path];
+            let notifyProps = inst.__dataToNotify || (inst.__dataToNotify = {});
+            notifyProps[link] = true;
+          } else if (Polymer.Path.isDescendant(b, path)) {
+            link = Polymer.Path.translate(b, a, path);
+            cache[link] = changedProps[link] = changedProps[path];
+            let notifyProps = inst.__dataToNotify || (inst.__dataToNotify = {});
+            notifyProps[link] = true;
+          }
+        }
+      }
+    }
+  }
+
+  // -- bindings ----------------------------------------------
+
+  /**
+   * Adds "binding" property effects for the template annotation
+   * ("note" for short) and node index specified.  These may either be normal
+   * "binding" effects (property/path bindings) or "method binding"
+   * effects, aka inline computing functions, depending on the type of binding
+   * detailed in the note.
+   *
+   * @param {Object} model Prototype or instance
+   * @param {Object} note Annotation note returned from Annotator
+   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
+   *   note applies to
+   * @param {Object=} dynamicFns Map indicating whether method names should
+   *   be included as a dependency to the effect.
+   * @private
+   */
+  function addBindingEffect(model, note, index, dynamicFns) {
+    for (let i=0; i<note.parts.length; i++) {
+      let part = note.parts[i];
+      if (part.signature) {
+        addMethodBindingEffect(model, note, part, index, dynamicFns);
+      } else if (!part.literal) {
+        if (note.kind === 'attribute' && note.name[0] === '-') {
+          console.warn('Cannot set attribute ' + note.name +
+            ' because "-" is not a valid attribute starting character');
+        } else {
+          model._addPropertyEffect(Polymer.Path.root(part.value), TYPES.PROPAGATE, {
+            fn: runBindingEffect,
+            info:  {
+              kind: note.kind,
+              index: index,
+              name: note.name,
+              propertyName: note.propertyName,
+              value: part.value,
+              isCompound: note.isCompound,
+              compoundIndex: part.compoundIndex,
+              event: part.event,
+              customEvent: part.customEvent,
+              negate: part.negate
+            }
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Implements the "binding" (property/path binding) effect.
+   *
+   * @param {Element} inst The instance the effect will be run on
+   * @param {string} path Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runBindingEffect(inst, path, props, oldProps, info, hasPaths) {
+    let value;
+    let node = inst.__templateNodes[info.index];
+    // Subpath notification: transform path and set to client
+    // e.g.: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop
+    if (hasPaths && (path.length > info.value.length) &&
+        (info.kind == 'property') && !info.isCompound &&
+        node.__propertyEffects && node.__propertyEffects[info.name]) {
+      let value = props[path];
+      path = Polymer.Path.translate(info.value, info.name, path);
+      if (node._setPendingPropertyOrPath(path, value, false, true)) {
+        inst._enqueueClient(node);
+      }
+    } else {
+      // Root or deeper path was set; extract bound path value
+      // e.g.: foo="{{obj.sub}}", path: 'obj', set 'foo'=obj.sub
+      //   or: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo'=obj.sub
+      if (path != info.value) {
+        value = Polymer.Path.get(inst, info.value);
+      } else {
+        if (hasPaths && Polymer.Path.isPath(path)) {
+          value = Polymer.Path.get(inst, path);
+        } else {
+          value = inst.__data[path];
+        }
+      }
+      // Propagate value to child
+      applyBindingValue(inst, info, value);
+    }
+  }
+
+  /**
+   * Sets the value for an "binding" (binding) effect to a node,
+   * either as a property or attribute.
+   *
+   * @param {Object} inst The instance owning the binding effect
+   * @param {Object} info Effect metadata
+   * @param {*} value Value to set
+   * @private
+   */
+  function applyBindingValue(inst, info, value) {
+    let node = inst.__templateNodes[info.index];
+    value = computeBindingValue(node, value, info);
+    if (Polymer.sanitizeDOMValue) {
+      value = Polymer.sanitizeDOMValue(value, info.name, info.kind, node);
+    }
+    if (info.kind == 'attribute') {
+      // Attribute binding
+      inst._valueToNodeAttribute(node, value, info.name);
+    } else {
+      // Property binding
+      let prop = info.name;
+      if (node.__propertyEffects && node.__propertyEffects[prop]) {
+        if (!node.__readOnly || !node.__readOnly[prop]) {
+          if (node._setPendingProperty(prop, value)) {
+            inst._enqueueClient(node);
+          }
+        }
+      } else  {
+        inst._setUnmanagedPropertyToNode(node, prop, value);
+      }
+    }
+  }
+
+  /**
+   * Transforms an "binding" effect value based on compound & negation
+   * effect metadata, as well as handling for special-case properties
+   *
+   * @param {Node} node Node the value will be set to
+   * @param {*} value Value to set
+   * @param {Object} info Effect metadata
+   * @return {*} Transformed value to set
+   * @private
+   */
+  function computeBindingValue(node, value, info) {
+    if (info.negate) {
+      value = !value;
+    }
+    if (info.isCompound) {
+      let storage = node.__dataCompoundStorage[info.name];
+      storage[info.compoundIndex] = value;
+      value = storage.join('');
+    }
+    if (info.kind !== 'attribute') {
+      // Some browsers serialize `undefined` to `"undefined"`
+      if (info.name === 'textContent' ||
+          (node.localName == 'input' && info.name == 'value')) {
+        value = value == undefined ? '' : value;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Adds "binding method" property effects for the template binding
+   * ("note" for short), part metadata, and node index specified.
+   *
+   * @param {Object} model Prototype or instance
+   * @param {Object} note Binding note returned from Annotator
+   * @param {Object} part The compound part metadata
+   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
+   *   note applies to
+   * @param {Object=} dynamicFns Map indicating whether method names should
+   *   be included as a dependency to the effect.
+   * @private
+   */
+  function addMethodBindingEffect(model, note, part, index, dynamicFns) {
+    createMethodEffect(model, part.signature, TYPES.PROPAGATE,
+      runMethodBindingEffect, {
+        index: index,
+        isCompound: note.isCompound,
+        compoundIndex: part.compoundIndex,
+        kind: note.kind,
+        name: note.name,
+        negate: part.negate,
+        part: part
+      }, dynamicFns
+    );
+  }
+
+  /**
+   * Implements the "binding method" (inline computed function) effect.
+   *
+   * Runs the method with the values of the arguments specified in the `info`
+   * object and setting the return value to the node property/attribute.
+   *
+   * @param {Object} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runMethodBindingEffect(inst, property, props, oldProps, info) {
+    let val = runMethodEffect(inst, property, props, oldProps, info);
+    applyBindingValue(inst, info.methodInfo, val);
+  }
+
+  /**
+   * Post-processes template bindings (notes for short) provided by the
+   * Bindings library for use by the effects system:
+   * - Parses bindings for methods into method `signature` objects
+   * - Memoizes the root property for path bindings
+   * - Recurses into nested templates and processes those templates and
+   *   extracts any host properties, which are set to the template's
+   *   `_content._hostProps`
+   * - Adds bindings from the host to <template> elements for any nested
+   *   template's lexically bound "host properties"; template handling
+   *   elements can then add accessors to the template for these properties
+   *   to forward host properties into template instances accordingly.
+   *
+   * @param {Array<Object>} notes List of notes to process; the notes are
+   *   modified in place.
+   * @private
+   */
+  function processAnnotations(notes) {
+    if (!notes._processed) {
+      for (let i=0; i<notes.length; i++) {
+        let note = notes[i];
+        // Parse bindings for methods & path roots (models)
+        for (let j=0; j<note.bindings.length; j++) {
+          let b = note.bindings[j];
+          for (let k=0; k<b.parts.length; k++) {
+            let p = b.parts[k];
+            if (!p.literal) {
+              p.signature = parseMethod(p.value);
+              if (!p.signature) {
+                p.rootProperty = Polymer.Path.root(p.value);
+              }
+            }
+          }
+        }
+        // Recurse into nested templates & bind host props
+        if (note.templateContent) {
+          processAnnotations(note.templateContent._notes);
+          let hostProps = note.templateContent._hostProps =
+            discoverTemplateHostProps(note.templateContent._notes);
+          let bindings = [];
+          for (let prop in hostProps) {
+            bindings.push({
+              index: note.index,
+              kind: 'property',
+              name: '_host_' + prop,
+              parts: [{
+                mode: '{',
+                value: prop
+              }]
+            });
+          }
+          note.bindings = note.bindings.concat(bindings);
+        }
+      }
+      notes._processed = true;
+    }
+  }
+
+  /**
+   * Finds all property usage in templates (property/path bindings and function
+   * arguments) and returns the path roots as keys in a map. Each outer template
+   * merges inner _hostProps to propagate inner host property needs to outer
+   * templates.
+   *
+   * @param {Array<Object>} notes List of notes to process for a given template
+   * @return {Object<string,boolean>} Map of host properties that the template
+   *   (or any nested templates) uses
+   * @private
+   */
+  function discoverTemplateHostProps(notes) {
+    let hostProps = {};
+    for (let i=0, n; (i<notes.length) && (n=notes[i]); i++) {
+      // Find all bindings to parent.* and spread them into _parentPropChain
+      for (let j=0, b$=n.bindings, b; (j<b$.length) && (b=b$[j]); j++) {
+        for (let k=0, p$=b.parts, p; (k<p$.length) && (p=p$[k]); k++) {
+          if (p.signature) {
+            let args = p.signature.args;
+            for (let kk=0; kk<args.length; kk++) {
+              let rootProperty = args[kk].rootProperty;
+              if (rootProperty) {
+                hostProps[rootProperty] = true;
+              }
+            }
+            hostProps[p.signature.methodName] = true;
+          } else {
+            if (p.rootProperty) {
+              hostProps[p.rootProperty] = true;
+            }
+          }
+        }
+      }
+      // Merge child _hostProps into this _hostProps
+      if (n.templateContent) {
+        let templateHostProps = n.templateContent._hostProps;
+        Object.assign(hostProps, templateHostProps);
+      }
+    }
+    return hostProps;
+  }
+
+  /**
+   * Returns true if a binding's metadata meets all the requirements to allow
+   * 2-way binding, and therefore a <property>-changed event listener should be
+   * added:
+   * - used curly braces
+   * - is a property (not attribute) binding
+   * - is not a textContent binding
+   * - is not compound
+   *
+   * @param {Object} binding Binding metadata
+   * @return {boolean} True if 2-way listener should be added
+   * @private
+   */
+  function shouldAddListener(binding) {
+    return binding.name &&
+           binding.kind != 'attribute' &&
+           binding.kind != 'text' &&
+           !binding.isCompound &&
+           binding.parts[0].mode === '{';
+  }
+
+  /**
+   * Sets up a prototypical `__notifyListeners` metadata array to be used at
+   * instance time to add event listeners for 2-way bindings.
+   *
+   * @param {Object} model Prototype (instances not currently supported)
+   * @param {number} index Index into `__templateNodes` list of annotated nodes that the
+   *   event should be added to
+   * @param {string} property Property of target node to listen for changes
+   * @param {string} path Host path that the change should be propagated to
+   * @param {string=} event A custom event name to listen for (e.g. via the
+   *   `{{prop::eventName}}` syntax)
+   * @param {boolean=} negate Whether the notified value should be negated before
+   *   setting to host path
+   * @private
+   */
+  function addAnnotatedListener(model, index, property, path, event, negate) {
+    let eventName = event ||
+      (CaseMap.camelToDashCase(property) + '-changed');
+    model.__notifyListeners = model.__notifyListeners || [];
+    model.__notifyListeners.push({
+      index: index,
+      property: property,
+      path: path,
+      event: eventName,
+      negate: negate
+    });
+  }
+
+  /**
+   * Adds all 2-way binding notification listeners to a host based on
+   * `__notifyListeners` metadata recorded by prior calls to`addAnnotatedListener`
+   *
+   * @param {Object} inst Host element instance
+   * @private
+   */
+  function setupNotifyListeners(inst) {
+    let b$ = inst.__notifyListeners;
+    for (let i=0, l=b$.length, info; (i<l) && (info=b$[i]); i++) {
+      let node = inst.__templateNodes[info.index];
+      addNotifyListener(node, inst, info);
+    }
+  }
+
+  /**
+   * On the `inst` element that was previously bound, uses `inst.__templateNotes`
+   * to setup compound binding storage structures onto the bound
+   * nodes (`inst.__templateNodes`).
+   * (`inst._, and 2-way binding event listeners are also added.)
+   *
+   * @param {Object} inst Instance that bas been previously bound
+   * @private
+   */
+  function setupBindings(inst) {
+    let notes = inst.__templateNotes;
+    if (notes.length) {
+      for (let i=0; i < notes.length; i++) {
+        let note = notes[i];
+        let node = inst.__templateNodes[i];
+        node.__dataHost = inst;
+        if (note.bindings) {
+          setupCompoundBinding(note, node);
+        }
+      }
+    }
+    if (inst.__notifyListeners) {
+      setupNotifyListeners(inst);
+    }
+  }
+
+  // -- for method-based effects (complexObserver & computed) --------------
+
+  /**
+   * Adds property effects for each argument in the method signature (and
+   * optionally, for the method name if `dynamic` is true) that calls the
+   * provided effect function.
+   *
+   * @param {Element | Object} model Prototype or instance
+   * @param {Object} sig Method signature metadata
+   * @param {string} type
+   * @param {Function} effectFn Function to run when arguments change
+   * @param {*=} methodInfo
+   * @param {Object=} dynamicFns Map indicating whether method names should
+   *   be included as a dependency to the effect. Note, defaults to true
+   *   if the signature is statci (sig.static is true).
+   * @private
+   */
+  function createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFns) {
+    let dynamicFn = sig.static || dynamicFns && dynamicFns[sig.methodName];
+    let info = {
+      methodName: sig.methodName,
+      args: sig.args,
+      methodInfo,
+      dynamicFn
+    };
+    for (let i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {
+      if (!arg.literal) {
+        model._addPropertyEffect(arg.rootProperty, type, {
+          fn: effectFn, info: info, trigger: arg
+        });
+      }
+    }
+    if (dynamicFn) {
+      model._addPropertyEffect(sig.methodName, type, {
+        fn: effectFn, info: info
+      });
+    }
+  }
+
+  /**
+   * Calls a method with arguments marshaled from properties on the instance
+   * based on the method signature contained in the effect metadata.
+   *
+   * Multi-property observers, computed properties, and inline computing
+   * functions call this function to invoke the method, then use the return
+   * value accordingly.
+   *
+   * @param {Object} inst The instance the effect will be run on
+   * @param {string} property Name of property
+   * @param {*} value Current value of property
+   * @param {*} old Previous value of property
+   * @param {Object} info Effect metadata
+   * @private
+   */
+  function runMethodEffect(inst, property, props, oldProps, info) {
+    // Instances can optionally have a _methodHost which allows redirecting where
+    // to find methods. Currently used by `templatize`.
+    let context = inst._methodHost || inst;
+    let fn = context[info.methodName];
+    if (fn) {
+      let args = marshalArgs(inst.__data, info.args, property, props);
+      return fn.apply(context, args);
+    } else if (!info.dynamicFn) {
+      console.warn('method `' + info.methodName + '` not defined');
+    }
+  }
+
+  const emptyArray = [];
+
+  /**
+   * Parses an expression string for a method signature, and returns a metadata
+   * describing the method in terms of `methodName`, `static` (whether all the
+   * arguments are literals), and an array of `args`
+   *
+   * @param {string} expression The expression to parse
+   * @return {?Object} The method metadata object if a method expression was
+   *   found, otherwise `undefined`
+   * @private
+   */
+  function parseMethod(expression) {
+    // tries to match valid javascript property names
+    let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
+    if (m) {
+      let sig = { methodName: m[1], static: true };
+      if (m[2].trim()) {
+        // replace escaped commas with comma entity, split on un-escaped commas
+        let args = m[2].replace(/\\,/g, '&comma;').split(',');
+        return parseArgs(args, sig);
+      } else {
+        sig.args = emptyArray;
+        return sig;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parses an array of arguments and sets the `args` property of the supplied
+   * signature metadata object. Sets the `static` property to false if any
+   * argument is a non-literal.
+   *
+   * @param {Array<string>} argList Array of argument names
+   * @param {Object} sig Method signature metadata object
+   * @return {Object} The updated signature metadata object
+   * @private
+   */
+  function parseArgs(argList, sig) {
+    sig.args = argList.map(function(rawArg) {
+      let arg = parseArg(rawArg);
+      if (!arg.literal) {
+        sig.static = false;
+      }
+      return arg;
+    }, this);
+    return sig;
+  }
+
+  /**
+   * Parses an individual argument, and returns an argument metadata object
+   * with the following fields:
+   *
+   *   {
+   *     value: 'prop',        // property/path or literal value
+   *     literal: false,       // whether argument is a literal
+   *     structured: false,    // whether the property is a path
+   *     rootProperty: 'prop', // the root property of the path
+   *     wildcard: false       // whether the argument was a wildcard '.*' path
+   *   }
+   *
+   * @param {string} rawArg The string value of the argument
+   * @return {Object} Argument metadata object
+   * @private
+   */
+  function parseArg(rawArg) {
+    // clean up whitespace
+    let arg = rawArg.trim()
+      // replace comma entity with comma
+      .replace(/&comma;/g, ',')
+      // repair extra escape sequences; note only commas strictly need
+      // escaping, but we allow any other char to be escaped since its
+      // likely users will do this
+      .replace(/\\(.)/g, '\$1')
+      ;
+    // basic argument descriptor
+    let a = {
+      name: arg
+    };
+    // detect literal value (must be String or Number)
+    let fc = arg[0];
+    if (fc === '-') {
+      fc = arg[1];
+    }
+    if (fc >= '0' && fc <= '9') {
+      fc = '#';
+    }
+    switch(fc) {
+      case "'":
+      case '"':
+        a.value = arg.slice(1, -1);
+        a.literal = true;
+        break;
+      case '#':
+        a.value = Number(arg);
+        a.literal = true;
+        break;
+    }
+    // if not literal, look for structured path
+    if (!a.literal) {
+      a.rootProperty = Polymer.Path.root(arg);
+      // detect structured path (has dots)
+      a.structured = Polymer.Path.isDeep(arg);
+      if (a.structured) {
+        a.wildcard = (arg.slice(-2) == '.*');
+        if (a.wildcard) {
+          a.name = arg.slice(0, -2);
+        }
+      }
+    }
+    return a;
+  }
+
+  /**
+   * Gather the argument values for a method specified in the provided array
+   * of argument metadata.
+   *
+   * The `path` and `value` arguments are used to fill in wildcard descriptor
+   * when the method is being called as a result of a path notification.
+   *
+   * @param {Object} data Instance data storage object to read properties from
+   * @param {Array<Object>} args Array of argument metadata
+   * @return {Array<*>} Array of argument values
+   * @private
+   */
+  function marshalArgs(data, args, path, props) {
+    let values = [];
+    for (let i=0, l=args.length; i<l; i++) {
+      let arg = args[i];
+      let name = arg.name;
+      let v;
+      if (arg.literal) {
+        v = arg.value;
+      } else {
+        if (arg.structured) {
+          v = Polymer.Path.get(data, name);
+          // when data is not stored e.g. `splices`
+          if (v === undefined) {
+            v = props[name];
+          }
+        } else {
+          v = data[name];
+        }
+      }
+      if (arg.wildcard) {
+        // Only send the actual path changed info if the change that
+        // caused the observer to run matched the wildcard
+        let baseChanged = (name.indexOf(path + '.') === 0);
+        let matches = (path.indexOf(name) === 0 && !baseChanged);
+        values[i] = {
+          path: matches ? path : name,
+          value: matches ? props[path] : v,
+          base: v
+        };
+      } else {
+        values[i] = v;
+      }
+    }
+    return values;
+  }
+
+  /**
+   * Initializes `__dataCompoundStorage` local storage on a bound node with
+   * initial literal data for compound bindings, and sets the joined
+   * literal parts to the bound property.
+   *
+   * When changes to compound parts occur, they are first set into the compound
+   * storage array for that property, and then the array is joined to result in
+   * the final value set to the property/attribute.
+   *
+   * @param {Object} note Annotation metadata
+   * @param {Node} node Bound node to initialize
+   * @private
+   */
+  function setupCompoundBinding(note, node) {
+    let bindings = note.bindings;
+    for (let i=0; i<bindings.length; i++) {
+      let binding = bindings[i];
+      if (binding.isCompound) {
+        // Create compound storage map
+        let storage = node.__dataCompoundStorage ||
+          (node.__dataCompoundStorage = {});
+        let parts = binding.parts;
+        // Copy literals from parts into storage for this binding
+        let literals = new Array(parts.length);
+        for (let j=0; j<parts.length; j++) {
+          literals[j] = parts[j].literal;
+        }
+        let name = binding.name;
+        storage[name] = literals;
+        // Configure properties with their literal parts
+        if (binding.literal && binding.kind == 'property') {
+          node[name] = binding.literal;
+        }
+      }
+    }
+  }
+
+  // data api
+
+  /**
+   * Sends array splice notifications (`.splices` and `.length`)
+   *
+   * Note: this implementation only accepts normalized paths
+   *
+   * @param {Element} inst Instance to send notifications to
+   * @param {Array} array The array the mutations occurred on
+   * @param {string} path The path to the array that was mutated
+   * @param {Array} splices Array of splice records
+   * @private
+   */
+  function notifySplices(inst, array, path, splices) {
+    let splicesPath = path + '.splices';
+    inst.notifyPath(splicesPath, { indexSplices: splices });
+    inst.notifyPath(path + '.length', array.length);
+    // Null here to allow potentially large splice records to be GC'ed.
+    inst.__data[splicesPath] = {indexSplices: null};
+  }
+
+  /**
+   * Creates a splice record and sends an array splice notification for
+   * the described mutation
+   *
+   * Note: this implementation only accepts normalized paths
+   *
+   * @param {Element} inst Instance to send notifications to
+   * @param {Array} array The array the mutations occurred on
+   * @param {string} path The path to the array that was mutated
+   * @param {number} index Index at which the array mutation occurred
+   * @param {number} addedCount Number of added items
+   * @param {Array} removed Array of removed items
+   * @private
+   */
+  function notifySplice(inst, array, path, index, addedCount, removed) {
+    notifySplices(inst, array, path, [{
+      index: index,
+      addedCount: addedCount,
+      removed: removed,
+      object: array,
+      type: 'splice'
+    }]);
+  }
+
+  /**
+   * Returns an upper-cased version of the string.
+   *
+   * @param {string} name String to uppercase
+   * @return {string} Uppercased string
+   * @private
+   */
+  function upper(name) {
+    return name[0].toUpperCase() + name.substring(1);
+  }
+
+  /**
+   * Sets the provided properties into pending data on the instance.
+   *
+   * @param {HTMLElement} inst Instance to apply data to
+   * @param {object} props Bag of instance properties to set
+   * @private
+   */
+  function initalizeInstanceProperties(inst, props) {
+    inst.__dataOld = inst.__dataOld || {};
+    inst.__dataPending = inst.__dataPending || {};
+    let readOnly = inst.__readOnly;
+    for (let prop in props) {
+      if (!readOnly || !readOnly[prop]) {
+        inst.__data[prop] = inst.__dataPending[prop] = props[prop];
+      }
+    }
+  }
+
+  /**
+   * Element class mixin that provides meta-programming for Polymer's template
+   * binding and data observation (collectively, "property effects") system.
+   *
+   * This mixin uses provides the following key methods for adding property effects
+   * to this element:
+   * - `_createPropertyObserver`
+   * - `_createMethodObserver`
+   * - `_createNotifyingProperty`
+   * - `_createReadOnlyProperty`
+   * - `_createReflectedProperty`
+   * - `_createComputedProperty`
+   * - `_bindTemplate`
+   *
+   * Each method creates one or more property accessors, along with metadata
+   * used by this mixin's implementation of `_propertiesChanged` to perform
+   * the property effects.  These methods may be called on element instances,
+   * but are designed to be called on element prototypes such that the work to
+   * set up accessors and effect metadata are done once per element class.
+   *
+   * @polymerMixin
+   * @mixes Polymer.TemplateStamp
+   * @mixes Polymer.PropertyAccessors
+   * @memberof Polymer
+   * @summary Element class mixin that provides meta-programming for Polymer's
+   * template binding and data observation system.
+   */
+  Polymer.PropertyEffects = Polymer.dedupingMixin(function(superClass) {
+
+    const propertyEffectsBase = Polymer.TemplateStamp(Polymer.PropertyAccessors(superClass));
+
+    /**
+     * @polymerMixinClass
+     * @unrestricted
+     */
+    class PropertyEffects extends propertyEffectsBase {
+
+      get PROPERTY_EFFECT_TYPES() {
+        return TYPES;
+      }
+
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to initialize
+       * additional property-effect related properties.
+       *
+       * @override
+       */
+      _initializeProperties() {
+        super._initializeProperties();
+        this.__dataInitialized = false;
+        this.__dataClientsInitialized = false;
+        this.__dataPendingClients = null;
+        this.__dataToNotify = null;
+        this.__dataLinkedPaths = null;
+        this.__dataHasPaths = false;
+        // May be set on instance prior to upgrade
+        this.__dataCompoundStorage = this.__dataCompoundStorage || null;
+        this.__dataHost = this.__dataHost || null;
+        this.__dataTemp = {};
+        // Capture instance properties; these will be set into accessors
+        // during first flush. Don't set them here, since we want
+        // these to overwrite defaults/constructor assignments
+        for (let p in this.__propertyEffects) {
+          if (this.hasOwnProperty(p)) {
+            this.__dataInstanceProps = this.__dataInstanceProps || {};
+            this.__dataInstanceProps[p] = this[p];
+            delete this[p];
+          }
+        }
+      }
+
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to provide a
+       * more efficient implementation of initializing properties from
+       * the prototype on the instance.
+       *
+       * @override
+       */
+      _initializeProtoProperties(props) {
+        this.__data = Object.create(props);
+        this.__dataPending = Object.create(props);
+        this.__dataOld = {};
+      }
+
+      // Prototype setup ----------------------------------------
+
+      /**
+       * Ensures an accessor exists for the specified property, and adds
+       * to a list of "property effects" that will run when the accessor for
+       * the specified property is set.  Effects are grouped by "type", which
+       * roughly corresponds to a phase in effect processing.  The effect
+       * metadata should be in the following form:
+       *
+       *   {
+       *     fn: effectFunction, // Reference to function to call to perform effect
+       *     info: { ... }       // Effect metadata passed to function
+       *     // path: '...'      // Will be set by this method based on path arg
+       *   }
+       *
+       * Effect functions are called with the following signature:
+       *
+       *   effectFunction(inst, property, currentValue, oldValue, info)
+       *
+       * This method may be called either on the prototype of a class
+       * using the PropertyEffects mixin (for best performance), or on
+       * an instance to add dynamic effects.  When called on an instance or
+       * subclass of a class that has already had property effects added to
+       * its prototype, the property effect lists will be cloned and added as
+       * own properties of the caller.
+       *
+       * @param {string} path Property (or path) that should trigger the effect
+       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @param {Object=} effect Effect metadata object
+       * @protected
+       */
+      _addPropertyEffect(property, type, effect) {
+        let effects = ensureOwnEffectMap(this, TYPES.ANY)[property];
+        if (!effects) {
+          effects = this.__propertyEffects[property] = [];
+          this._createPropertyAccessor(property,
+            type == TYPES.READ_ONLY);
+        }
+        // effects are accumulated into arrays per property based on type
+        if (effect) {
+          effects.push(effect);
+        }
+        effects = ensureOwnEffectMap(this, type)[property];
+        if (!effects) {
+          effects = this[type][property] = [];
+        }
+        effects.push(effect);
+      }
+
+      /**
+       * Returns whether the current prototype/instance has a property effect
+       * of a certain type.
+       *
+       * @param {string} property Property name
+       * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @return {boolean} True if the prototype/instance has an effect of this type
+       * @protected
+       */
+      _hasPropertyEffect(property, type) {
+        let effects = this[type || TYPES.ANY];
+        return Boolean(effects && effects[property]);
+      }
+
+      /**
+       * Returns whether the current prototype/instance has a "read only"
+       * accessor for the given property.
+       *
+       * @param {string} property Property name
+       * @return {boolean} True if the prototype/instance has an effect of this type
+       * @protected
+       */
+      _hasReadOnlyEffect(property) {
+        return this._hasPropertyEffect(property, TYPES.READ_ONLY);
+      }
+
+      /**
+       * Returns whether the current prototype/instance has a "notify"
+       * property effect for the given property.
+       *
+       * @param {string} property Property name
+       * @return {boolean} True if the prototype/instance has an effect of this type
+       * @protected
+       */
+      _hasNotifyEffect(property) {
+        return this._hasPropertyEffect(property, TYPES.NOTIFY);
+      }
+
+      /**
+       * Returns whether the current prototype/instance has a "reflect to attribute"
+       * property effect for the given property.
+       *
+       * @param {string} property Property name
+       * @return {boolean} True if the prototype/instance has an effect of this type
+       * @protected
+       */
+      _hasReflectEffect(property) {
+        return this._hasPropertyEffect(property, TYPES.REFLECT);
+      }
+
+      /**
+       * Returns whether the current prototype/instance has a "computed"
+       * property effect for the given property.
+       *
+       * @param {string} property Property name
+       * @return {boolean} True if the prototype/instance has an effect of this type
+       * @protected
+       */
+      _hasComputedEffect(property) {
+        return this._hasPropertyEffect(property, TYPES.COMPUTE);
+      }
+
+      // Runtime ----------------------------------------
+
+      /**
+       * Sets a pending property or path.  If the root property of the path in
+       * question had no accessor, the path is set, otherwise it is enqueued
+       * via `_setPendingProperty`.
+       *
+       * This function isolates relatively expensive functionality necessary
+       * for the public API (`set`, `setProperties`, `notifyPath`, and property
+       * change listeners via {{...}} bindings), such that it is only done
+       * when paths enter the system, and not at every propagation step.  It
+       * also sets a `__dataHasPaths` flag on the instance which is used to
+       * fast-path slower path-matching code in the property effects host paths.
+       *
+       * `path` can be a path string or array of path parts as accepted by the
+       * public API.
+       *
+       * @param {string | !Array<number|string>} path Path to set
+       * @param {*} value Value to set
+       * @param {boolean=} isPathNotification If the path being set is a path
+       *   notification of an already changed value, as opposed to a request
+       *   to set and notify the change.  In the latter `false` case, a dirty
+       *   check is performed and then the value is set to the path before
+       *   enqueuing the pending property change.
+       * @return {boolean} Returns true if the property/path was enqueued in
+       *   the pending changes bag.
+       * @protected
+       */
+      _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
+        let rootProperty = Polymer.Path.root(Array.isArray(path) ? path[0] : path);
+        let hasEffect = this.__propertyEffects && this.__propertyEffects[rootProperty];
+        let isPath = (rootProperty !== path);
+        if (hasEffect) {
+          if (isPath) {
+            if (!isPathNotification) {
+              // Dirty check changes being set to a path against the actual object,
+              // since this is the entry point for paths into the system; from here
+              // the only dirty checks are against the `__dataTemp` cache to prevent
+              // duplicate work in the same turn only. Note, if this was a notification
+              // of a change already set to a path (isPathNotification: true),
+              // we always let the change through and skip the `set` since it was
+              // already dirty checked at the point of entry and the underlying
+              // object has already been updated
+              let old = Polymer.Path.get(this, path);
+              path = /** @type {string} */ Polymer.Path.set(this, path, value);
+              // Use property-accessor's simpler dirty check
+              if (!path || !super._shouldPropertyChange(path, value, old)) {
+                return false;
+              }
+            }
+            this.__dataHasPaths = true;
+          }
+          return this._setPendingProperty(path, value, shouldNotify);
+        } else {
+          if (isPath) {
+            Polymer.Path.set(this, path, value);
+          } else {
+            this[path] = value;
+          }
+        }
+        return false;
+      }
+
+      /**
+       * Applies a value to a non-Polymer element/node's property.
+       *
+       * The implementation makes a best-effort at binding interop:
+       * Some native element properties have side-effects when
+       * re-setting the same value (e.g. setting <input>.value resets the
+       * cursor position), so we do a dirty-check before setting the value.
+       * However, for better interop with non-Polymer custom elements that
+       * accept objects, we explicitly re-set object changes coming from the
+       * Polymer world (which may include deep object changes without the
+       * top reference changing), erring on the side of providing more
+       * information.
+       *
+       * Users may override this method to provide alternate approaches.
+       *
+       * @param {Node} node The node to set a property on
+       * @param {string} prop The property to set
+       * @param {*} value The value to set
+       * @protected
+       */
+      _setUnmanagedPropertyToNode(node, prop, value) {
+        // It is a judgment call that resetting primitives is
+        // "bad" and resettings objects is also "good"; alternatively we could
+        // implement a whitelist of tag & property values that should never
+        // be reset (e.g. <input>.value && <select>.value)
+        if (value !== node[prop] || typeof value == 'object') {
+          node[prop] = value;
+        }
+      }
+
+      /**
+       * Overrides the `PropertyAccessors` implementation to introduce special
+       * dirty check logic depending on the property & value being set:
+       *
+       * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
+       *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
+       * 2. Object set to simple property (e.g. 'prop': {...})
+       *    Stored in `__dataTemp` and `__data`, dirty checked against
+       *    `__dataTemp` by default implementation of `_shouldPropertyChange`
+       * 3. Primitive value set to simple property (e.g. 'prop': 42)
+       *    Stored in `__data`, dirty checked against `__data`
+       *
+       * The dirty-check is important to prevent cycles due to two-way
+       * notification, but paths and objects are only dirty checked against any
+       * previous value set during this turn via a "temporary cache" that is
+       * cleared when the last `_propertiesChaged` exits. This is so:
+       * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
+       *    due to array mutations like shift/unshift/splice; this is fine
+       *    since path changes are dirty-checked at user entry points like `set`
+       * b. dirty-checking for objects only lasts one turn to allow the user
+       *    to mutate the object in-place and re-set it with the same identity
+       *    and have all sub-properties re-propagated in a subsequent turn.
+       *
+       * The temp cache is not necessarily sufficient to prevent invalid array
+       * paths, since a splice can happen during the same turn (with pathological
+       * user code); we could introduce a "fixup" for temporarily cached array
+       * paths if needed: https://github.com/Polymer/polymer/issues/4227
+       *
+       * @override
+       */
+      _setPendingProperty(property, value, shouldNotify) {
+        let isPath = this.__dataHasPaths && Polymer.Path.isPath(property);
+        let prevProps = isPath ? this.__dataTemp : this.__data;
+        if (this._shouldPropertyChange(property, value, prevProps[property])) {
+          if (!this.__dataPending) {
+            this.__dataPending = {};
+            this.__dataOld = {};
+          }
+          // Ensure old is captured from the last turn
+          if (!(property in this.__dataOld)) {
+            this.__dataOld[property] = this.__data[property];
+          }
+          // Paths are stored in temporary cache (cleared at end of turn),
+          // which is used for dirty-checking, all others stored in __data
+          if (isPath) {
+            this.__dataTemp[property] = value;
+          } else {
+            this.__data[property] = value;
+          }
+          // All changes go into pending property bag, passed to _propertiesChanged
+          this.__dataPending[property] = value;
+          // Track properties that should notify separately
+          if (isPath || (this.__notifyEffects && this.__notifyEffects[property])) {
+            this.__dataToNotify = this.__dataToNotify || {};
+            this.__dataToNotify[property] = shouldNotify;
+          }
+          return true;
+        }
+      }
+
+      /**
+       * Overrides base implementation to ensure all accessors set `shouldNotify`
+       * to true, for per-property notification tracking.
+       *
+       * @override
+       */
+      _setProperty(property, value) {
+        if (this._setPendingProperty(property, value, true)) {
+          this._invalidateProperties();
+        }
+      }
+
+      /**
+       * Overrides `PropertyAccessor`'s default async queuing of
+       * `_propertiesChanged`: if `__dataInitialized` is false (has not yet been
+       * manually flushed), the function no-ops; otherwise flushes
+       * `_propertiesChanged` synchronously.
+       *
+       * @override
+       */
+      _invalidateProperties() {
+        if (this.__dataInitialized) {
+          this._flushProperties();
+        }
+      }
+
+      /**
+       * Enqueues the given client on a list of pending clients, whose
+       * pending property changes can later be flushed via a call to
+       * `_flushClients`.
+       *
+       * @param {Object} client PropertyEffects client to enqueue
+       * @protected
+       */
+      _enqueueClient(client) {
+        this.__dataPendingClients = this.__dataPendingClients || [];
+        if (client !== this) {
+          this.__dataPendingClients.push(client);
+        }
+      }
+
+      /**
+       * Flushes any clients previously enqueued via `_enqueueClient`, causing
+       * their `_flushProperties` method to run.
+       *
+       * @protected
+       */
+      _flushClients() {
+        if (!this.__dataClientsInitialized) {
+          this._readyClients();
+        }
+        // Flush all clients
+        let clients = this.__dataPendingClients;
+        if (clients) {
+          this.__dataPendingClients = null;
+          for (let i=0; i < clients.length; i++) {
+            let client = clients[i];
+            if (!client.__dataInitialized || client.__dataPending) {
+              client._flushProperties();
+            }
+          }
+        }
+      }
+
+      /**
+       * Sets a bag of property changes to this instance, and
+       * synchronously processes all effects of the properties as a batch.
+       *
+       * Property names must be simple properties, not paths.  Batched
+       * path propagation is not supported.
+       *
+       * @param {Object} props Bag of one or more key-value pairs whose key is
+       *   a property and value is the new value to set for that property.
+       * @public
+       */
+      setProperties(props) {
+        for (let path in props) {
+          if (!this.__readOnly || !this.__readOnly[path]) {
+            //TODO(kschaaf): explicitly disallow paths in setProperty?
+            // wildcard observers currently only pass the first changed path
+            // in the `info` object, and you could do some odd things batching
+            // paths, e.g. {'foo.bar': {...}, 'foo': null}
+            this._setPendingPropertyOrPath(path, props[path], true);
+          }
+        }
+        this._invalidateProperties();
+      }
+
+      /**
+       * Overrides PropertyAccessor's default async queuing of
+       * `_propertiesChanged`, to instead synchronously flush
+       * `_propertiesChanged` unless the `this._asyncEffects` property is true.
+       *
+       * If this is the first time properties are being flushed, the `ready`
+       * callback will be called.
+       *
+       * @override
+       */
+      _flushProperties() {
+        if (!this.__dataInitialized) {
+          this.ready()
+        } else if (this.__dataPending) {
+          super._flushProperties();
+          if (!this.__dataCounter) {
+            // Clear temporary cache at end of turn
+            this.__dataTemp = {};
+          }
+        }
+      }
+
+      /**
+       * Polymer-specific lifecycle callback called the first time properties
+       * are being flushed.  Prior to `ready`, all property sets through
+       * accessors are queued and their effects are flushed after this method
+       * returns.
+       *
+       * Users may override this function to implement behavior that is
+       * dependent on the element having its properties initialized, e.g.
+       * from defaults (initialized from `constructor`, `_initializeProperties`),
+       * `attributeChangedCallback`, or binding values propagated from host
+       * "binding effects".  `super.ready()` must be called to ensure the
+       * data system becomes enabled.
+       *
+       * @public
+       */
+      ready() {
+        // Update instance properties that shadowed proto accessors; these take
+        // priority over any defaults set in `properties` or constructor
+        let instanceProps = this.__dataInstanceProps;
+        if (instanceProps) {
+          initalizeInstanceProperties(this, instanceProps);
+        }
+        // Enable acceessors
+        this.__dataInitialized = true;
+        if (this.__dataPending) {
+          // Run normal flush
+          this._flushProperties();
+        } else {
+          this._readyClients();
+        }
+      }
+
+      /**
+       * Perform any initial setup on client dom. Called before the first
+       * `_flushProperties` call on client dom and before any element
+       * observers are called.
+       *
+       * @protected
+       */
+      _readyClients() {
+        this.__dataClientsInitialized = true;
+      }
+
+      /**
+       * Stamps the provided template and performs instance-time setup for
+       * Polymer template features, including data bindings, declarative event
+       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
+       * is returned containing the stamped DOM, ready for insertion into the
+       * DOM.
+       *
+       * Note that for host data to be bound into the stamped DOM, the template
+       * must have been previously bound to the prototype via a call to
+       * `_bindTemplate`, which performs one-time template binding work.
+       *
+       * Note that this method currently only supports being called once per
+       * instance.
+       *
+       * @param {HTMLTemplateElement} template Template to stamp
+       * @return {DocumentFragment} Cloned template content
+       * @protected
+       */
+      _stampTemplate(template) {
+        let dom = super._stampTemplate(template);
+        setupBindings(this);
+        return dom;
+      }
+
+      /**
+       * Implements `PropertyAccessors`'s properties changed callback.
+       *
+       * Runs each class of effects for the batch of changed properties in
+       * a specific order (compute, propagate, reflect, observe, notify).
+       *
+       * @override
+       */
+      _propertiesChanged(currentProps, changedProps, oldProps) {
+        // ----------------------------
+        // let c = Object.getOwnPropertyNames(changedProps || {});
+        // window.debug && console.group(this.localName + '#' + this.id + ': ' + c);
+        // if (window.debug) { debugger; }
+        // ----------------------------
+        let hasPaths = this.__dataHasPaths;
+        this.__dataHasPaths = false;
+        // Compute properties
+        runComputedEffects(this, changedProps, oldProps, hasPaths);
+        // Compute linked paths
+        computeLinkedPaths(this, changedProps, hasPaths);
+        // Clear notify properties prior to possible reentry (propagate, observe),
+        // but after computing effects have a chance to add to them
+        let notifyProps = this.__dataToNotify;
+        this.__dataToNotify = null;
+        // Propagate properties to clients
+        runEffects(this, this.__propagateEffects, changedProps, oldProps, hasPaths);
+        // Flush clients
+        this._flushClients();
+        // Reflect properties
+        runEffects(this, this.__reflectEffects, changedProps, oldProps, hasPaths);
+        // Observe properties
+        runEffects(this, this.__observeEffects, changedProps, oldProps, hasPaths);
+        // Notify properties to host
+        if (notifyProps) {
+          runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);
+        }
+        // ----------------------------
+        // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);
+        // ----------------------------
+      }
+
+      /**
+       * Aliases one data path as another, such that path notifications from one
+       * are routed to the other.
+       *
+       * @method linkPaths
+       * @param {string | !Array<string|number>} to Target path to link.
+       * @param {string | !Array<string|number>} from Source path to link.
+       * @public
+       */
+      linkPaths(to, from) {
+        to = Polymer.Path.normalize(to);
+        from = Polymer.Path.normalize(from);
+        this.__dataLinkedPaths = this.__dataLinkedPaths || {};
+        this.__dataLinkedPaths[to] = from;
+      }
+
+      /**
+       * Removes a data path alias previously established with `_linkPaths`.
+       *
+       * Note, the path to unlink should be the target (`to`) used when
+       * linking the paths.
+       *
+       * @method unlinkPaths
+       * @param {string | !Array<string|number>} path Target path to unlink.
+       * @public
+       */
+      unlinkPaths(path) {
+        path = Polymer.Path.normalize(path);
+        if (this.__dataLinkedPaths) {
+          delete this.__dataLinkedPaths[path];
+        }
+      }
+
+      /**
+       * Notify that an array has changed.
+       *
+       * Example:
+       *
+       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
+       *     ...
+       *     this.items.splice(1, 1, {name: 'Sam'});
+       *     this.items.push({name: 'Bob'});
+       *     this.notifySplices('items', [
+       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, obect: this.items, type: 'splice' },
+       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
+       *     ]);
+       *
+       * @param {string} path Path that should be notified.
+       * @param {Array} splices Array of splice records indicating ordered
+       *   changes that occurred to the array. Each record should have the
+       *   following fields:
+       *    * index: index at which the change occurred
+       *    * removed: array of items that were removed from this index
+       *    * addedCount: number of new items added at this index
+       *    * object: a reference to the array in question
+       *    * type: the string literal 'splice'
+       *
+       *   Note that splice records _must_ be normalized such that they are
+       *   reported in index order (raw results from `Object.observe` are not
+       *   ordered and must be normalized/merged before notifying).
+       * @public
+      */
+      notifySplices(path, splices) {
+        let info = {};
+        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
+        notifySplices(this, array, info.path, splices);
+      }
+
+      /**
+       * Convenience method for reading a value from a path.
+       *
+       * Note, if any part in the path is undefined, this method returns
+       * `undefined` (this method does not throw when dereferencing undefined
+       * paths).
+       *
+       * @method get
+       * @param {(string|!Array<(string|number)>)} path Path to the value
+       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+       * @param {Object=} root Root object from which the path is evaluated.
+       * @return {*} Value at the path, or `undefined` if any part of the path
+       *   is undefined.
+       * @public
+       */
+      get(path, root) {
+        return Polymer.Path.get(root || this, path);
+      }
+
+      /**
+       * Convenience method for setting a value to a path and notifying any
+       * elements bound to the same path.
+       *
+       * Note, if any part in the path except for the last is undefined,
+       * this method does nothing (this method does not throw when
+       * dereferencing undefined paths).
+       *
+       * @method set
+       * @param {(string|!Array<(string|number)>)} path Path to the value
+       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
+       * @param {*} value Value to set at the specified path.
+       * @param {Object=} root Root object from which the path is evaluated.
+       *   When specified, no notification will occur.
+       * @public
+      */
+      set(path, value, root) {
+        if (root) {
+          Polymer.Path.set(root, path, value);
+        } else {
+          if (!this.__readOnly || !this.__readOnly[/** @type {string} */(path)]) {
+            if (this._setPendingPropertyOrPath(path, value, true)) {
+              this._invalidateProperties();
+            }
+          }
+        }
+      }
+
+      /**
+       * Adds items onto the end of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method push
+       * @param {string} path Path to array.
+       * @param {...*} items Items to push onto array
+       * @return {number} New length of the array.
+       * @public
+       */
+      push(path, ...items) {
+        let info = {};
+        let array = /** @type {Array}*/(Polymer.Path.get(this, path, info));
+        let len = array.length;
+        let ret = array.push(...items);
+        if (items.length) {
+          notifySplice(this, array, info.path, len, items.length, []);
+        }
+        return ret;
+      }
+
+      /**
+       * Removes an item from the end of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method pop
+       * @param {string} path Path to array.
+       * @return {*} Item that was removed.
+       * @public
+       */
+      pop(path) {
+        let info = {};
+        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
+        let hadLength = Boolean(array.length);
+        let ret = array.pop();
+        if (hadLength) {
+          notifySplice(this, array, info.path, array.length, 0, [ret]);
+        }
+        return ret;
+      }
+
+      /**
+       * Starting from the start index specified, removes 0 or more items
+       * from the array and inserts 0 or more new items in their place.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.splice`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method splice
+       * @param {string} path Path to array.
+       * @param {number} start Index from which to start removing/inserting.
+       * @param {number} deleteCount Number of items to remove.
+       * @param {...*} items Items to insert into array.
+       * @return {Array} Array of removed items.
+       * @public
+       */
+      splice(path, start, deleteCount, ...items) {
+        let info = {};
+        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
+        // Normalize fancy native splice handling of crazy start values
+        if (start < 0) {
+          start = array.length - Math.floor(-start);
+        } else {
+          start = Math.floor(start);
+        }
+        if (!start) {
+          start = 0;
+        }
+        let ret = array.splice(start, deleteCount, ...items);
+        if (items.length || ret.length) {
+          notifySplice(this, array, info.path, start, items.length, ret);
+        }
+        return ret;
+      }
+
+      /**
+       * Removes an item from the beginning of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method shift
+       * @param {string} path Path to array.
+       * @return {*} Item that was removed.
+       * @public
+       */
+      shift(path) {
+        let info = {};
+        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
+        let hadLength = Boolean(array.length);
+        let ret = array.shift();
+        if (hadLength) {
+          notifySplice(this, array, info.path, 0, 0, [ret]);
+        }
+        return ret;
+      }
+
+      /**
+       * Adds items onto the beginning of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @method unshift
+       * @param {string} path Path to array.
+       * @param {...*} items Items to insert info array
+       * @return {number} New length of the array.
+       * @public
+       */
+      unshift(path, ...items) {
+        let info = {};
+        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
+        let ret = array.unshift(...items);
+        if (items.length) {
+          notifySplice(this, array, info.path, 0, items.length, []);
+        }
+        return ret;
+      }
+
+      /**
+       * Notify that a path has changed.
+       *
+       * Example:
+       *
+       *     this.item.user.name = 'Bob';
+       *     this.notifyPath('item.user.name');
+       *
+       * @param {string} path Path that should be notified.
+       * @param {*=} value Value at the path (optional).
+       * @public
+      */
+      notifyPath(path, value) {
+        /** @type {string} */
+        let propPath;
+        if (arguments.length == 1) {
+          // Get value if not supplied
+          let info = {};
+          value = Polymer.Path.get(this, path, info);
+          propPath = info.path;
+        } else if (Array.isArray(path)) {
+          // Normalize path if needed
+          propPath = Polymer.Path.normalize(path);
+        } else {
+          propPath = /** @type{string} */(path);
+        }
+        if (this._setPendingPropertyOrPath(propPath, value, true, true)) {
+          this._invalidateProperties();
+        }
+      }
+
+      /**
+       * Creates a read-only accessor for the given property.
+       *
+       * To set the property, use the protected `_setProperty` API.
+       * To create a custom protected setter (e.g. `_setMyProp()` for
+       * property `myProp`), pass `true` for `protectedSetter`.
+       *
+       * Note, if the property will have other property effects, this method
+       * should be called first, before adding other effects.
+       *
+       * @param {string} property Property name
+       * @param {boolean=} protectedSetter Creates a custom protected setter
+       *   when `true`.
+       * @protected
+       */
+      _createReadOnlyProperty(property, protectedSetter) {
+        this._addPropertyEffect(property, TYPES.READ_ONLY);
+        if (protectedSetter) {
+          this['_set' + upper(property)] = function(value) {
+            this._setProperty(property, value);
+          }
+        }
+      }
+
+      /**
+       * Creates a single-property observer for the given property.
+       *
+       * @param {string} property Property name
+       * @param {string} methodName Name of observer method to call
+       * @param {boolean=} dynamicFn Whether the method name should be included as
+       *   a dependency to the effect.
+       * @protected
+       */
+      _createPropertyObserver(property, methodName, dynamicFn) {
+        let info = { property, methodName };
+        this._addPropertyEffect(property, TYPES.OBSERVE, {
+          fn: runObserverEffect, info, trigger: {name: property}
+        });
+        if (dynamicFn) {
+          this._addPropertyEffect(methodName, TYPES.OBSERVE, {
+            fn: runObserverEffect, info, trigger: {name: methodName}
+          });
+        }
+      }
+
+      /**
+       * Creates a multi-property "method observer" based on the provided
+       * expression, which should be a string in the form of a normal Javascript
+       * function signature: `'methodName(arg1, [..., argn])'`.  Each argument
+       * should correspond to a property or path in the context of this
+       * prototype (or instance), or may be a literal string or number.
+       *
+       * @param {string} expression Method expression
+       * @param {Object=} dynamicFns Map indicating whether method names should
+       *   be included as a dependency to the effect.
+       * @protected
+       */
+      _createMethodObserver(expression, dynamicFns) {
+        let sig = parseMethod(expression);
+        if (!sig) {
+          throw new Error("Malformed observer expression '" + expression + "'");
+        }
+        createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFns);
+      }
+
+      /**
+       * Causes the setter for the given property to dispatch `<property>-changed`
+       * events to notify of changes to the property.
+       *
+       * @param {string} property Property name
+       * @protected
+       */
+      _createNotifyingProperty(property) {
+        this._addPropertyEffect(property, TYPES.NOTIFY, {
+          fn: runNotifyEffect,
+          info: {
+            eventName: CaseMap.camelToDashCase(property) + '-changed',
+            property: property
+          }
+        });
+      }
+
+      /**
+       * Causes the setter for the given property to reflect the property value
+       * to a (dash-cased) attribute of the same name.
+       *
+       * @param {string} property Property name
+       * @protected
+       */
+      _createReflectedProperty(property) {
+        let attr = CaseMap.camelToDashCase(property);
+        if (attr[0] === '-') {
+          console.warn('Property ' + property + ' cannot be reflected to attribute ' +
+            attr + ' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property thisead.');
+        } else {
+          this._addPropertyEffect(property, TYPES.REFLECT, {
+            fn: runReflectEffect,
+            info: {
+              attrName: attr
+            }
+          });
+        }
+      }
+
+      /**
+       * Creates a computed property whose value is set to the result of the
+       * method described by the given `expression` each time one or more
+       * arguments to the method changes.  The expression should be a string
+       * in the form of a normal Javascript function signature:
+       * `'methodName(arg1, [..., argn])'`
+       *
+       * @param {string} property Name of computed property to set
+       * @param {string} expression Method expression
+       * @param {Object=} dynamicFns Map indicating whether method names should
+       *   be included as a dependency to the effect.
+       * @protected
+       */
+      _createComputedProperty(property, expression, dynamicFns) {
+        let sig = parseMethod(expression);
+        if (!sig) {
+          throw new Error("Malformed computed expression '" + expression + "'");
+        }
+        createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFns);
+      }
+
+      // -- binding ----------------------------------------------
+
+      /**
+       * Creates "binding" property effects for all binding bindings
+       * in the provided template that forward host properties into DOM stamped
+       * from the template via `_stampTemplate`.
+       *
+       * @param {HTMLTemplateElement} template Template containing binding
+       *   bindings
+       * @param {Object=} dynamicFns Map indicating whether method names should
+       *   be included as a dependency to the effect.
+       * @protected
+       */
+      _bindTemplate(template, dynamicFns) {
+        // Clear any existing propagation effects inherited from superClass
+        this.__propagateEffects = {};
+        this.__notifyListeners = [];
+        let notes = this._parseTemplateAnnotations(template);
+        processAnnotations(notes);
+        for (let i=0, note; (i<notes.length) && (note=notes[i]); i++)  {
+          // where to find the node in the concretized list
+          let b$ = note.bindings;
+          for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
+            if (shouldAddListener(binding)) {
+              addAnnotatedListener(this, i, binding.name,
+                binding.parts[0].value,
+                binding.parts[0].event,
+                binding.parts[0].negate);
+            }
+            addBindingEffect(this, binding, i, dynamicFns);
+          }
+        }
+      }
+
+    }
+
+    return PropertyEffects;
+  });
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/mixins/template-stamp.html b/lib/polymer2/bower_components/polymer/lib/mixins/template-stamp.html
new file mode 100644
index 00000000..ac10e38f
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/mixins/template-stamp.html
@@ -0,0 +1,543 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/mixin.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  // null-array (shared empty array to avoid null-checks)
+  const emptyArray = [];
+
+  let bindingRegex = (function() {
+    let IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
+    let NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
+    let SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
+    let DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
+    let STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
+    let ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
+    let ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
+    let ARGUMENT_LIST = '(?:' + '\\(\\s*' +
+                                  '(?:' + ARGUMENTS + '?' + ')' +
+                                '\\)\\s*' + ')';
+    let BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
+    let OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
+    let CLOSE_BRACKET = '(?:]]|}})';
+    let NEGATE = '(?:(!)\\s*)?'; // Group 2
+    let EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+    return new RegExp(EXPRESSION, "g");
+  })();
+
+  let insertionPointTag = 'slot';
+
+  /**
+   * Scans a template to produce an annotation map that stores expression metadata
+   * and information that associates the metadata to nodes in a template instance.
+   *
+   * Supported annotations are:
+   *   * id attributes
+   *   * binding annotations in text nodes
+   *     * double-mustache expressions: {{expression}}
+   *     * double-bracket expressions: [[expression]]
+   *   * binding annotations in attributes
+   *     * attribute-bind expressions: name="{{expression}} || [[expression]]"
+   *     * property-bind expressions: name*="{{expression}} || [[expression]]"
+   *     * property-bind expressions: name:="expression"
+   *   * event annotations
+   *     * event delegation directives: on-<eventName>="expression"
+   *
+   * Generated data-structure:
+   *   [
+   *     {
+   *       id: '<id>',
+   *       events: [
+   *         {
+   *           mode: ['auto'|''],
+   *           name: '<name>'
+   *           value: '<expression>'
+   *         }, ...
+   *       ],
+   *       bindings: [
+   *         {
+   *           kind: ['text'|'attribute'|'property'],
+   *           mode: ['auto'|''],
+   *           name: '<name>'
+   *           value: '<expression>'
+   *         }, ...
+   *       ],
+   *       parent: <reference to parent annotation>,
+   *       index: <integer index in parent's childNodes collection>
+   *     },
+   *     ...
+   *   ]
+   *
+   * @param {HTMLTemplateElement} template
+   * @param {boolean=} stripWhiteSpace
+   * @return {Array<Object>}
+   */
+  function parseTemplateAnnotations(template, stripWhiteSpace, ownerDocument) {
+    // TODO(kschaaf): File issue and/or remove when fixed
+    // hold a reference to content as _content to prevent odd Chrome gc issue
+    // nested templates also may receive their content as _content
+    let content = (template._content = template._content || template.content);
+    // since a template may be re-used, memo-ize notes.
+    if (!content._notes) {
+      content._notes = [];
+      // TODO(sorvell): whitespace and processAnnotations need to be factored
+      // into plugins
+      ownerDocument = ownerDocument || template.ownerDocument;
+      parseNodeAnnotations(content, content._notes,
+        stripWhiteSpace || template.hasAttribute('strip-whitespace'), ownerDocument);
+    }
+    return content._notes;
+  }
+
+  // add annotations gleaned from subtree at `node` to `list`
+  function parseNodeAnnotations(node, list, stripWhiteSpace, ownerDocument) {
+    return node.nodeType === Node.TEXT_NODE ?
+      parseTextNodeAnnotation(node, list) :
+        parseElementAnnotations(node, list, stripWhiteSpace, ownerDocument);
+  }
+
+  function parseBindings(text) {
+    let parts = [];
+    let lastIndex = 0;
+    let m;
+    // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
+    // Regex matches:
+    //        Iteration 1:  Iteration 2:
+    // m[1]: '{{'          '[['
+    // m[2]: ''            '!'
+    // m[3]: 'prop'        'compute(foo,bar)'
+    while ((m = bindingRegex.exec(text)) !== null) {
+      // Add literal part
+      if (m.index > lastIndex) {
+        parts.push({literal: text.slice(lastIndex, m.index)});
+      }
+      // Add binding part
+      // Mode (one-way or two)
+      let mode = m[1][0];
+      let negate = Boolean(m[2]);
+      let value = m[3].trim();
+      let customEvent, notifyEvent, colon;
+      if (mode == '{' && (colon = value.indexOf('::')) > 0) {
+        notifyEvent = value.substring(colon + 2);
+        value = value.substring(0, colon);
+        customEvent = true;
+      }
+      parts.push({
+        compoundIndex: parts.length,
+        value: value,
+        mode: mode,
+        negate: negate,
+        event: notifyEvent,
+        customEvent: customEvent
+      });
+      lastIndex = bindingRegex.lastIndex;
+    }
+    // Add a final literal part
+    if (lastIndex && lastIndex < text.length) {
+      let literal = text.substring(lastIndex);
+      if (literal) {
+        parts.push({
+          literal: literal
+        });
+      }
+    }
+    if (parts.length) {
+      return parts;
+    }
+  }
+
+  function literalFromParts(parts) {
+    let s = '';
+    for (let i=0; i<parts.length; i++) {
+      let literal = parts[i].literal;
+      s += literal || '';
+    }
+    return s;
+  }
+
+  // add annotations gleaned from TextNode `node` to `list`
+  function parseTextNodeAnnotation(node, list) {
+    let parts = parseBindings(node.textContent);
+    if (parts) {
+      // Initialize the textContent with any literal parts
+      // NOTE: default to a space here so the textNode remains; some browsers
+      // (IE) evacipate an empty textNode following cloneNode/importNode.
+      node.textContent = literalFromParts(parts) || ' ';
+      let note = {
+        bindings: [{
+          kind: 'text',
+          name: 'textContent',
+          parts: parts,
+          isCompound: parts.length !== 1
+        }]
+      };
+      list.push(note);
+      return note;
+    }
+  }
+
+  // add annotations gleaned from Element `node` to `list`
+  function parseElementAnnotations(element, list, stripWhiteSpace, ownerDocument) {
+    let note = {
+      bindings: [],
+      events: []
+    };
+    if (element.localName === insertionPointTag) {
+      list._hasInsertionPoint = true;
+    }
+    parseChildNodesAnnotations(element, note, list, stripWhiteSpace, ownerDocument);
+    if (element.attributes) {
+      parseNodeAttributeAnnotations(element, note);
+    }
+    if (note.bindings.length || note.events.length || note.id) {
+      list.push(note);
+    }
+    return note;
+  }
+
+  // 1.x backwards-compatible auto-wrapper for template type extensions
+  // This is a clear layering violation and gives favored-nation status to
+  // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
+  // a.) to ease 1.x backwards-compatibility due to loss of `is`, and
+  // b.) to maintain if/repeat capability in parser-constrained elements
+  //     (e.g. table, select) in lieu of native CE type extensions without
+  //     massive new invention in this space (e.g. directive system)
+  const templateExtensions = {
+    'dom-if': true,
+    'dom-repeat': true
+  };
+  function wrapTemplateExtension(node) {
+    let is = node.getAttribute('is');
+    if (is && templateExtensions[is]) {
+      let t = node;
+      t.removeAttribute('is');
+      node = t.ownerDocument.createElement(is);
+      t.parentNode.replaceChild(node, t);
+      node.appendChild(t);
+      while(t.attributes.length) {
+        node.setAttribute(t.attributes[0].name, t.attributes[0].value);
+        t.removeAttribute(t.attributes[0].name);
+      }
+    }
+    return node;
+  }
+
+  // add annotations gleaned from children of `root` to `list`, `root`'s
+  // `note` is supplied as it is the note.parent of added annotations
+  function parseChildNodesAnnotations(root, note, list, stripWhiteSpace, ownerDocument) {
+    if (root.firstChild) {
+      let node = root.firstChild;
+      let i = 0;
+      while (node) {
+        // Wrap templates
+        if (node.localName == 'template') {
+          node = wrapTemplateExtension(node);
+        }
+        // Recurse
+        if (node.localName == 'template' &&
+          !node.hasAttribute('preserve-content')) {
+          parseTemplate(node, i, list, note, stripWhiteSpace, ownerDocument);
+        }
+        // collapse adjacent textNodes: fixes an IE issue that can cause
+        // text nodes to be inexplicably split =(
+        // note that root.normalize() should work but does not so we do this
+        // manually.
+        let next = node.nextSibling;
+        if (node.nodeType === Node.TEXT_NODE) {
+          let n = next;
+          while (n && (n.nodeType === Node.TEXT_NODE)) {
+            node.textContent += n.textContent;
+            next = n.nextSibling;
+            root.removeChild(n);
+            n = next;
+          }
+          // optionally strip whitespace
+          if (stripWhiteSpace && !node.textContent.trim()) {
+            root.removeChild(node);
+            // decrement index since node is removed
+            i--;
+          }
+        }
+        // if this node didn't get evacipated, parse it.
+        if (node.parentNode) {
+          let childAnnotation = parseNodeAnnotations(node, list,
+            stripWhiteSpace, ownerDocument);
+          if (childAnnotation) {
+            childAnnotation.parent = note;
+            childAnnotation.index = i;
+          }
+        }
+        node = next;
+        i++;
+      }
+    }
+  }
+
+  // 1. Parse annotations from the template and memoize them on
+  //    content._notes (recurses into nested templates)
+  // 2. Remove template.content and store it in annotation list, where it
+  //    will be the responsibility of the host to set it back to the template
+  //    (this is both an optimization to avoid re-stamping nested template
+  //    children and avoids a bug in Chrome where nested template children
+  //    upgrade)
+  function parseTemplate(node, index, list, parent, stripWhiteSpace, ownerDocument) {
+    let content = node.content.ownerDocument.createDocumentFragment();
+    content._notes = parseTemplateAnnotations(node, stripWhiteSpace, ownerDocument);
+    content.appendChild(node.content);
+    list.push({
+      bindings: emptyArray,
+      events: emptyArray,
+      templateContent: content,
+      parent: parent,
+      index: index
+    });
+  }
+
+  // add annotation data from attributes to the `annotation` for node `node`
+  function parseNodeAttributeAnnotations(node, annotation) {
+    // Make copy of original attribute list, since the order may change
+    // as attributes are added and removed
+    let attrs = Array.prototype.slice.call(node.attributes);
+    for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
+      let n = a.name;
+      let v = a.value;
+      let b;
+      // events (on-*)
+      if (n.slice(0, 3) === 'on-') {
+        node.removeAttribute(n);
+        annotation.events.push({
+          name: n.slice(3),
+          value: v
+        });
+      }
+      // bindings (other attributes)
+      else if ((b = parseNodeAttributeAnnotation(node, n, v))) {
+        annotation.bindings.push(b);
+      }
+      // static id
+      else if (n === 'id') {
+        annotation.id = v;
+      }
+    }
+  }
+
+  // construct annotation data from a generic attribute, or undefined
+  function parseNodeAttributeAnnotation(node, name, value) {
+    let parts = parseBindings(value);
+    if (parts) {
+      // Attribute or property
+      let origName = name;
+      let kind = 'property';
+      if (name[name.length-1] == '$') {
+        name = name.slice(0, -1);
+        kind = 'attribute';
+      }
+      // Initialize attribute bindings with any literal parts
+      let literal = literalFromParts(parts);
+      if (literal && kind == 'attribute') {
+        node.setAttribute(name, literal);
+      }
+      // Clear attribute before removing, since IE won't allow removing
+      // `value` attribute if it previously had a value (can't
+      // unconditionally set '' before removing since attributes with `$`
+      // can't be set using setAttribute)
+      if (node.localName === 'input' && origName === 'value') {
+        node.setAttribute(origName, '');
+      }
+      // Remove annotation
+      node.removeAttribute(origName);
+      // Case hackery: attributes are lower-case, but bind targets
+      // (properties) are case sensitive. Gambit is to map dash-case to
+      // camel-case: `foo-bar` becomes `fooBar`.
+      // Attribute bindings are excepted.
+      let propertyName = Polymer.CaseMap.dashToCamelCase(name);
+      if (kind === 'property') {
+        name = propertyName;
+      }
+      return {
+        kind: kind,
+        name: name,
+        propertyName: propertyName,
+        parts: parts,
+        literal: literal,
+        isCompound: parts.length !== 1
+      };
+    }
+  }
+
+  function findTemplateAnnotatedNode(root, note) {
+    // recursively ascend tree until we hit root
+    let parent = note.parent && findTemplateAnnotatedNode(root,
+      note.parent);
+    // unwind the stack, returning the indexed node at each level
+    if (parent) {
+      // note: marginally faster than indexing via childNodes
+      // (http://jsperf.com/childnodes-lookup)
+      for (let n=parent.firstChild, i=0; n; n=n.nextSibling) {
+        if (note.index === i++) {
+          return n;
+        }
+      }
+    } else {
+      return root;
+    }
+  }
+
+  // construct `$` map (from id annotations)
+  function applyIdToMap(inst, map, node, note) {
+    if (note.id) {
+      map[note.id] = node;
+    }
+  }
+
+  // install event listeners (from event annotations)
+  function applyEventListener(inst, node, note, host) {
+    if (note.events && note.events.length) {
+      for (let j=0, e$=note.events, e; (j<e$.length) && (e=e$[j]); j++) {
+        inst._addMethodEventListenerToNode(node, e.name, e.value, host);
+      }
+    }
+  }
+
+  // push configuration references at configure time
+  function applyTemplateContent(inst, node, note) {
+    if (note.templateContent) {
+      node._content = note.templateContent;
+    }
+  }
+
+  function createNodeEventHandler(context, eventName, methodName) {
+    // Instances can optionally have a _methodHost which allows redirecting where
+    // to find methods. Currently used by `templatize`.
+    context = context._methodHost || context;
+    let handler = function(e) {
+      if (context[methodName]) {
+        context[methodName](e, e.detail);
+      } else {
+        console.warn('listener method `' + methodName + '` not defined');
+      }
+    };
+    return handler;
+  }
+
+  /**
+   * Element mixin that provides basic template parsing and stamping, including
+   * the following template-related features for stamped templates:
+   *
+   * - Declarative event listeners (`on-eventname="listener"`)
+   * - Map of node id's to stamped node instances (`this.$.id`)
+   * - Nested template content caching/removal and re-installation (performance
+   *   optimization)
+   * - Relative URL's relative to original template location
+   * - Template binding annotation parsing (note that this library only parses
+   *   template bindings and provides annotation metadata; see
+   *   `Polymer.PropertyEffects` for a full implementation of data-binding)
+   *
+   * @polymerMixin
+   * @memberof Polymer
+   * @summary Element class mixin that provides basic template parsing and stamping
+   */
+  Polymer.TemplateStamp = Polymer.dedupingMixin(function(superClass) {
+
+    return class TemplateStamp extends superClass {
+
+      constructor() {
+        super();
+        this.$ = null;
+        this.__templateNodes = null;
+        this.__templateNotes = null;
+      }
+
+      /**
+       * Clones the provided template content and returns a document fragment
+       * containing the cloned dom.
+       *
+       * The template is parsed (once and memoized) using this library's
+       * template parsing features, which identify nodes with declarative
+       * event listeners (`on-...``), `id`'s, `<template>`s, and bindings
+       * (`{{...}}` and `[[...]]`).  This template metadata ("notes")
+       * are stored as `this.__templateNotes`, and any nodes identified in
+       * notes are collected for this instance into `__templateNodes` in
+       * the same order as the notes array.
+       *
+       * Finally, this method generates an "id map" for all nodes with id's
+       * under `this.$`, passes template content back to templates as `_content`
+       * (a performance optimization to avoid deep template cloning), and
+       * installs declarative event listeners.
+       *
+       * Note that the memoized template parsing process is destructive to the
+       * template: attributes for bindings and declarative event listeners are
+       * removed after being noted in notes, and any nested <template>.content
+       * is removed and stored in notes as well.
+       *
+       * Note that this method may only be called once per instance (it does
+       * not support stamping multiple templates per element instance).
+       *
+       * @param {HTMLTemplateElement} template Template to stamp
+       */
+      _stampTemplate(template) {
+        // Polyfill support: bootstrap the template if it has not already been
+        if (template && !template.content &&
+            window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
+          HTMLTemplateElement.decorate(template);
+        }
+        let notes = this.__templateNotes = this._parseTemplateAnnotations(template);
+        let dom = document.importNode(template._content || template.content, true);
+        // NOTE: ShadyDom optimization indicating there is an insertion point
+        dom.__noInsertionPoint = !notes._hasInsertionPoint;
+        this.$ = {};
+        this.__templateNodes = new Array(notes.length);
+        for (let i=0, l=notes.length, note, node; (i<l) && (note=notes[i]); i++) {
+          node = this.__templateNodes[i] = findTemplateAnnotatedNode(dom, note);
+          applyIdToMap(this, this.$, node, note);
+          applyTemplateContent(this, node, note);
+          applyEventListener(this, node, note, this);
+        }
+        return dom;
+      }
+
+      // preprocess-time
+
+      // construct and return a list of annotation records
+      // by scanning `template`'s content
+      //
+      // TODO(sorvell): This should just crawl over a template and call
+      // a supplied list of callbacks.
+      _parseTemplateAnnotations(template) {
+        return parseTemplateAnnotations(template);
+      }
+
+      _addMethodEventListenerToNode(node, eventName, methodName, context) {
+        context = context || node;
+        let handler = createNodeEventHandler(context, eventName, methodName);
+        this._addEventListenerToNode(node, eventName, handler);
+        return handler;
+      }
+
+      _addEventListenerToNode(node, eventName, handler) {
+        node.addEventListener(eventName, handler);
+      }
+
+      _removeEventListenerFromNode(node, eventName, handler) {
+        node.removeEventListener(eventName, handler);
+      }
+
+    }
+
+  });
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/array-splice.html b/lib/polymer2/bower_components/polymer/lib/utils/array-splice.html
new file mode 100644
index 00000000..34e45a65
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/array-splice.html
@@ -0,0 +1,296 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<script>
+(function() {
+
+  'use strict';
+
+  function newSplice(index, removed, addedCount) {
+    return {
+      index: index,
+      removed: removed,
+      addedCount: addedCount
+    };
+  }
+
+  const EDIT_LEAVE = 0;
+  const EDIT_UPDATE = 1;
+  const EDIT_ADD = 2;
+  const EDIT_DELETE = 3;
+
+  const ArraySplice = {
+
+    // Note: This function is *based* on the computation of the Levenshtein
+    // "edit" distance. The one change is that "updates" are treated as two
+    // edits - not one. With Array splices, an update is really a delete
+    // followed by an add. By retaining this, we optimize for "keeping" the
+    // maximum array items in the original array. For example:
+    //
+    //   'xxxx123' -> '123yyyy'
+    //
+    // With 1-edit updates, the shortest path would be just to update all seven
+    // characters. With 2-edit updates, we delete 4, leave 3, and add 4. This
+    // leaves the substring '123' intact.
+    calcEditDistances(current, currentStart, currentEnd,
+                                old, oldStart, oldEnd) {
+      // "Deletion" columns
+      let rowCount = oldEnd - oldStart + 1;
+      let columnCount = currentEnd - currentStart + 1;
+      let distances = new Array(rowCount);
+
+      // "Addition" rows. Initialize null column.
+      for (let i = 0; i < rowCount; i++) {
+        distances[i] = new Array(columnCount);
+        distances[i][0] = i;
+      }
+
+      // Initialize null row
+      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 (this.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;
+    },
+
+    // This starts at the final weight, and walks "backward" by finding
+    // the minimum previous weight recursively until the origin of the weight
+    // matrix.
+    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;
+    },
+
+    /**
+     * Splice Projection functions:
+     *
+     * A splice map is a representation of how a previous array of items
+     * was transformed into a new array of items. Conceptually it is a list of
+     * tuples of
+     *
+     *   <index, removed, addedCount>
+     *
+     * which are kept in ascending index order of. The tuple represents that at
+     * the |index|, |removed| sequence of items were removed, and counting forward
+     * from |index|, |addedCount| items were added.
+     */
+
+    /**
+     * Lacking individual splice mutation information, the minimal set of
+     * splices can be synthesized given the previous state and final state of an
+     * array. The basic approach is to calculate the edit distance matrix and
+     * choose the shortest path through it.
+     *
+     * Complexity: O(l * p)
+     *   l: The length of the current array
+     *   p: The length of the old array
+     */
+    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 = this.sharedPrefix(current, old, minLength);
+
+      if (currentEnd == current.length && oldEnd == old.length)
+        suffixCount = this.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 = this.spliceOperationsFromEditDistances(
+          this.calcEditDistances(current, currentStart, currentEnd,
+                                 old, oldStart, oldEnd));
+
+      splice = undefined;
+      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 = undefined;
+            }
+
+            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;
+    },
+
+    sharedPrefix(current, old, searchLength) {
+      for (let i = 0; i < searchLength; i++)
+        if (!this.equals(current[i], old[i]))
+          return i;
+      return searchLength;
+    },
+
+    sharedSuffix(current, old, searchLength) {
+      let index1 = current.length;
+      let index2 = old.length;
+      let count = 0;
+      while (count < searchLength && this.equals(current[--index1], old[--index2]))
+        count++;
+
+      return count;
+    },
+
+    calculateSplices(current, previous) {
+      return this.calcSplices(current, 0, current.length, previous, 0,
+                              previous.length);
+    },
+
+    equals(currentValue, previousValue) {
+      return currentValue === previousValue;
+    }
+
+  };
+
+  /**
+   * @namespace
+   * @memberof Polymer
+   * @summary Module that provides utilities for diffing arrays.
+   */
+  Polymer.ArraySplice = {
+    /**
+     * Returns an array of splice records indicating the minimum edits required
+     * to transform the `previous` array into the `current` array.
+     *
+     * Splice records are ordered by index and contain the following fields:
+     * - `index`: index where edit started
+     * - `removed`: array of removed items from this index
+     * - `addedCount`: number of items added at this index
+     *
+     * This function is based on the Levenshtein "minimum edit distance"
+     * algorithm. Note that updates are treated as removal followed by addition.
+     *
+     * The worst-case time complexity of this algorithm is `O(l * p)`
+     *   l: The length of the current array
+     *   p: The length of the previous array
+     *
+     * However, the worst-case complexity is reduced by an `O(n)` optimization
+     * to detect any shared prefix & suffix between the two arrays and only
+     * perform the more expensive minimum edit distance calculation over the
+     * non-shared portions of the arrays.
+     *
+     * @memberof Polymer.ArraySplice
+     */
+    calculateSplices(current, previous) {
+      return ArraySplice.calculateSplices(current, previous);
+    }
+  }
+
+})();
+</script>
\ No newline at end of file
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/async.html b/lib/polymer2/bower_components/polymer/lib/utils/async.html
new file mode 100644
index 00000000..6bcfbd4b
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/async.html
@@ -0,0 +1,202 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  /** @typedef {{run: function(function(), number=):number, cancel: function(number)}} */
+  let AsyncInterface; // eslint-disable-line no-unused-vars
+
+  // Microtask implemented using Mutation Observer
+  let microtaskCurrHandle = 0;
+  let microtaskLastHandle = 0;
+  let microtaskCallbacks = [];
+  let microtaskNodeContent = 0;
+  let microtaskNode = document.createTextNode('');
+  new window.MutationObserver(microtaskFlush).observe(microtaskNode, {characterData: true});
+
+  function microtaskFlush() {
+    const len = microtaskCallbacks.length;
+    for (let i = 0; i < len; i++) {
+      let cb = microtaskCallbacks[i];
+      if (cb) {
+        try {
+          cb();
+        } catch (e) {
+          setTimeout(() => { throw e });
+        }
+      }
+    }
+    microtaskCallbacks.splice(0, len);
+    microtaskLastHandle += len;
+  }
+
+  /**
+   * Module that provides a number of strategies for enqueuing asynchronous
+   * tasks.  Each sub-module provides a standard `run(fn)` interface that returns a
+   * handle, and a `cancel(handle)` interface for canceling async tasks before
+   * they run.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module that provides a number of strategies for enqueuing asynchronous
+   * tasks.
+   */
+  Polymer.Async = {
+
+    /**
+     * Async interface wrapper around `setTimeout`.
+     *
+     * @namespace
+     * @memberof Polymer.Async
+     * @summary Async interface wrapper around `setTimeout`.
+     */
+    timeOut: {
+      /**
+       * Returns a sub-module with the async interface providing the provided
+       * delay.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {number} delay Time to wait before calling callbacks in ms
+       * @return {AsyncInterface} An async timeout interface
+       */
+      after(delay) {
+        return  {
+          run(fn) { return setTimeout(fn, delay) },
+          cancel: window.clearTimeout.bind(window)
+        }
+      },
+      /**
+       * Enqueues a function called in the next task.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {Function} fn Callback to run
+       * @return {*} Handle used for canceling task
+       */
+      run: window.setTimeout.bind(window),
+      /**
+       * Cancels a previously enqueued `timeOut` callback.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {*} handle Handle returned from `run` of callback to cancel
+       */
+      cancel: window.clearTimeout.bind(window)
+    },
+
+    /**
+     * Async interface wrapper around `requestAnimationFrame`.
+     *
+     * @namespace
+     * @memberof Polymer.Async
+     * @summary Async interface wrapper around `requestAnimationFrame`.
+     */
+    animationFrame: {
+      /**
+       * Enqueues a function called at `requestAnimationFrame` timing.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {Function} fn Callback to run
+       * @return {*} Handle used for canceling task
+       */
+      run: window.requestAnimationFrame.bind(window),
+      /**
+       * Cancels a previously enqueued `animationFrame` callback.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {*} handle Handle returned from `run` of callback to cancel
+       */
+      cancel: window.cancelAnimationFrame.bind(window)
+    },
+
+    /**
+     * Async interface wrapper around `requestIdleCallback`.  Falls back to
+     * `setTimeout` on browsers that do not support `requestIdleCallback`.
+     *
+     * @namespace
+     * @memberof Polymer.Async
+     * @summary Async interface wrapper around `requestIdleCallback`.
+     */
+    idlePeriod: {
+      /**
+       * Enqueues a function called at `requestIdleCallback` timing.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {Function} fn Callback to run
+       * @return {*} Handle used for canceling task
+       */
+      run(fn) {
+        return window.requestIdleCallback ?
+          window.requestIdleCallback(fn) :
+          window.setTimeout(fn, 16);
+      },
+      /**
+       * Cancels a previously enqueued `idlePeriod` callback.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {*} handle Handle returned from `run` of callback to cancel
+       */
+      cancel(timer) {
+        return window.cancelIdleCallback ?
+          window.cancelIdleCallback(timer) :
+          window.clearTimeout(timer);
+      }
+    },
+
+    /**
+     * Async interface for enqueueing callbacks that run at microtask timing.
+     *
+     * Note that microtask timing is achieved via a single `MutationObserver`,
+     * and thus callbacks enqueued with this API will all run in a single
+     * batch, and not interleaved with other microtasks such as promises.
+     * Promises are avoided as an implementation choice for the time being
+     * due to Safari bugs that cause Promises to lack microtask guarantees.
+     *
+     * @namespace
+     * @memberof Polymer.Async
+     * @summary Async interface for enqueueing callbacks that run at microtask
+     *   timing.
+     */
+    microTask: {
+
+      /**
+       * Enqueues a function called at microtask timing.
+       *
+       * @memberof Polymer.Async.timeOut
+       * @param {Function} fn Callback to run
+       */
+      run(callback) {
+        microtaskNode.textContent = microtaskNodeContent++;
+        microtaskCallbacks.push(callback);
+        return microtaskCurrHandle++;
+      },
+
+      /**
+       * Cancels a previously enqueued `microTask` callback.
+       *
+       * @param {*} handle Handle returned from `run` of callback to cancel
+       */
+      cancel(handle) {
+        const idx = handle - microtaskLastHandle;
+        if (idx >= 0) {
+          if (!microtaskCallbacks[idx]) {
+            throw new Error('invalid async handle: ' + handle);
+          }
+          microtaskCallbacks[idx] = null;
+        }
+      }
+
+    }
+  };
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/boot.html b/lib/polymer2/bower_components/polymer/lib/utils/boot.html
new file mode 100644
index 00000000..677a2954
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/boot.html
@@ -0,0 +1,51 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<script>
+(function() {
+  'use strict';
+
+  const userPolymer = window.Polymer;
+
+  /**
+   * @namespace Polymer
+   * @summary Polymer is a lightweight library built on top of the web
+   * standards-based Web Components API's, and makes it easy to build your
+   * own custom HTML elements.
+   */
+  window.Polymer = function(info) {
+    return window.Polymer._polymerFn(info);
+  }
+
+  // support user settings on the Polymer object
+  if (userPolymer) {
+    Object.assign(Polymer, userPolymer);
+  }
+
+  // To be plugged by legacy implementation if loaded
+  window.Polymer._polymerFn = function() {
+    throw new Error('Load polymer.html to use the Polymer() function.');
+  }
+  window.Polymer.version = '2.0-preview';
+
+  /* eslint-disable no-unused-vars */
+  /*
+  When using Closure Compiler, goog.reflect.objectProperty(property, object) is replaced by the munged name for object[property]
+  We cannot alias this function, so we have to use a small shim that has the same behavior when not compiling.
+  */
+  window.goog = window.goog || {};
+  window.goog.reflect = window.goog.reflect || {
+    objectProperty(s, o) {
+      return s;
+    }
+  };
+  /* eslint-enable */
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/case-map.html b/lib/polymer2/bower_components/polymer/lib/utils/case-map.html
new file mode 100644
index 00000000..b1b44cda
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/case-map.html
@@ -0,0 +1,64 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<script>
+(function() {
+  'use strict';
+
+  const caseMap = {};
+  const DASH_TO_CAMEL = /-[a-z]/g;
+  const CAMEL_TO_DASH = /([A-Z])/g;
+
+  /**
+   * Module with utilities for converting between "dash-case" and "camelCase"
+   * identifiers.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module that provides utilities for converting between "dash-case"
+   *   and "camelCase".
+   */
+  const CaseMap = {
+
+    /**
+     * Converts "dash-case" identifier (e.g. `foo-bar-baz`) to "camelCase"
+     * (e.g. `fooBarBaz`).
+     *
+     * @memberof Polymer.CaseMap
+     * @param {string} dash Dash-case identifier
+     * @return {string} Camel-case representation of the identifier
+     */
+    dashToCamelCase(dash) {
+      return caseMap[dash] || (
+        caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(DASH_TO_CAMEL,
+          (m) => m[1].toUpperCase()
+        )
+      );
+    },
+
+    /**
+     * Converts "camelCase" identifier (e.g. `fooBarBaz`) to "dash-case"
+     * (e.g. `foo-bar-baz`).
+     *
+     * @memberof Polymer.CaseMap
+     * @param {string} camel Camel-case identifier
+     * @return {string} Dash-case representation of the identifier
+     */
+    camelToDashCase(camel) {
+      return caseMap[camel] || (
+        caseMap[camel] = camel.replace(CAMEL_TO_DASH, '-$1').toLowerCase()
+      );
+    }
+
+  };
+
+  Polymer.CaseMap = CaseMap;
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/debounce.html b/lib/polymer2/bower_components/polymer/lib/utils/debounce.html
new file mode 100644
index 00000000..8681b432
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/debounce.html
@@ -0,0 +1,91 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<link rel="import" href="mixin.html">
+<link rel="import" href="async.html">
+
+<script>
+(function() {
+  'use strict';
+
+  /** @typedef {{run: function(function(), number=):number, cancel: function(number)}} */
+  let AsyncModule; // eslint-disable-line no-unused-vars
+
+  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 {!AsyncModule} asyncModule
+     * @param {function()} callback
+     */
+    setConfig(asyncModule, cb) {
+      this._asyncModule = asyncModule;
+      this._callback = cb;
+      this._timer = this._asyncModule.run(() => {
+        this._timer = null;
+        this._callback()
+      });
+    }
+    /**
+     * Cancels an active debouncer and returns a reference to itself.
+     */
+    cancel() {
+      if (this.isActive()) {
+        this._asyncModule.cancel(this._timer);
+        this._timer = null;
+      }
+    }
+    /**
+     * Flushes an active debouncer and returns a reference to itself.
+     */
+    flush() {
+      if (this.isActive()) {
+        this.cancel();
+        this._callback();
+      }
+    }
+    /**
+     * Returns true if the debouncer is active.
+     *
+     * @return {boolean}
+     */
+    isActive() {
+      return this._timer != null;
+    }
+  /**
+   * Creates a debouncer if no debouncer is passed as a parameter
+   * or it cancels an active debouncer otherwise.
+   *
+   * @param {Polymer.Debouncer?} debouncer
+   * @param {!AsyncModule} asyncModule
+   * @param {function()} cb
+   * @return {!Debouncer}
+   */
+    static debounce(debouncer, asyncModule, cb) {
+      if (debouncer instanceof Debouncer) {
+        debouncer.cancel();
+      } else {
+        debouncer = new Debouncer();
+      }
+      debouncer.setConfig(asyncModule, cb);
+      return debouncer;
+    }
+  }
+
+  Polymer.Debouncer = Debouncer;
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/flattened-nodes-observer.html b/lib/polymer2/bower_components/polymer/lib/utils/flattened-nodes-observer.html
new file mode 100644
index 00000000..0a49b3ab
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/flattened-nodes-observer.html
@@ -0,0 +1,242 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/array-splice.html">
+<link rel="import" href="../utils/async.html">
+<script>
+(function() {
+  'use strict';
+
+  function isSlot(node) {
+    return (node.localName === 'slot');
+  }
+
+  /**
+   * Class that listens for changes (additions or removals) to
+   * "flattened nodes" on a given `node`. The list of flattened nodes 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.
+   *
+   * The provided `callback` is called whenever any change to this list
+   * of flattened nodes occurs, where an addition or removal of a node is
+   * considered a change. The `callback` is called with one argument, an object
+   * containing an array of any `addedNodes` and `removedNodes`.
+   *
+   * Note: the callback is called asynchronous to any changes
+   * at a microtask checkpoint. This is because observation is performed using
+   * `MutationObserver` and the `<slot> element's `slotchange` event which
+   * are asynchronous.
+   *
+   * @memberof Polymer
+   * @param {Node} target Node on which to listen for changes.
+   * @param {Function} callback Function called when there are additions
+   * or removals from the target's list of flattened nodes.
+   * @summary Class that listens for changes (additions or removals) to
+   * "flattened nodes" on a given `node`.
+   */
+  class FlattenedNodesObserver {
+
+    /**
+     * 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 {Node} node The node for which to return the list of flattened nodes.
+     * @returns {Array} The list of flattened nodes for the given `node`.
+    */
+    static getFlattenedNodes(node) {
+      if (isSlot(node)) {
+        return node.assignedNodes({flatten: true});
+      } else {
+        return Array.from(node.childNodes).map(node => {
+          if (isSlot(node)) {
+            return node.assignedNodes({flatten: true});
+          } else {
+            return [node];
+          }
+        }).reduce((a, b) => a.concat(b), []);
+      }
+    }
+
+    constructor(target, callback) {
+      /** @type {MutationObserver} */
+      this._shadyChildrenObserver = null;
+      /** @type {MutationObserver} */
+      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.
+     */
+    connect() {
+      if (isSlot(this._target)) {
+        this._listenSlots([this._target]);
+      } else {
+        this._listenSlots(this._target.children);
+        if (window.ShadyDOM) {
+          this._shadyChildrenObserver =
+            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.
+     */
+    disconnect() {
+      if (isSlot(this._target)) {
+        this._unlistenSlots([this._target]);
+      } else {
+        this._unlistenSlots(this._target.children);
+        if (window.ShadyDOM && this._shadyChildrenObserver) {
+          ShadyDOM.unobserveChildren(this._shadyChildrenObserver);
+          this._shadyChildrenObserver = null;
+        } else if (this._nativeChildrenObserver) {
+          this._nativeChildrenObserver.disconnect();
+          this._nativeChildrenObserver = null;
+        }
+      }
+      this._connected = false;
+    }
+
+    _schedule() {
+      if (!this._scheduled) {
+        this._scheduled = true;
+        Polymer.Async.microTask.run(() => this.flush());
+      }
+    }
+
+    _processMutations(mutations) {
+      this._processSlotMutations(mutations);
+      this.flush();
+    }
+
+    _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;
+      }
+      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 = Polymer.ArraySplice.calculateSplices(newNodes,
+        this._effectiveNodes);
+      // process removals
+      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);
+        }
+      }
+      // process adds
+      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]);
+        }
+      }
+      // update cache
+      this._effectiveNodes = newNodes;
+      let didFlush = false;
+      if (info.addedNodes.length || info.removedNodes.length) {
+        didFlush = true;
+        this.callback.call(this._target, info);
+      }
+      return didFlush;
+    }
+
+    _listenSlots(nodeList) {
+      for (let i=0; i < nodeList.length; i++) {
+        let n = nodeList[i];
+        if (isSlot(n)) {
+          n.addEventListener('slotchange', this._boundSchedule);
+        }
+      }
+    }
+
+    _unlistenSlots(nodeList) {
+      for (let i=0; i < nodeList.length; i++) {
+        let n = nodeList[i];
+        if (isSlot(n)) {
+          n.removeEventListener('slotchange', this._boundSchedule);
+        }
+      }
+    }
+
+  }
+
+  Polymer.FlattenedNodesObserver = FlattenedNodesObserver;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/flush.html b/lib/polymer2/bower_components/polymer/lib/utils/flush.html
new file mode 100644
index 00000000..0e3384bc
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/flush.html
@@ -0,0 +1,60 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<script>
+(function() {
+  'use strict';
+
+  let debouncerQueue = [];
+
+  /**
+   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
+   *
+   * @memberof Polymer
+   * @param {Polymer.Debouncer} debouncer Debouncer to enqueue
+   */
+  Polymer.enqueueDebouncer = function(debouncer) {
+    debouncerQueue.push(debouncer);
+  }
+
+  function flushDebouncers() {
+    const didFlush = Boolean(debouncerQueue.length);
+    while (debouncerQueue.length) {
+      try {
+        debouncerQueue.shift().flush();
+      } catch(e) {
+        setTimeout(() => {
+          throw e;
+        });
+      }
+    }
+    return didFlush;
+  }
+
+  /**
+   * Forces several classes of asynchronously queued tasks to flush:
+   * - Debouncers added via `enqueueDebouncer`
+   * - ShadyDOM distribution
+   *
+   * @memberof Polymer
+   */
+  Polymer.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);
+  }
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/gestures.html b/lib/polymer2/bower_components/polymer/lib/utils/gestures.html
new file mode 100644
index 00000000..e4599758
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/gestures.html
@@ -0,0 +1,822 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<link rel="import" href="async.html">
+<link rel="import" href="debounce.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  // detect native touch action support
+  let HAS_NATIVE_TA = typeof document.head.style.touchAction === 'string';
+  let GESTURE_KEY = '__polymerGestures';
+  let HANDLED_OBJ = '__polymerGesturesHandled';
+  let TOUCH_ACTION = '__polymerGesturesTouchAction';
+  // radius for tap and track
+  let TAP_DISTANCE = 25;
+  let TRACK_DISTANCE = 5;
+  // number of last N track positions to keep
+  let TRACK_LENGTH = 2;
+
+  // Disabling "mouse" handlers for 2500ms is enough
+  let MOUSE_TIMEOUT = 2500;
+  let MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'click'];
+  // an array of bitmask values for mapping MouseEvent.which to MouseEvent.buttons
+  let MOUSE_WHICH_TO_BUTTONS = [0, 1, 4, 2];
+  let MOUSE_HAS_BUTTONS = (function() {
+    try {
+      return new MouseEvent('test', {buttons: 1}).buttons === 1;
+    } catch (e) {
+      return false;
+    }
+  })();
+
+  /* eslint no-empty: ["error", { "allowEmptyCatch": true }] */
+  // check for passive event listeners
+  let SUPPORTS_PASSIVE = false;
+  (function() {
+    try {
+      let opts = Object.defineProperty({}, 'passive', {get: function() {SUPPORTS_PASSIVE = true;}})
+      window.addEventListener('test', null, opts);
+      window.removeEventListener('test', null, opts);
+    } catch(e) {}
+  })();
+
+  // Check for touch-only devices
+  let IS_TOUCH_ONLY = navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/);
+
+  // touch will make synthetic mouse events
+  // `preventDefault` on touchend will cancel them,
+  // but this breaks `<input>` focus and link clicks
+  // disable mouse handlers for MOUSE_TIMEOUT ms after
+  // a touchend to ignore synthetic mouse events
+  let mouseCanceller = function(mouseEvent) {
+    // Check for sourceCapabilities, used to distinguish synthetic events
+    // if mouseEvent did not come from a device that fires touch events,
+    // it was made by a real mouse and should be counted
+    // http://wicg.github.io/InputDeviceCapabilities/#dom-inputdevicecapabilities-firestouchevents
+    let sc = mouseEvent.sourceCapabilities;
+    if (sc && !sc.firesTouchEvents) {
+      return;
+    }
+    // skip synthetic mouse events
+    mouseEvent[HANDLED_OBJ] = {skip: true};
+    // disable "ghost clicks"
+    if (mouseEvent.type === 'click') {
+      let path = mouseEvent.composedPath && mouseEvent.composedPath();
+      if (path) {
+        for (let i = 0; i < path.length; i++) {
+          if (path[i] === POINTERSTATE.mouse.target) {
+            return;
+          }
+        }
+      }
+      mouseEvent.preventDefault();
+      mouseEvent.stopPropagation();
+    }
+  };
+
+  /**
+   * @param {boolean=} setup
+   */
+  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) {
+        document.addEventListener(en, mouseCanceller, true);
+      } else {
+        document.removeEventListener(en, mouseCanceller, true);
+      }
+    }
+  }
+
+  function ignoreMouse(e) {
+    if (!POINTERSTATE.mouse.mouseIgnoreJob) {
+      setupTeardownMouseCanceller(true);
+    }
+    let unset = function() {
+      setupTeardownMouseCanceller();
+      POINTERSTATE.mouse.target = null;
+      POINTERSTATE.mouse.mouseIgnoreJob = null;
+    };
+    POINTERSTATE.mouse.target = e.composedPath()[0];
+    POINTERSTATE.mouse.mouseIgnoreJob = Polymer.Debouncer.debounce(
+          POINTERSTATE.mouse.mouseIgnoreJob
+        , Polymer.Async.timeOut.after(MOUSE_TIMEOUT)
+        , unset);
+  }
+
+  function hasLeftMouseButton(ev) {
+    let type = ev.type;
+    // exit early if the event is not a mouse event
+    if (MOUSE_EVENTS.indexOf(type) === -1) {
+      return false;
+    }
+    // ev.button is not reliable for mousemove (0 is overloaded as both left button and no buttons)
+    // instead we use ev.buttons (bitmask of buttons) or fall back to ev.which (deprecated, 0 for no buttons, 1 for left button)
+    if (type === 'mousemove') {
+      // allow undefined for testing events
+      let buttons = ev.buttons === undefined ? 1 : ev.buttons;
+      if ((ev instanceof window.MouseEvent) && !MOUSE_HAS_BUTTONS) {
+        buttons = MOUSE_WHICH_TO_BUTTONS[ev.which] || 0;
+      }
+      // buttons is a bitmask, check that the left button bit is set (1)
+      return Boolean(buttons & 1);
+    } else {
+      // allow undefined for testing events
+      let button = ev.button === undefined ? 0 : ev.button;
+      // ev.button is 0 in mousedown/mouseup/click for left button activation
+      return button === 0;
+    }
+  }
+
+  function isSyntheticClick(ev) {
+    if (ev.type === 'click') {
+      // ev.detail is 0 for HTMLElement.click in most browsers
+      if (ev.detail === 0) {
+        return true;
+      }
+      // in the worst case, check that the x/y position of the click is within
+      // the bounding box of the target of the event
+      // Thanks IE 10 >:(
+      let t = Gestures._findOriginalTarget(ev);
+      let bcr = t.getBoundingClientRect();
+      // use page x/y to account for scrolling
+      let x = ev.pageX, y = ev.pageY;
+      // ev is a synthetic click if the position is outside the bounding box of the target
+      return !((x >= bcr.left && x <= bcr.right) && (y >= bcr.top && y <= bcr.bottom));
+    }
+    return false;
+  }
+
+  let POINTERSTATE = {
+    mouse: {
+      target: null,
+      mouseIgnoreJob: null
+    },
+    touch: {
+      x: 0,
+      y: 0,
+      id: -1,
+      scrollDecided: false
+    }
+  };
+
+  function firstTouchAction(ev) {
+    let ta = 'auto';
+    let path = ev.composedPath && ev.composedPath();
+    if (path) {
+      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;
+  }
+
+  // use a document-wide touchend listener to start the ghost-click prevention mechanism
+  // Use passive event listeners, if supported, to not affect scrolling performance
+  document.addEventListener('touchend', ignoreMouse, SUPPORTS_PASSIVE ? {passive: true} : false);
+
+  /**
+   * Module for adding listeners to a node for the following normalized
+   * cross-platform "gesture" events:
+   * - `down` - mouse or touch went down
+   * - `up` - mouse or touch went up
+   * - `tap` - mouse click or finger tap
+   * - `track` - mouse drag or touch move
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module for adding cross-platform gesture event listeners.
+   */
+  const Gestures = {
+    gestures: {},
+    recognizers: [],
+
+    /**
+     * Finds the element rendered on the screen at the provided coordinates.
+     *
+     * Similar to `document.elementFromPoint`, but pierces through
+     * shadow roots.
+     *
+     * @memberof Polymer.Gestures
+     * @param {number} x Horizontal pixel coordinate
+     * @param {number} y Vertical pixel coordinate
+     */
+    deepTargetFind: function(x, y) {
+      let node = document.elementFromPoint(x, y);
+      let next = node;
+      // this code path is only taken when native ShadowDOM is used
+      // if there is a shadowroot, it may have a node at x/y
+      // if there is not a shadowroot, exit the loop
+      while (next && next.shadowRoot && !window.ShadyDOM) {
+        // if there is a node at x/y in the shadowroot, look deeper
+        next = next.shadowRoot.elementFromPoint(x, y);
+        if (next) {
+          node = next;
+        }
+      }
+      return node;
+    },
+    /**
+     * a cheaper check than ev.composedPath()[0];
+     *
+     * @private
+     */
+    _findOriginalTarget: function(ev) {
+      // shadowdom
+      if (ev.composedPath) {
+        return ev.composedPath()[0];
+      }
+      // shadydom
+      return ev.target;
+    },
+
+    /**
+     * @private
+     */
+    _handleNative: function(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') {
+          let t = ev.changedTouches[0];
+          if (type === 'touchstart') {
+            // only handle the first finger
+            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') {
+              Gestures._handleTouchAction(ev);
+            }
+          }
+        }
+      }
+      handled = ev[HANDLED_OBJ];
+      // used to ignore synthetic mouse events
+      if (handled.skip) {
+        return;
+      }
+      let recognizers = Gestures.recognizers;
+      // reset recognizer state
+      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();
+          }
+        }
+      }
+      // enforce gesture recognizer order
+      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);
+        }
+      }
+    },
+
+    /**
+     * @private
+     */
+    _handleTouchAction: function(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 prevent = false;
+        let dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
+        let dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
+        if (!ev.cancelable) {
+          // scrolling is happening
+        } else if (ta === 'none') {
+          prevent = true;
+        } else if (ta === 'pan-x') {
+          prevent = dy > dx;
+        } else if (ta === 'pan-y') {
+          prevent = dx > dy;
+        }
+        if (prevent) {
+          ev.preventDefault();
+        } else {
+          Gestures.prevent('track');
+        }
+      }
+    },
+
+    /**
+     * Adds an event listener to a node for the given gesture type.
+     *
+     * @memberof Polymer.Gestures
+     * @param {Node} node Node to add listener on
+     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
+     * @param {Function} handler Event listener function to call
+     */
+    addListener: function(node, evType, handler) {
+      if (this.gestures[evType]) {
+        this._add(node, evType, handler);
+        return true;
+      }
+    },
+
+    /**
+     * Removes an event listener from a node for the given gesture type.
+     *
+     * @memberof Polymer.Gestures
+     * @param {Node} node Node to remove listener from
+     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
+     * @param {Function} handler Event listener function previously passed to
+     *  `addListener`.
+     */
+    removeListener: function(node, evType, handler) {
+      if (this.gestures[evType]) {
+        this._remove(node, evType, handler);
+        return true;
+      }
+    },
+
+    /**
+     * automate the event listeners for the native events
+     *
+     * @private
+     */
+    _add: function(node, evType, handler) {
+      let recognizer = this.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];
+        // don't add mouse handlers on iOS because they cause gray selection overlays
+        if (IS_TOUCH_ONLY && MOUSE_EVENTS.indexOf(dep) > -1 && dep !== 'click') {
+          continue;
+        }
+        gd = gobj[dep];
+        if (!gd) {
+          gobj[dep] = gd = {_count: 0};
+        }
+        if (gd._count === 0) {
+          node.addEventListener(dep, this._handleNative);
+        }
+        gd[name] = (gd[name] || 0) + 1;
+        gd._count = (gd._count || 0) + 1;
+      }
+      node.addEventListener(evType, handler);
+      if (recognizer.touchAction) {
+        this.setTouchAction(node, recognizer.touchAction);
+      }
+    },
+
+    /**
+     * automate event listener removal for native events
+     *
+     * @private
+     */
+    _remove: function(node, evType, handler) {
+      let recognizer = this.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, this._handleNative);
+            }
+          }
+        }
+      }
+      node.removeEventListener(evType, handler);
+    },
+
+    /**
+     * Registers a new gesture event recognizer for adding new custom
+     * gesture event types.
+     *
+     * @memberof Polymer.Gestures
+     * @param {Object} recog Gesture recognizer descriptor
+     */
+    register: function(recog) {
+      this.recognizers.push(recog);
+      for (let i = 0; i < recog.emits.length; i++) {
+        this.gestures[recog.emits[i]] = recog;
+      }
+    },
+
+    /**
+     * @private
+     */
+    _findRecognizerByEvent: function(evName) {
+      for (let i = 0, r; i < this.recognizers.length; i++) {
+        r = this.recognizers[i];
+        for (let j = 0, n; j < r.emits.length; j++) {
+          n = r.emits[j];
+          if (n === evName) {
+            return r;
+          }
+        }
+      }
+      return null;
+    },
+
+    /**
+     * Sets scrolling direction on node.
+     *
+     * This value is checked on first move, thus it should be called prior to
+     * adding event listeners.
+     *
+     * @memberof Polymer.Gestures
+     * @param {Node} node Node to set touch action setting on
+     * @param {string} value Touch action value
+     */
+    setTouchAction: function(node, value) {
+      if (HAS_NATIVE_TA) {
+        node.style.touchAction = value;
+      }
+      node[TOUCH_ACTION] = value;
+    },
+
+    /**
+     * @private
+     */
+    _fire: function(target, type, detail) {
+      let ev = new Event(type, { bubbles: true, cancelable: true, composed: true });
+      ev.detail = detail;
+      target.dispatchEvent(ev);
+      // forward `preventDefault` in a clean way
+      if (ev.defaultPrevented) {
+        let preventer = detail.preventer || detail.sourceEvent;
+        if (preventer && preventer.preventDefault) {
+          preventer.preventDefault();
+        }
+      }
+    },
+
+    /**
+     * Prevents the dispatch and default action of the given event name.
+     *
+     * @memberof Polymer.Gestures
+     */
+    prevent: function(evName) {
+      let recognizer = this._findRecognizerByEvent(evName);
+      if (recognizer.info) {
+        recognizer.info.prevent = true;
+      }
+    },
+
+    /**
+     * Reset the 2500ms timeout on processing mouse input after detecting touch input.
+     *
+     * Touch inputs create synthesized mouse inputs anywhere from 0 to 2000ms after the touch.
+     * This method should only be called during testing with simulated touch inputs.
+     * Calling this method in production may cause duplicate taps or other Gestures.
+     *
+     * @method resetMouseCanceller
+     * @memberof Polymer.Gestures
+     */
+    resetMouseCanceller: function() {
+      if (POINTERSTATE.mouse.mouseIgnoreJob) {
+        POINTERSTATE.mouse.mouseIgnoreJob.flush();
+      }
+    }
+  };
+
+  Gestures.register({
+    name: 'downup',
+    deps: ['mousedown', 'touchstart', 'touchend'],
+    flow: {
+      start: ['mousedown', 'touchstart'],
+      end: ['mouseup', 'touchend']
+    },
+    emits: ['down', 'up'],
+
+    info: {
+      movefn: null,
+      upfn: null
+    },
+
+    reset: function() {
+      untrackDocument(this.info);
+    },
+
+    mousedown: function(e) {
+      if (!hasLeftMouseButton(e)) {
+        return;
+      }
+      let t = Gestures._findOriginalTarget(e);
+      let self = this;
+      let movefn = function movefn(e) {
+        if (!hasLeftMouseButton(e)) {
+          self._fire('up', t, e);
+          untrackDocument(self.info);
+        }
+      };
+      let upfn = function upfn(e) {
+        if (hasLeftMouseButton(e)) {
+          self._fire('up', t, e);
+        }
+        untrackDocument(self.info);
+      };
+      trackDocument(this.info, movefn, upfn);
+      this._fire('down', t, e);
+    },
+    touchstart: function(e) {
+      this._fire('down', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
+    },
+    touchend: function(e) {
+      this._fire('up', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
+    },
+    _fire: function(type, target, event, preventer) {
+      Gestures._fire(target, type, {
+        x: event.clientX,
+        y: event.clientY,
+        sourceEvent: event,
+        preventer: preventer,
+        prevent: function(e) {
+          return Gestures.prevent(e);
+        }
+      });
+    }
+  });
+
+  Gestures.register({
+    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: [],
+      addMove: function(move) {
+        if (this.moves.length > TRACK_LENGTH) {
+          this.moves.shift();
+        }
+        this.moves.push(move);
+      },
+      movefn: null,
+      upfn: null,
+      prevent: false
+    },
+
+    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);
+    },
+
+    hasMovedEnough: function(x, y) {
+      if (this.info.prevent) {
+        return false;
+      }
+      if (this.info.started) {
+        return true;
+      }
+      let dx = Math.abs(this.info.x - x);
+      let dy = Math.abs(this.info.y - y);
+      return (dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE);
+    },
+
+    mousedown: function(e) {
+      if (!hasLeftMouseButton(e)) {
+        return;
+      }
+      let t = Gestures._findOriginalTarget(e);
+      let self = this;
+      let movefn = function movefn(e) {
+        let x = e.clientX, y = e.clientY;
+        if (self.hasMovedEnough(x, y)) {
+          // first move is 'start', subsequent moves are 'move', mouseup is 'end'
+          self.info.state = self.info.started ? (e.type === 'mouseup' ? 'end' : 'track') : 'start';
+          if (self.info.state === 'start') {
+            // if and only if tracking, always prevent tap
+            Gestures.prevent('tap');
+          }
+          self.info.addMove({x: x, y: y});
+          if (!hasLeftMouseButton(e)) {
+            // always _fire "end"
+            self.info.state = 'end';
+            untrackDocument(self.info);
+          }
+          self._fire(t, e);
+          self.info.started = true;
+        }
+      };
+      let upfn = function upfn(e) {
+        if (self.info.started) {
+          movefn(e);
+        }
+
+        // remove the temporary listeners
+        untrackDocument(self.info);
+      };
+      // add temporary document listeners as mouse retargets
+      trackDocument(this.info, movefn, upfn);
+      this.info.x = e.clientX;
+      this.info.y = e.clientY;
+    },
+
+    touchstart: function(e) {
+      let ct = e.changedTouches[0];
+      this.info.x = ct.clientX;
+      this.info.y = ct.clientY;
+    },
+
+    touchmove: function(e) {
+      let t = Gestures._findOriginalTarget(e);
+      let ct = e.changedTouches[0];
+      let x = ct.clientX, y = ct.clientY;
+      if (this.hasMovedEnough(x, y)) {
+        if (this.info.state === 'start') {
+          // if and only if tracking, always prevent tap
+          Gestures.prevent('tap');
+        }
+        this.info.addMove({x: x, y: y});
+        this._fire(t, ct);
+        this.info.state = 'track';
+        this.info.started = true;
+      }
+    },
+
+    touchend: function(e) {
+      let t = Gestures._findOriginalTarget(e);
+      let ct = e.changedTouches[0];
+      // only trackend if track was started and not aborted
+      if (this.info.started) {
+        // reset started state on up
+        this.info.state = 'end';
+        this.info.addMove({x: ct.clientX, y: ct.clientY});
+        this._fire(t, ct, e);
+      }
+    },
+
+    _fire: function(target, touch) {
+      let secondlast = this.info.moves[this.info.moves.length - 2];
+      let lastmove = this.info.moves[this.info.moves.length - 1];
+      let dx = lastmove.x - this.info.x;
+      let dy = lastmove.y - this.info.y;
+      let ddx, ddy = 0;
+      if (secondlast) {
+        ddx = lastmove.x - secondlast.x;
+        ddy = lastmove.y - secondlast.y;
+      }
+      return Gestures._fire(target, 'track', {
+        state: this.info.state,
+        x: touch.clientX,
+        y: touch.clientY,
+        dx: dx,
+        dy: dy,
+        ddx: ddx,
+        ddy: ddy,
+        sourceEvent: touch,
+        hover: function() {
+          return Gestures.deepTargetFind(touch.clientX, touch.clientY);
+        }
+      });
+    }
+
+  });
+
+  Gestures.register({
+    name: 'tap',
+    deps: ['mousedown', 'click', 'touchstart', 'touchend'],
+    flow: {
+      start: ['mousedown', 'touchstart'],
+      end: ['click', 'touchend']
+    },
+    emits: ['tap'],
+    info: {
+      x: NaN,
+      y: NaN,
+      prevent: false
+    },
+    reset: function() {
+      this.info.x = NaN;
+      this.info.y = NaN;
+      this.info.prevent = false;
+    },
+    save: function(e) {
+      this.info.x = e.clientX;
+      this.info.y = e.clientY;
+    },
+
+    mousedown: function(e) {
+      if (hasLeftMouseButton(e)) {
+        this.save(e);
+      }
+    },
+    click: function(e) {
+      if (hasLeftMouseButton(e)) {
+        this.forward(e);
+      }
+    },
+
+    touchstart: function(e) {
+      this.save(e.changedTouches[0], e);
+    },
+    touchend: function(e) {
+      this.forward(e.changedTouches[0], e);
+    },
+
+    forward: function(e, preventer) {
+      let dx = Math.abs(e.clientX - this.info.x);
+      let dy = Math.abs(e.clientY - this.info.y);
+      let t = Gestures._findOriginalTarget(e);
+      // dx,dy can be NaN if `click` has been simulated and there was no `down` for `start`
+      if (isNaN(dx) || isNaN(dy) || (dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) || isSyntheticClick(e)) {
+        // prevent taps from being generated if an event has canceled them
+        if (!this.info.prevent) {
+          Gestures._fire(t, 'tap', {
+            x: e.clientX,
+            y: e.clientY,
+            sourceEvent: e,
+            preventer: preventer
+          });
+        }
+      }
+    }
+  });
+
+  /** @deprecated */
+  Gestures.findOriginalTarget = Gestures._findOriginalTarget;
+
+  /** @deprecated */
+  Gestures.add = Gestures.addListener;
+
+  /** @deprecated */
+  Gestures.remove = Gestures.removeListener;
+
+  Polymer.Gestures = Gestures;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/import-href.html b/lib/polymer2/bower_components/polymer/lib/utils/import-href.html
new file mode 100644
index 00000000..627eae9c
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/import-href.html
@@ -0,0 +1,108 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="boot.html">
+
+<script>
+
+(function() {
+
+  'use strict';
+
+  // run a callback when HTMLImports are ready or immediately if
+  // this api is not available.
+  function whenImportsReady(cb) {
+    if (window.HTMLImports) {
+      HTMLImports.whenReady(cb);
+    } else {
+      cb();
+    }
+  }
+
+  /**
+   * Convenience method for importing an HTML document imperatively.
+   *
+   * This method creates a new `<link rel="import">` element with
+   * the provided URL and appends it to the document to start loading.
+   * In the `onload` callback, the `import` property of the `link`
+   * element will contain the imported document contents.
+   *
+   * @memberof Polymer
+   * @method importHref
+   * @param {string} href URL to document to load.
+   * @param {Function=} onload Callback to notify when an import successfully
+   *   loaded.
+   * @param {Function=} onerror Callback to notify when an import
+   *   unsuccessfully loaded.
+   * @param {boolean=} optAsync True if the import should be loaded `async`.
+   *   Defaults to `false`.
+   * @return {HTMLLinkElement} The link element for the URL to be loaded.
+   */
+  Polymer.importHref = function(href, onload, onerror, optAsync) {
+    let link =
+      document.head.querySelector('link[href="' + href + '"][import-href]');
+    if (!link) {
+      link = document.createElement('link');
+      link.rel = 'import';
+      link.href = href;
+      link.setAttribute('import-href', '');
+    }
+    // always ensure link has `async` attribute if user specified one,
+    // even if it was previously not async. This is considered less confusing.
+    if (optAsync) {
+      link.setAttribute('async', '');
+    }
+    // NOTE: the link may now be in 3 states: (1) pending insertion,
+    // (2) inflight, (3) already laoded. In each case, we need to add
+    // event listeners to process callbacks.
+    let cleanup = function() {
+      link.removeEventListener('load', loadListener);
+      link.removeEventListener('error', errorListener);
+    }
+    let loadListener = function(event) {
+      cleanup();
+      // In case of a successful load, cache the load event on the link so
+      // that it can be used to short-circuit this method in the future when
+      // it is called with the same href param.
+      link.__dynamicImportLoaded = true;
+      if (onload) {
+        whenImportsReady(() => {
+          onload(event);
+        });
+      }
+    };
+    let errorListener = function(event) {
+      cleanup();
+      // In case of an error, remove the link from the document so that it
+      // will be automatically created again the next time `importHref` is
+      // called.
+      if (link.parentNode) {
+        link.parentNode.removeChild(link);
+      }
+      if (onerror) {
+        whenImportsReady(() => {
+          onerror(event);
+        });
+      }
+    };
+    link.addEventListener('load', loadListener);
+    link.addEventListener('error', errorListener);
+    if (link.parentNode == null) {
+      document.head.appendChild(link);
+    // if the link already loaded, dispatch a fake load event
+    // so that listeners are called and get a proper event argument.
+    } else if (link.__dynamicImportLoaded) {
+      link.dispatchEvent(new Event('load'));
+    }
+    return link;
+  };
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/mixin.html b/lib/polymer2/bower_components/polymer/lib/utils/mixin.html
new file mode 100644
index 00000000..91dbdbfe
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/mixin.html
@@ -0,0 +1,75 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="boot.html">
+
+<script>
+
+(function() {
+
+  'use strict';
+
+  // unique global id for deduping mixins.
+  let dedupeId = 0;
+
+  /**
+   * Given a mixin producing function, memoize applications of mixin to base
+   * @private
+   */
+  function cachingMixin(mixin) {
+    return function(base) {
+      if (!mixin.__mixinApplications) {
+        mixin.__mixinApplications = new WeakMap();
+      }
+      let map = mixin.__mixinApplications;
+      let application = map.get(base);
+      if (!application) {
+        application = mixin(base);
+        map.set(base, application);
+      }
+      return application;
+    };
+  }
+
+  /**
+   * Wraps an ES6 class expression mixin such that the mixin is only applied
+   * if it has not already been applied its base argument.  Also memoizes mixin
+   * applications.
+   *
+   * @memberof Polymer
+   * @param {function} mixin ES6 class expression mixin to wrap
+   * @return {function} Wrapped mixin that deduplicates and memoizes
+   *   mixin applications to base
+   */
+  Polymer.dedupingMixin = function(mixin) {
+    mixin = cachingMixin(mixin);
+    // maintain a unique id for each mixin
+    if (!mixin.__id) {
+      mixin.__dedupeId = ++dedupeId;
+    }
+    return function(base) {
+      let baseSet = base.__mixinSet;
+      if (baseSet && baseSet[mixin.__dedupeId]) {
+        return base;
+      }
+      let extended = mixin(base);
+      // copy inherited mixin set from the extended class, or the base class
+      // NOTE: we avoid use of Set here because some browser (IE11)
+      // cannot extend a base Set via the constructor.
+      extended.__mixinSet =
+        Object.create(extended.__mixinSet || baseSet || null);
+      extended.__mixinSet[mixin.__dedupeId] = true;
+      return extended;
+    }
+  };
+
+})();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/path.html b/lib/polymer2/bower_components/polymer/lib/utils/path.html
new file mode 100644
index 00000000..869358d3
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/path.html
@@ -0,0 +1,270 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="boot.html">
+
+<script>
+(function() {
+  'use strict';
+
+  /**
+   * Module with utilities for manipulating structured data path strings.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module with utilities for manipulating structured data path strings.
+   */
+  const Path = {
+
+    /**
+     * Returns true if the given string is a structured data path (has dots).
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isPath('foo.bar.baz') // true
+     * Polymer.Path.isPath('foo')         // false
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string} path Path string
+     * @return {boolean} True if the string contained one or more dots
+     */
+    isPath: function(path) {
+      return path.indexOf('.') >= 0;
+    },
+
+    /**
+     * Returns the root property name for the given path.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.root('foo.bar.baz') // 'foo'
+     * Polymer.Path.root('foo')         // 'foo'
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string} path Path string
+     * @return {string} Root property name
+     */
+    root: function(path) {
+      let dotIndex = path.indexOf('.');
+      if (dotIndex === -1) {
+        return path;
+      }
+      return path.slice(0, dotIndex);
+    },
+
+    /**
+     * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not
+     * Returns true if the given path is an ancestor of the base path.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isAncestor('foo.bar', 'foo')         // true
+     * Polymer.Path.isAncestor('foo.bar', 'foo.bar')     // false
+     * Polymer.Path.isAncestor('foo.bar', 'foo.bar.baz') // false
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string} path Path string
+     * @return {boolean} True if `path` is an ancestor of `base`
+     */
+    isAncestor: function(base, path) {
+      //     base.startsWith(path + '.');
+      return base.indexOf(path + '.') === 0;
+    },
+
+    /**
+     * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isDescendant('foo.bar', 'foo.bar.baz') // true
+     * Polymer.Path.isDescendant('foo.bar', 'foo.bar')     // false
+     * Polymer.Path.isDescendant('foo.bar', 'foo')         // false
+     * ```
+     *
+     * @memberof Polymer.Path
+     */
+    isDescendant: function(base, path) {
+      //     path.startsWith(base + '.');
+      return path.indexOf(base + '.') === 0;
+    },
+
+    /**
+     * Replaces a previous base path with a new base path, preserving the
+     * remainder of the path.
+     *
+     * User must ensure `path` has a prefix of `base`.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.translate('foo.bar', 'zot' 'foo.bar.baz') // 'zot.baz'
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string} base Current base string to remove
+     * @param {string} newBase New base string to replace with
+     * @param {string} path Path to translate
+     * @return {string} Translated string
+     */
+    translate: function(base, newBase, path) {
+      return newBase + path.slice(base.length);
+    },
+
+    matches: function(base, path) {
+      return (base === path) ||
+             this.isAncestor(base, path) ||
+             this.isDescendant(base, path);
+    },
+
+    /**
+     * Converts array-based paths to flattened path.  String-based paths
+     * are returned as-is.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'
+     * Polymer.Path.normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string | !Array<string|number>} path Input path
+     * @return {string} Flattened path
+     */
+    normalize: function(path) {
+      if (Array.isArray(path)) {
+        let parts = [];
+        for (let i=0; i<path.length; i++) {
+          let args = path[i].toString().split('.');
+          for (let j=0; j<args.length; j++) {
+            parts.push(args[j]);
+          }
+        }
+        return parts.join('.');
+      } else {
+        return path;
+      }
+    },
+
+    /**
+     * Splits a path into an array of property names. Accepts either arrays
+     * of path parts or strings.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']
+     * Polymer.Path.split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']
+     * ```
+     *
+     * @memberof Polymer.Path
+     * @param {string | !Array<string|number>} path Input path
+     * @return {!Array<string>} Array of path parts
+     */
+    split: function(path) {
+      if (Array.isArray(path)) {
+        return this.normalize(path).split('.');
+      }
+      return path.toString().split('.');
+    },
+
+    /**
+     * Reads a value from a path.  If any sub-property in the path is `undefined`,
+     * this method returns `undefined` (will never throw.
+     *
+     * @memberof Polymer.Path
+     * @param {Object} root Object from which to dereference path from
+     * @param {string | !Array<string|number>} path Path to read
+     * @param {Object=} info If an object is provided to `info`, the normalized
+     *  (flattened) path will be set to `info.path`.
+     * @return {*} Value at path, or `undefined` if the path could not be
+     *  fully dereferenced.
+     */
+    get: function(root, path, info) {
+      let prop = root;
+      let parts = this.split(path);
+      // Loop over path parts[0..n-1] and dereference
+      for (let i=0; i<parts.length; i++) {
+        if (!prop) {
+          return;
+        }
+        let part = parts[i];
+        prop = prop[part];
+      }
+      if (info) {
+        info.path = parts.join('.');
+      }
+      return prop;
+    },
+
+    /**
+     * Sets a value to a path.  If any sub-property in the path is `undefined`,
+     * this method will no-op.
+     *
+     * @memberof Polymer.Path
+     * @param {Object} root Object from which to dereference path from
+     * @param {string | !Array<string|number>} path Path to set
+     * @param {*} value Value to set to path
+     * @return {string | undefined} The normalized version of the input path
+     */
+    set: function(root, path, value) {
+      let prop = root;
+      let parts = this.split(path);
+      let last = parts[parts.length-1];
+      if (parts.length > 1) {
+        // Loop over path parts[0..n-2] and dereference
+        for (let i=0; i<parts.length-1; i++) {
+          let part = parts[i];
+          prop = prop[part];
+          if (!prop) {
+            return;
+          }
+        }
+        // Set value to object at end of path
+        prop[last] = value;
+      } else {
+        // Simple property set
+        prop[path] = value;
+      }
+      return parts.join('.');
+    }
+
+  };
+
+  /**
+   * Returns true if the given string is a structured data path (has dots).
+   *
+   * This function is deprecated.  Use `Polymer.Path.isPath` instead.
+   *
+   * Example:
+   *
+   * ```
+   * Polymer.Path.isDeep('foo.bar.baz') // true
+   * Polymer.Path.isDeep('foo')         // false
+   * ```
+   *
+   * @deprecated
+   * @memberof Polymer.Path
+   * @param {string} path Path string
+   * @return {boolean} True if the string contained one or more dots
+   */
+  Path.isDeep = Path.isPath;
+
+  Polymer.Path = Path;
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/render-status.html b/lib/polymer2/bower_components/polymer/lib/utils/render-status.html
new file mode 100644
index 00000000..1713b57d
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/render-status.html
@@ -0,0 +1,120 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+
+<script>
+(function() {
+
+  'use strict';
+
+  let scheduled = false;
+  let beforeRenderQueue = [];
+  let afterRenderQueue = [];
+
+  function schedule() {
+    scheduled = true;
+    // before next render
+    requestAnimationFrame(function() {
+      scheduled = false;
+      flushQueue(beforeRenderQueue);
+      // after the render
+      setTimeout(function() {
+        flushQueue(afterRenderQueue);
+      });
+    });
+  }
+
+  function flushQueue(queue) {
+    while (queue.length) {
+      const q = queue.shift();
+      const context = q[0];
+      const callback = q[1];
+      const args = q[2];
+      try {
+        callback.apply(context, args);
+      } catch(e) {
+        setTimeout(() => {
+          throw e;
+        })
+      }
+    }
+  }
+
+  function flush() {
+    while (beforeRenderQueue.length || afterRenderQueue.length) {
+      flushQueue(beforeRenderQueue);
+      flushQueue(afterRenderQueue);
+    }
+  }
+
+  /**
+   * Module for scheduling flushable pre-render and post-render tasks.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module for scheduling flushable pre-render and post-render tasks.
+   */
+  Polymer.RenderStatus = {
+
+    /**
+     * Enqueues a callback which will be run before the next render, at
+     * `requestAnimationFrame` timing.
+     *
+     * This method is useful for enqueuing work that requires DOM measurement,
+     * since measurement may not be reliable in custom element callbacks before
+     * the first render, as well as for batching measurement tasks in general.
+     *
+     * Tasks in this queue may be flushed by calling `Polymer.RenderStatus.flush()`.
+     *
+     * @memberof Polymer.RenderStatus
+     * @param {*} context Context object the callback function will be bound to
+     * @param {function} callback Callback function
+     * @param {Array} args An array of arguments to call the callback function with
+     */
+    beforeNextRender: function(context, callback, args) {
+      if (!scheduled) {
+        schedule();
+      }
+      beforeRenderQueue.push([context, callback, args]);
+    },
+
+    /**
+     * Enqueues a callback which will be run after the next render, equivalent
+     * to one task (`setTimeout`) after the next `requestAnimationFrame`.
+     *
+     * This method is useful for tuning the first-render performance of an
+     * element or application by deferring non-critical work until after the
+     * first paint.  Typical non-render-critical work may include adding UI
+     * event listeners and aria attributes.
+     *
+     * @memberof Polymer.RenderStatus
+     * @param {*} context Context object the callback function will be bound to
+     * @param {function} callback Callback function
+     * @param {Array} args An array of arguments to call the callback function with
+     */
+    afterNextRender: function(context, callback, args) {
+      if (!scheduled) {
+        schedule();
+      }
+      afterRenderQueue.push([context, callback, args]);
+    },
+
+    /**
+     * Flushes all `beforeNextRender` tasks, followed by all `afterNextRender`
+     * tasks.
+     *
+     * @memberof Polymer.RenderStatus
+     */
+    flush: flush
+
+  };
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/resolve-url.html b/lib/polymer2/bower_components/polymer/lib/utils/resolve-url.html
new file mode 100644
index 00000000..7bffd134
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/resolve-url.html
@@ -0,0 +1,108 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+
+<script>
+
+  (function() {
+    'use strict';
+
+    let CSS_URL_RX = /(url\()([^)]*)(\))/g;
+    let ABS_URL = /(^\/)|(^#)|(^[\w-\d]*:)/;
+    let workingURL;
+    let resolveDoc;
+    /**
+     * Resolves the given URL against the provided `baseUri'.
+     *
+     * @memberof Polymer.ResolveUrl
+     * @param {string} url Input URL to resolve
+     * @param {string} baseURI Base URI to resolve the URL against
+     * @return {string} resolved URL
+     */
+    function resolveUrl(url, baseURI) {
+      if (url && ABS_URL.test(url)) {
+        return url;
+      }
+      // Lazy feature detection.
+      if (workingURL === undefined) {
+        workingURL = false;
+        try {
+          const u = new URL('b', 'http://a');
+          u.pathname = 'c%20d';
+          workingURL = (u.href === 'http://a/c%20d');
+        } catch (e) {
+          // silently fail
+        }
+      }
+      if (!baseURI) {
+        baseURI = document.baseURI || window.location.href;
+      }
+      if (workingURL) {
+        return (new URL(url, baseURI)).href;
+      }
+      // Fallback to creating an anchor into a disconnected document.
+      if (!resolveDoc) {
+        resolveDoc = document.implementation.createHTMLDocument('temp');
+        resolveDoc.base = resolveDoc.createElement('base');
+        resolveDoc.head.appendChild(resolveDoc.base);
+        resolveDoc.anchor = resolveDoc.createElement('a');
+        resolveDoc.body.appendChild(resolveDoc.anchor);
+      }
+      resolveDoc.base.href = baseURI;
+      resolveDoc.anchor.href = url;
+      return resolveDoc.anchor.href || url;
+
+    }
+
+    /**
+     * Resolves any relative URL's in the given CSS text against the provided
+     * `ownerDocument`'s `baseURI`.
+     *
+     * @memberof Polymer.ResolveUrl
+     * @param {string} cssText CSS text to process
+     * @param {string} baseURI Base URI to resolve the URL against
+     * @return {string} Processed CSS text with resolved URL's
+     */
+    function resolveCss(cssText, baseURI) {
+      return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {
+        return pre + '\'' +
+          resolveUrl(url.replace(/["']/g, ''), baseURI) +
+          '\'' + post;
+      });
+    }
+
+    /**
+     * Returns a path from a given `url`. The path includes the trailing
+     * `/` from the url.
+     *
+     * @memberof Polymer.ResolveUrl
+     * @param {string} url Input URL to transform
+     * @return {string} resolved path
+     */
+    function pathFromUrl(url) {
+      return url.substring(0, url.lastIndexOf('/') + 1);
+    }
+
+    /**
+     * Module with utilities for resolving relative URL's.
+     *
+     * @namespace
+     * @memberof Polymer
+     * @summary Module with utilities for resolving relative URL's.
+     */
+    Polymer.ResolveUrl = {
+      resolveCss: resolveCss,
+      resolveUrl: resolveUrl,
+      pathFromUrl: pathFromUrl
+    };
+
+  })();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/style-gather.html b/lib/polymer2/bower_components/polymer/lib/utils/style-gather.html
new file mode 100644
index 00000000..1fb045f3
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/style-gather.html
@@ -0,0 +1,145 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="resolve-url.html">
+<script>
+(function() {
+  'use strict';
+
+  const MODULE_STYLE_LINK_SELECTOR = 'link[rel=import][type~=css]';
+  const INCLUDE_ATTR = 'include';
+
+  function importModule(moduleId) {
+    if (!Polymer.DomModule) {
+      return null;
+    }
+    return Polymer.DomModule.import(moduleId);
+  }
+
+  /**
+   * Module with utilities for collection CSS text from `<templates>`, external
+   * stylesheets, and `dom-module`s.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module with utilities for collection CSS text from various sources.
+   */
+  const StyleGather = {
+
+    /**
+     * Returns CSS text of styles in a space-separated list of `dom-module`s.
+     *
+     * @memberof Polymer.StyleGather
+     * @param {string} moduleIds
+     * @return {string} Concatenated CSS content from specified `dom-module`s
+     */
+    cssFromModules(moduleIds) {
+      let modules = moduleIds.trim().split(' ');
+      let cssText = '';
+      for (let i=0; i < modules.length; i++) {
+        cssText += this.cssFromModule(modules[i]);
+      }
+      return cssText;
+    },
+
+    /**
+     * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`
+     * can come either from `<style>`s within the first `<template>`, or else
+     * from one or more `<link rel="import" type="css">` links outside the
+     * template.
+     *
+     * Any `<styles>` processed are removed from their original location.
+     *
+     * @memberof Polymer.StyleGather
+     * @param {string} moduleId dom-module id to gather styles from
+     * @return {string} Concatenated CSS content from specified `dom-module`
+     */
+    cssFromModule(moduleId) {
+      let m = importModule(moduleId);
+      if (m && m._cssText === undefined) {
+        let cssText = '';
+        // include css from the first template in the module
+        let t = m.querySelector('template');
+        if (t) {
+          cssText += this.cssFromTemplate(t, m.assetpath);
+        }
+        // module imports: <link rel="import" type="css">
+        cssText += this.cssFromModuleImports(moduleId);
+        m._cssText = cssText || null;
+      }
+      if (!m) {
+        console.warn('Could not find style data in module named', moduleId);
+      }
+      return m && m._cssText || '';
+    },
+
+    /**
+     * Returns CSS text of `<styles>` within a given template.
+     *
+     * Any `<styles>` processed are removed from their original location.
+     *
+     * @memberof Polymer.StyleGather
+     * @param {HTMLTemplateElement} template Template to gather styles from
+     * @param {string} baseURI Base URI to resolve the URL against
+     * @return {string} Concatenated CSS content from specified template
+     */
+    cssFromTemplate(template, baseURI) {
+      let cssText = '';
+      // if element is a template, get content from its .content
+      let e$ = template.content.querySelectorAll('style');
+      for (let i=0; i < e$.length; i++) {
+        let e = e$[i];
+        // support style sharing by allowing styles to "include"
+        // other dom-modules that contain styling
+        let include = e.getAttribute(INCLUDE_ATTR);
+        if (include) {
+          cssText += this.cssFromModules(include);
+        }
+        e.parentNode.removeChild(e);
+        cssText += baseURI ?
+          Polymer.ResolveUrl.resolveCss(e.textContent, baseURI) : e.textContent;
+      }
+      return cssText;
+    },
+
+    /**
+     * Returns CSS text from stylsheets loaded via `<link rel="import" type="css">`
+     * links within the specified `dom-module`.
+     *
+     * @memberof Polymer.StyleGather
+     * @param {string} moduleId Id of `dom-module` to gather CSS from
+     * @return {string} Concatenated CSS content from links in specified `dom-module`
+     */
+    cssFromModuleImports(moduleId) {
+      let cssText = '';
+      let m = importModule(moduleId);
+      if (!m) {
+        return cssText;
+      }
+      let p$ = m.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);
+      for (let i=0; i < p$.length; i++) {
+        let p = p$[i];
+        if (p.import) {
+          let importDoc = p.import;
+          // NOTE: polyfill affordance.
+          // under the HTMLImports polyfill, there will be no 'body',
+          // but the import pseudo-doc can be used directly.
+          let container = importDoc.body ? importDoc.body : importDoc;
+          cssText +=
+            Polymer.ResolveUrl.resolveCss(container.textContent,
+              importDoc.baseURI);
+        }
+      }
+      return cssText;
+    }
+  };
+
+  Polymer.StyleGather = StyleGather;
+})();
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/templatize.html b/lib/polymer2/bower_components/polymer/lib/utils/templatize.html
new file mode 100644
index 00000000..ad1008ae
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/templatize.html
@@ -0,0 +1,458 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="boot.html">
+<link rel="import" href="../mixins/property-effects.html">
+<link rel="import" href="../mixins/mutable-data.html">
+
+<script>
+  (function() {
+    'use strict';
+
+    // Base class for HTMLTemplateElement extension that has property effects
+    // machinery for propagating host properties to children. This is an ES5
+    // class only because Babel (incorrectly) requires super() in the class
+    // constructor even though no `this` is used and it returns an instance.
+    let newInstance = null;
+    function HTMLTemplateElementExtension() { return newInstance; }
+    HTMLTemplateElementExtension.prototype = Object.create(HTMLTemplateElement.prototype, {
+      constructor: {
+        value: HTMLTemplateElementExtension,
+        writable: true
+      }
+    });
+    const DataTemplate = Polymer.PropertyEffects(HTMLTemplateElementExtension);
+    const MutableDataTemplate = Polymer.MutableData(DataTemplate);
+
+    // Applies a DataTemplate subclass to a <template> instance
+    function upgradeTemplate(template, constructor) {
+      newInstance = template;
+      Object.setPrototypeOf(template, constructor.prototype);
+      new constructor();
+      newInstance = null;
+    }
+
+    // Base class for TemplateInstance's
+    class TemplateInstanceBase extends Polymer.PropertyEffects(class{}) {
+      constructor(props) {
+        super();
+        this._configureProperties(props);
+        this.root = this._stampTemplate(this.__dataHost);
+        // Save list of stamped children
+        let children = this.children = [];
+        for (let n = this.root.firstChild; n; n=n.nextSibling) {
+          children.push(n);
+          n.__templatizeInstance = this;
+        }
+        if (this.__templatizeOwner.__hideTemplateChildren__) {
+          this._showHideChildren(true);
+        }
+        // Flush props only when props are passed if instance props exist
+        // or when there isn't instance props.
+        let options = this.__templatizeOptions;
+        if ((props && options.instanceProps) || !options.instanceProps) {
+          this._flushProperties();
+        }
+      }
+      /**
+       * @private
+       */
+      _configureProperties(props) {
+        let options = this.__templatizeOptions;
+        if (props) {
+          for (let iprop in options.instanceProps) {
+            if (iprop in props) {
+              this._setPendingProperty(iprop, props[iprop]);
+            }
+          }
+        }
+        for (let hprop in this.__hostProps) {
+          this._setPendingProperty(hprop, this.__dataHost['_host_' + hprop]);
+        }
+      }
+      /**
+       * 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
+       */
+      forwardHostProp(prop, value) {
+        if (this._setPendingPropertyOrPath(prop, value, false, true)) {
+          this.__dataHost._enqueueClient(this);
+        }
+      }
+      /**
+       * @override
+       */
+      _addEventListenerToNode(node, eventName, handler) {
+        if (this._methodHost && this.__templatizeOptions.parentModel) {
+          // If this instance should be considered a parent model, decorate
+          // events this template instance as `model`
+          this._methodHost._addEventListenerToNode(node, eventName, (e) => {
+            e.model = this;
+            handler(e);
+          });
+        } else {
+          // Otherwise delegate to the template's host (which could be)
+          // another template instance
+          let templateHost = this.__dataHost.__dataHost;
+          if (templateHost) {
+            templateHost._addEventListenerToNode(node, eventName, handler);
+          }
+        }
+      }
+      /**
+       * @protected
+       */
+      _showHideChildren(hide) {
+        let c = this.children;
+        for (let i=0; i<c.length; i++) {
+          let n = c[i];
+          // Ignore non-changes
+          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.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);
+          }
+        }
+      }
+      /**
+       * Overrides default property-effects implementation to intercept
+       * textContent bindings while children are "hidden" and cache in
+       * private storage for later retrieval.
+       *
+       * @override
+       */
+      _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.PropertyEffectsInterface} The parent model of this instance
+       */
+      get parentModel() {
+        let model = this.__parentModel;
+        if (!model) {
+          let options;
+          model = this
+          do {
+            // A template instance's `__dataHost` is a <template>
+            // `model.__dataHost.__dataHost` is the template's host
+            model = model.__dataHost.__dataHost;
+          } while ((options = model.__templatizeOptions) && !options.parentModel)
+          this.__parentModel = model;
+        }
+        return model;
+      }
+    }
+
+    const MutableTemplateInstanceBase = Polymer.MutableData(TemplateInstanceBase);
+
+    function findMethodHost(template) {
+      // Technically this should be the owner of the outermost template.
+      // In shadow dom, this is always getRootNode().host, but we can
+      // approximate this via cooperation with our dataHost always setting
+      // `_methodHost` as long as there were bindings (or id's) on this
+      // instance causing it to get a dataHost.
+      let templateHost = template.__dataHost;
+      return templateHost && templateHost._methodHost || templateHost;
+    }
+
+    function createTemplatizerClass(template, options) {
+      // Anonymous class created by the templatize
+      /**
+       * @unrestricted
+       */
+      let base = options.mutableData ?
+        MutableTemplateInstanceBase : TemplateInstanceBase;
+      let klass = class extends base { }
+      klass.prototype.__templatizeOptions = options;
+      klass.prototype._bindTemplate(template);
+      addNotifyEffects(klass, template, options);
+      return klass;
+    }
+
+    function addPropagateEffects(template, options) {
+      let userForwardHostProp = options.forwardHostProp;
+      if (userForwardHostProp) {
+        // Provide data API and property effects on memoized template class
+        let klass = template._content.__templatizeTemplateClass;
+        if (!klass) {
+          let base = options.mutableData ? MutableDataTemplate : DataTemplate;
+          klass = template._content.__templatizeTemplateClass =
+            class TemplatizedTemplate extends base {}
+          // Add template - >instances effects
+          // and host <- template effects
+          let hostProps = template._content._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);
+          }
+        }
+        upgradeTemplate(template, klass);
+        // Mix any pre-bound data into __data; no need to flush this to
+        // instances since they pull from the template at instance-time
+        if (template.__dataProto) {
+          // Note, generally `__dataProto` could be chained, but it's guaranteed
+          // to not be since this is a vanilla template we just added effects to
+          Object.assign(template.__data, template.__dataProto);
+        }
+        // Clear any pending data for performance
+        template.__dataTemp = {};
+        template.__dataPending = null;
+        template.__dataOld = null;
+        template._flushProperties();
+      }
+    }
+
+    function createForwardHostPropEffect(hostProp, userForwardHostProp) {
+      return function forwardHostProp(template, prop, props) {
+        userForwardHostProp.call(template.__templatizeOwner,
+          prop.substring('_host_'.length), props[prop]);
+      }
+    }
+
+    function addNotifyEffects(klass, template, options) {
+      let hostProps = template._content._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) {
+          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);
+      }
+    }
+
+    /**
+     * Module for preparing and stamping instances of templates that utilize
+     * Polymer's data-binding and declarative event listener features.
+     *
+     * Example:
+     *
+     *     // Get a template from somewhere, e.g. light DOM
+     *     let template = this.querySelector('template');
+     *     // Prepare the template
+     *     let TemplateClass = Polymer.Tempaltize.templatize(template);
+     *     // Instance the template with an initial data model
+     *     let instance = new TemplateClass({myProp: 'initial'});
+     *     // Insert the instance's DOM somewhere, e.g. element's shadow DOM
+     *     this.shadowRoot.appendChild(instance.root);
+     *     // Changing a property on the instance will propagate to bindings
+     *     // in the template
+     *     instance.myProp = 'new value';
+     *
+     * The `options` dictionary passed to `templatize` allows for customizing
+     * features of the generated template class, including how outer-scope host
+     * properties should be forwarded into template instances, how any instance
+     * properties added into the template's scope should be notified out to
+     * the host, and whether the instance should be decorated as a "parent model"
+     * of any event handlers.
+     *
+     *     // Customze property forwarding and event model decoration
+     *     let TemplateClass = Polymer.Tempaltize.templatize(template, this, {
+     *       parentModel: true,
+     *       instanceProps: {...},
+     *       forwardHostProp(property, value) {...},
+     *       notifyInstanceProp(instance, property, value) {...},
+     *     });
+     *
+     *
+     * @namespace
+     * @memberof Polymer
+     * @summary Module for preparing and stamping instances of templates
+     *   utilizing Polymer templating features.
+     */
+    const Templatize = {
+
+      /**
+       * Returns an anonymous `Polymer.PropertyEffects` class bound to the
+       * `<template>` provided.  Instancing the class will result in the
+       * template being stamped into document fragment stored as the instance's
+       * `root` property, after which it can be appended to the DOM.
+       *
+       * Templates may utilize all Polymer data-binding features as well as
+       * declarative event listeners.  Event listeners and inline computing
+       * functions in the template will be called on the host of the template.
+       *
+       * The constructor returned takes a single argument dictionary of initial
+       * property values to propagate into template bindings.  Additionally
+       * host properties can be forwarded in, and instance properties can be
+       * notified out by providing optional callbacks in the `options` dictionary.
+       *
+       * Valid configuration in `options` are as follows:
+       *
+       * - `forwardHostProp(property, value)`: Called when a property referenced
+       *   in the template changed on the template's host. As this library does
+       *   not retain references to templates instanced by the user, it is the
+       *   templatize owner's responsibility to forward host property changes into
+       *   user-stamped instances.  The `instance.forwardHostProp(property, value)`
+       *    method on the generated class should be called to forward host
+       *   properties into the template to prevent unnecessary property-changed
+       *   notifications. Any properties referenced in the template that are not
+       *   defined in `instanceProps` will be notified up to the template's host
+       *   automatically.
+       * - `instanceProps`: Dictionary of property names that will be added
+       *   to the instance by the templatize owner.  These properties shadow any
+       *   host properties, and changes within the template to these properties
+       *   will result in `notifyInstanceProperties` to be called.
+       * - `mutableData`: When `true`, the generated class will skip strict
+       *   dirty-checking for objects and arrays (always consider them to be
+       *   "dirty").
+       * - `notifyInstanceProperties(instance, property, value)`: Called when
+       *   an instance property changes.  Users may choose to call `notifyPath`
+       *   on e.g. the owner to notify the change.
+       * - `parentModel`: When `true`, events handled by declarative event listeners
+       *   (`on-event="handler"`) will be decorated with a `model` property pointing
+       *   to the template instance that stamped it.  It will also be returned
+       *   from `instance.parentModel` in cases where template instance nesting
+       *   causes an inner model to shadow an outer model.
+       *
+       * Note that the class returned from `templatize` is generated only once
+       * for a given `<template>` using `options` from the first call for that
+       * template, and the cached class is returned for all subsequent calls to
+       * `templatize` for that template.  As such, `options` callbacks should not
+       * close over owner-specific properties since only the first `options` is
+       * used; rather, callbacks are called bound to the `owner`, and so context
+       * needed from the callbacks (such as references to `instances` stamped)
+       * should be stored on the `owner` such that they can be retrieved via `this`.
+       *
+       * @memberof Polymer.Templatize
+       * @param {HTMLTemplateElement} template Template to templatize
+       * @param {*} owner Owner of the template instances; any optional callbacks
+       *   will be bound to this owner.
+       * @param {*} options Options dictionary (see summary for details)
+       * @return {TemplateInstanceBase} Generated class bound to the template
+       *   provided
+       */
+      templatize(template, owner, options) {
+        if (template.__templatizeOwner) {
+          throw new Error('A <template> can only be templatized once');
+        }
+        template.__templatizeOwner = owner;
+        // Ensure template has _content
+        template._content = template._content || template.content;
+        // Get memoized base class for the prototypical template, which
+        // includes property effects for binding template & forwarding
+        let baseClass = template._content.__templatizeInstanceClass;
+        if (!baseClass) {
+          baseClass = template._content.__templatizeInstanceClass =
+            createTemplatizerClass(template, options);
+        }
+        // Host property forwarding must be installed onto template instance
+        addPropagateEffects(template, options);
+        // Subclass base class and add reference for this specific template
+        let klass = class TemplateInstance extends baseClass {};
+        klass.prototype._methodHost = findMethodHost(template);
+        klass.prototype.__dataHost = template;
+        klass.prototype.__templatizeOwner = owner;
+        klass.prototype.__hostProps = template._content._hostProps;
+        return klass;
+      },
+
+      /**
+       * 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 is an instance of `Polymer.Base`, and
+       * 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);
+       *   }
+       *
+       * @memberof Polymer.Templatize
+       * @method modelForElement
+       * @param {HTMLElement} el Element for which to return a template model.
+       * @return {TemplateInstanceBase} Template instance representing the
+       *   binding scope for the element
+       */
+      modelForElement(host, el) {
+        let model;
+        while (el) {
+          // An element with a __templatizeInstance marks the top boundary
+          // of a scope; walk up until we find one, and then ensure that
+          // its __dataHost matches `this`, meaning this dom-repeat stamped it
+          if ((model = el.__templatizeInstance)) {
+            // Found an element stamped by another template; keep walking up
+            // from its __dataHost
+            if (model.__dataHost != host) {
+              el = model.__dataHost;
+            } else {
+              return model;
+            }
+          } else {
+            // Still in a template scope, keep going up until
+            // a __templatizeInstance is found
+            el = el.parentNode;
+          }
+        }
+        return null;
+      }
+    }
+
+    Polymer.Templatize = Templatize;
+
+  })();
+
+</script>
diff --git a/lib/polymer2/bower_components/polymer/lib/utils/unresolved.html b/lib/polymer2/bower_components/polymer/lib/utils/unresolved.html
new file mode 100644
index 00000000..6c8752a9
--- /dev/null
+++ b/lib/polymer2/bower_components/polymer/lib/utils/unresolved.html
@@ -0,0 +1,31 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<script>
+(function() {
+  'use strict';
+
+  // unresolved
+
+  function resolve() {
+    document.body.removeAttribute('unresolved');
+  }
+
+  if (window.WebComponents) {
+    window.addEventListener('WebComponentsReady', resolve);
+  } else {
+    if (document.readyState === 'interactive' || document.readyState === 'complete') {
+      resolve();
+    } else {
+      window.addEventListener('DOMContentLoaded', resolve);
+    }
+  }
+
+})();
+</script>
diff --git a/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-ce-es5-index.js b/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-ce-es5-index.js
new file mode 100644
index 00000000..457536a1
--- /dev/null
+++ b/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-ce-es5-index.js
@@ -0,0 +1,23 @@
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+'use strict';
+
+/*
+ * Polyfills loaded: Custom Elements ES5 Shim
+ * Used in: Chrome
+ */
+
+import '../bower_components/custom-elements/src/native-shim.js'
+
+import '../src/unresolved.js'
+
+requestAnimationFrame(() => {
+  window.dispatchEvent(new CustomEvent('WebComponentsReady'));
+});
diff --git a/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-hi-ce-es5-index.js b/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-hi-ce-es5-index.js
new file mode 100644
index 00000000..65d2726c
--- /dev/null
+++ b/lib/polymer2/bower_components/webcomponentsjs/entrypoints/webcomponents-hi-ce-es5-index.js
@@ -0,0 +1,21 @@
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+'use strict';
+
+/*
+ * Polyfills loaded: HTML Imports + Custom Elements ES5 shim
+ * Used in: Safari Tech Preview, Chrome
+ */
+
+import '../bower_components/custom-elements/src/native-shim.js'
+import '../bower_components/html-imports/src/html-imports.js'
+
+import '../src/post-polyfill.js'
+import '../src/unresolved.js'
diff --git a/lib/polymer2/bower_components/webcomponentsjs/webcomponents-ce-es5.js b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-ce-es5.js
new file mode 100644
index 00000000..5c8f4b70
--- /dev/null
+++ b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-ce-es5.js
@@ -0,0 +1,18 @@
+(function () {
+'use strict';
+
+(()=>{'use strict';if(!window.customElements)return;const a=window.HTMLElement,b=window.customElements.define,c=window.customElements.get,d=new Map,e=new Map;let f=!1,g=!1;window.HTMLElement=function(){if(!f){const h=d.get(this.constructor),i=c.call(window.customElements,h);g=!0;const j=new i;return j}f=!1;},window.HTMLElement.prototype=a.prototype,window.customElements.define=(h,i)=>{const j=i.prototype,k=class extends a{constructor(){super(),Object.setPrototypeOf(this,j),g||(f=!0,i.call(this)),g=!1;}},l=k.prototype;k.observedAttributes=i.observedAttributes,l.connectedCallback=j.connectedCallback,l.disconnectedCallback=j.disconnectedCallback,l.attributeChangedCallback=j.attributeChangedCallback,l.adoptedCallback=j.adoptedCallback,d.set(i,h),e.set(h,i),b.call(window.customElements,h,k);},window.customElements.get=(h)=>e.get(h);})();
+
+(function(){'use strict';var a=document.createElement('style');a.textContent='body {transition: opacity ease-in 0.2s; } \\nbody[unresolved] {opacity: 0; display: block; overflow: hidden; position: relative; } \\n';var b=document.querySelector('head');b.insertBefore(a,b.firstChild);})();
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/requestAnimationFrame(()=>{window.dispatchEvent(new CustomEvent('WebComponentsReady'));});
+
+}());
diff --git a/lib/polymer2/bower_components/webcomponentsjs/webcomponents-es5-loader.js b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-es5-loader.js
new file mode 100644
index 00000000..7141ecf5
--- /dev/null
+++ b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-es5-loader.js
@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+(function() {
+  'use strict';
+  var name = 'webcomponents-es5-loader.js';
+  // Feature detect which polyfill needs to be imported.
+  var polyfills = [];
+  if (!('import' in document.createElement('link'))) {
+    polyfills.push('hi');
+  }
+  if (!('attachShadow' in Element.prototype && 'getRootNode' in Element.prototype) ||
+    (window.ShadyDOM && window.ShadyDOM.force)) {
+    polyfills.push('sd');
+  }
+  if (!window.customElements || window.customElements.forcePolyfill) {
+    polyfills.push('ce');
+  } else {
+    polyfills.push('ce-es5');
+  }
+  if (!('content' in document.createElement('template')) || !window.Promise ||
+    // Edge has broken fragment cloning which means you cannot clone template.content
+    !(document.createDocumentFragment().cloneNode() instanceof DocumentFragment)) {
+    polyfills.push('pf');
+  }
+
+  if (polyfills.length === 4) { // hi-ce-sd-pf is actually called lite.
+    polyfills = ['lite'];
+  }
+
+  if (polyfills.length) {
+    var script = document.querySelector('script[src*="' + name + '"]');
+    var newScript = document.createElement('script');
+    // Load it from the right place.
+    var replacement = 'webcomponents-' + polyfills.join('-') + '.js';
+    var url = script.src.replace(name, replacement);
+    newScript.src = url;
+    document.head.appendChild(newScript);
+  } else {
+    // Ensure `WebComponentsReady` is fired also when there are no polyfills loaded.
+    requestAnimationFrame(function() {
+      window.dispatchEvent(new CustomEvent('WebComponentsReady'));
+    });
+  }
+})();
diff --git a/lib/polymer2/bower_components/webcomponentsjs/webcomponents-hi-ce-es5.js b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-hi-ce-es5.js
new file mode 100644
index 00000000..4d15ac10
--- /dev/null
+++ b/lib/polymer2/bower_components/webcomponentsjs/webcomponents-hi-ce-es5.js
@@ -0,0 +1,16 @@
+(function () {
+'use strict';
+
+(()=>{'use strict';if(!window.customElements)return;const a=window.HTMLElement,b=window.customElements.define,c=window.customElements.get,d=new Map,e=new Map;let f=!1,g=!1;window.HTMLElement=function(){if(!f){const h=d.get(this.constructor),i=c.call(window.customElements,h);g=!0;const j=new i;return j}f=!1;},window.HTMLElement.prototype=a.prototype,window.customElements.define=(h,i)=>{const j=i.prototype,k=class extends a{constructor(){super(),Object.setPrototypeOf(this,j),g||(f=!0,i.call(this)),g=!1;}},l=k.prototype;k.observedAttributes=i.observedAttributes,l.connectedCallback=j.connectedCallback,l.disconnectedCallback=j.disconnectedCallback,l.attributeChangedCallback=j.attributeChangedCallback,l.adoptedCallback=j.adoptedCallback,d.set(i,h),e.set(h,i),b.call(window.customElements,h,k);},window.customElements.get=(h)=>e.get(h);})();
+
+((a)=>{const b=!!('import'in document.createElement('link'));let c=null;!1=='currentScript'in document&&Object.defineProperty(document,'currentScript',{get(){return c||('complete'===document.readyState?null:document.scripts[document.scripts.length-1])},configurable:!0});const d=/(^\/)|(^#)|(^[\w-\d]*:)/,f=/(url\()([^)]*)(\))/g,g=/(@import[\s]+(?!url\())([^;]*)(;)/g,h=/(<link[^>]*)(rel=['|"]?stylesheet['|"]?[^>]*>)/g,k={fixUrls(J,K){if(J.href&&J.setAttribute('href',k.replaceAttrUrl(J.getAttribute('href'),K)),J.src&&J.setAttribute('src',k.replaceAttrUrl(J.getAttribute('src'),K)),'style'===J.localName){const L=k.replaceUrls(J.textContent,K,f);J.textContent=k.replaceUrls(L,K,g);}},replaceUrls(J,K,L){return J.replace(L,(M,N,O,P)=>{let Q=O.replace(/["']/g,'');return K&&(Q=k.resolveUrl(Q,K)),N+'\''+Q+'\''+P})},replaceAttrUrl(J,K){return J&&d.test(J)?J:k.resolveUrl(J,K)},resolveUrl(J,K){if(void 0===k.__workingURL){k.__workingURL=!1;try{const M=new URL('b','http://a');M.pathname='c%20d',k.__workingURL='http://a/c%20d'===M.href;}catch(M){}}if(k.__workingURL)return new URL(J,K).href;let L=k.__tempDoc;return L||(L=document.implementation.createHTMLDocument('temp'),k.__tempDoc=L,L.__base=L.createElement('base'),L.head.appendChild(L.__base),L.__anchor=L.createElement('a')),L.__base.href=K,L.__anchor.href=J,L.__anchor.href||J}},o={async:!0,load(J,K,L){if(!J)L('error: href must be specified');else if(J.match(/^data:/)){const M=J.split(','),N=M[0];let O=M[1];O=-1<N.indexOf(';base64')?atob(O):decodeURIComponent(O),K(O);}else{const M=new XMLHttpRequest;M.open('GET',J,o.async),M.onload=()=>{let N=M.getResponseHeader('Location');if(N&&0===N.indexOf('/')){const P=location.origin||location.protocol+'//'+location.host;N=P+N;}const O=M.response||M.responseText;304===M.status||0===M.status||200<=M.status&&300>M.status?K(O,N):L(O);},M.send();}}},p=/Trident/.test(navigator.userAgent)||/Edge\/\d./i.test(navigator.userAgent),q='link[rel=import]',t='import-disable',v=`link[rel=stylesheet][href][type=${t}]`,w=`${q}, ${v},
+    style:not([type]), link[rel=stylesheet][href]:not([type]),
+    script:not([type]), script[type="application/javascript"],
+    script[type="text/javascript"]`,x='import-dependency',y=`${q}:not(${x})`,z=`script[${x}]`,A=`style[${x}],
+    link[rel=stylesheet][${x}]`;const C=(J)=>{return J.nodeType===Node.ELEMENT_NODE&&'link'===J.localName&&'import'===J.rel},D=(J,K)=>{if(J.__loaded)K&&K();else if('script'===J.localName&&!J.src)J.__loaded=!0,K&&K();else{const L=(M)=>{J.removeEventListener(M.type,L),J.__loaded=!0,K&&K();};J.addEventListener('load',L),p&&'style'===J.localName||J.addEventListener('error',L);}},E=(J)=>{F(()=>G(()=>J&&J()));},F=(J)=>{if('loading'!==document.readyState)J();else{const K=()=>{'loading'!==document.readyState&&(document.removeEventListener('readystatechange',K),J());};document.addEventListener('readystatechange',K);}},G=(J)=>{let K=document.querySelectorAll(y),L=K.length;if(!L)return void J();for(let O,M=0,N=K.length;M<N&&(O=K[M]);M++)D(O,()=>{0==--L&&J();});},H=(J)=>{if(b)return J.ownerDocument===document?null:J.ownerDocument;let K=J.__importDoc;if(!K&&J.parentNode){if(K=J.parentNode,'function'==typeof K.closest)K=K.closest(q);else for(;!C(K)&&(K=K.parentNode););J.__importDoc=K;}return K},I=(J,K)=>{if('function'==typeof window.CustomEvent)return new CustomEvent(J,K);const L=document.createEvent('CustomEvent');return L.initCustomEvent(J,!!K.bubbles,!!K.cancelable,K.detail),L};if(b){const J=document.querySelectorAll(q);for(let N,L=0,M=J.length;L<M&&(N=J[L]);L++)N.import&&'loading'===N.import.readyState||(N.__loaded=!0);const K=(L)=>{const M=L.target;C(M)&&(M.__loaded=!0);};document.addEventListener('load',K,!0),document.addEventListener('error',K,!0);}else new class{constructor(){this.documents={},this.inflight=0,this.dynamicImportsMO=new MutationObserver((J)=>this.handleMutations(J)),F(()=>{this.dynamicImportsMO.observe(document.head,{childList:!0,subtree:!0}),this.loadImports(document);});}loadImports(J){const K=J.querySelectorAll(q);for(let L=0,M=K.length;L<M;L++)this.loadImport(K[L]);}loadImport(J){const K=J.href;if(void 0!==this.documents[K]){const L=this.documents[K];return void(L&&L.__loaded&&(J.import=L,this.fireEventIfNeeded(J)))}this.inflight++,this.documents[K]='pending',o.load(K,(L,M)=>{const N=this.makeDocument(L,M||K);this.documents[K]=N,this.inflight--,this.loadImports(N),this.processImportsIfLoadingDone();},()=>{this.documents[K]=null,this.inflight--,this.processImportsIfLoadingDone();});}makeDocument(J,K){if(!J)return document.createDocumentFragment();p&&(J=J.replace(h,(Q,R,S)=>{return-1===Q.indexOf('type=')?`${R} type=${t} ${S}`:Q}));let L;const M=document.createElement('template');if(M.innerHTML=J,M.content)L=M.content;else for(L=document.createDocumentFragment();M.firstChild;)L.appendChild(M.firstChild);const N=L.querySelector('base');N&&(K=k.replaceAttrUrl(N.getAttribute('href'),K),N.removeAttribute('href'));const O=L.querySelectorAll(w);let P=0;for(let S,Q=0,R=O.length;Q<R&&(S=O[Q]);Q++)if(D(S),k.fixUrls(S,K),S.setAttribute(x,''),'script'===S.localName&&!S.src&&S.textContent){const T=P?`-${P}`:'',U=S.textContent+`\n//# sourceURL=${K}${T}.js\n`;S.setAttribute('src','data:text/javascript;charset=utf-8,'+encodeURIComponent(U)),S.textContent='',P++;}return L}processImportsIfLoadingDone(){if(this.inflight)return;this.dynamicImportsMO.disconnect(),this.flatten(document);let J=!1,K=!1;const L=()=>{K&&J&&(this.dynamicImportsMO.observe(document.head,{childList:!0,subtree:!0}),this.fireEvents());};this.waitForStyles(()=>{K=!0,L();}),this.runScripts(()=>{J=!0,L();});}flatten(J){const K=J.querySelectorAll(q);for(let N,L=0,M=K.length;L<M&&(N=K[L]);L++){const O=this.documents[N.href];N.import=O,O&&O.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(this.documents[N.href]=N,N.readyState='loading',N.import=N,Object.defineProperty(N,'baseURI',{get:()=>N.href,configurable:!0,enumerable:!0}),this.flatten(O),N.appendChild(O));}}runScripts(J){const K=document.querySelectorAll(z),L=K.length,M=(N)=>{if(N<L){const O=K[N],P=document.createElement('script');O.removeAttribute(x);for(let Q=0,R=O.attributes.length;Q<R;Q++)P.setAttribute(O.attributes[Q].name,O.attributes[Q].value);c=P,O.parentNode.replaceChild(P,O),D(P,()=>{c=null,M(N+1);});}else J();};M(0);}waitForStyles(J){const K=document.querySelectorAll(A);let L=K.length;if(!L)return void J();const M=p&&!!document.querySelector(v);for(let P,N=0,O=K.length;N<O&&(P=K[N]);N++)if(D(P,()=>{P.removeAttribute(x),0==--L&&J();}),M&&P.parentNode!==document.head){const Q=document.createElement(P.localName);Q.__appliedElement=P,Q.setAttribute('type','import-placeholder'),P.parentNode.insertBefore(Q,P.nextSibling);let R=H(P);for(;R&&H(R);)R=H(R);R.parentNode!==document.head&&(R=null),document.head.insertBefore(P,R),P.removeAttribute('type');}}fireEvents(){const J=document.querySelectorAll(q);for(let L,K=J.length-1;0<=K&&(L=J[K]);K--)this.fireEventIfNeeded(L);}fireEventIfNeeded(J){if(!J.__loaded){J.__loaded=!0,J.import&&(J.import.readyState='complete');const K=J.import?'load':'error';J.dispatchEvent(I(K,{bubbles:!1,cancelable:!1,detail:void 0}));}}handleMutations(J){for(let K=0;K<J.length;K++){const L=J[K];if(L.addedNodes)for(let M=0;M<L.addedNodes.length;M++){const N=L.addedNodes[M];N&&N.nodeType===Node.ELEMENT_NODE&&(C(N)?this.loadImport(N):this.loadImports(N));}}}};E(()=>document.dispatchEvent(I('HTMLImportsLoaded',{cancelable:!0,bubbles:!0,detail:void 0}))),a.useNative=b,a.whenReady=E,a.importForElement=H;})(window.HTMLImports=window.HTMLImports||{});
+
+(function(){'use strict';var a=window.customElements,b=window.HTMLImports;if(a&&a.polyfillWrapFlushCallback){var c,d=function(){if(c){var g=c;return c=null,g(),!0}},e=b.whenReady;a.polyfillWrapFlushCallback(function(f){c=f,e(d);}),b.whenReady=function(f){e(function(){d()?b.whenReady(f):f();});};}b.whenReady(function(){requestAnimationFrame(function(){window.dispatchEvent(new CustomEvent('WebComponentsReady'));});});})();
+
+(function(){'use strict';var a=document.createElement('style');a.textContent='body {transition: opacity ease-in 0.2s; } \\nbody[unresolved] {opacity: 0; display: block; overflow: hidden; position: relative; } \\n';var b=document.querySelector('head');b.insertBefore(a,b.firstChild);})();
+
+}());