diff --git a/_bump.js b/_bump.js
deleted file mode 100644
index 1e33a3f..0000000
--- a/_bump.js
+++ /dev/null
@@ -1,19 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const version = require('./node_modules/@polymer/polymer/package.json').version;
-const current = require('./package.json');
-const updated = Object.assign({}, current, { version: version } );
-
-console.log('Current Polymer version:', version);
-console.log('Current package.json version:', current.version);
-
-fs.writeFile('./package.json', updated, function(err) {
-    if(err) {
-        return console.log(err);
-    } else {
-        return console.log('Succesfully updated package.json version to +', updated.version);
-    }
-}); 
-
-
diff --git a/index.js b/index.js
new file mode 100644
index 0000000..78261f6
--- /dev/null
+++ b/index.js
@@ -0,0 +1,3 @@
+'use strict';
+
+export const Polymer = window.Polymer;
\ No newline at end of file
diff --git a/package.json b/package.json
index 7aecaff..724794a 100644
--- a/package.json
+++ b/package.json
@@ -1,23 +1,11 @@
 {
   "name": "polymer-npm-wrapper",
-<<<<<<< HEAD
-  "version": "v2.0.0-rc4",
-=======
-  "version": "v1.0.1",
->>>>>>> polymer-1
+  "version": "v1.1",
   "description": "Unofficial wrapper for getting latest version of Polymer from Git as NPM dependency and exporting it as ES2015 module.",
-  "main": "polymer-element.js",
+  "main": "index.js",
   "repository": "https://github.com/contactlab/polymer-npm-wrapper.git",
   "author": "Contactlab Product Team <developer@contactlab.com>",
   "license": "Apache-2.0",
-<<<<<<< HEAD
-  "scripts": {
-    "extract": "webpack",
-    "download": "npm install --save https://github.com/Polymer/polymer",
-    "bump": "node ./actions/bump"
-  },
-=======
->>>>>>> polymer-1
   "keywords": [
     "polymer",
     "npm",
@@ -32,15 +20,6 @@
     "modules"
   ],
   "dependencies": {
-<<<<<<< HEAD
-    "@polymer/polymer": "git+https://github.com/Polymer/polymer.git",
-    "@webcomponents/shadycss": "https://github.com/webcomponents/shadycss"
-  },
-  "devDependencies": {
-    "wc-loader": "^1.1.3",
-    "webpack": "^2.4.1"
-=======
     "@polymer/polymer": "https://github.com/Polymer/polymer#7d460dd3fafa461eaef0a4ce647e4e244a87e65e"
->>>>>>> polymer-1
   }
 }
diff --git a/polymer-element.js b/polymer-element.js
deleted file mode 100644
index b4ca500..0000000
--- a/polymer-element.js
+++ /dev/null
@@ -1,5526 +0,0 @@
-/******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// identity function for calling harmony imports with the correct context
-/******/ 	__webpack_require__.i = function(value) { return value; };
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, {
-/******/ 				configurable: false,
-/******/ 				enumerable: true,
-/******/ 				get: getter
-/******/ 			});
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 13);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ (function(module, exports) {
-
-/*__wc__loader*/
-
-(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.
-   * @param {Object} info Prototype for the custom element. It must contain
-   * an `is` property to specify the element name. Other properties populate
-   * the element prototype. The `properties`, `observers`, `hostAttributes`,
-   * and `listeners` properties are processed to create element features.
-   * @return {Object} Returns a custom element class for the given provided
-   * prototype `info` object. The name of the element if given by `info.is`.
-   */
-  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
-  /**
-   * @param {Object} info Prototype for the custom element. It must contain
-   * an `is` property to specify the element name. Other properties populate
-   * the element prototype. The `properties`, `observers`, `hostAttributes`,
-   * and `listeners` properties are processed to create element features.
-   */
-  window.Polymer._polymerFn = function(info) { // eslint-disable-line no-unused-vars
-    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, JSCompiler_renameProperty(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.JSCompiler_renameProperty = function(prop, obj) {
-    return prop;
-  }
-  /* eslint-enable */
-
-})();
-
-
-
-/***/ }),
-/* 1 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-
-
-(function() {
-
-  'use strict';
-
-  // unique global id for deduping mixins.
-  let dedupeId = 0;
-
-  /**
-   * Given a mixin producing function, memoize applications of mixin to base
-   * @private
-   * @param {Function} mixin Mixin for which to create a caching mixin.
-   * @return {Function} Returns a mixin which when applied multiple times to the
-   * same base will always return the same extended class.
-   */
-  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
-    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;
-    }
-  };
-
-})();
-
-
-
-
-/***/ }),
-/* 2 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-
-(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;
-})();
-
-
-
-/***/ }),
-/* 3 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-
-
-  (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
-    };
-
-  })();
-
-
-
-
-/***/ }),
-/* 4 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(6);
-
-
-(function() {
-  'use strict';
-
-  /**
-   * Base class that provides the core API for Polymer's meta-programming
-   * features including template stamping, data-binding, attribute deserialization,
-   * and property change observation.
-   *
-   * @polymerElement
-   * @memberof Polymer
-   * @constructor
-   * @implements {Polymer_ElementMixin}
-   * @extends HTMLElement
-   * @mixes Polymer.ElementMixin
-   * @summary Custom element base class that provides the core API for Polymer's
-   *   key meta-programming features including template stamping, data-binding,
-   *   attribute deserialization, and property change observation
-   */
-  const Element = Polymer.ElementMixin(HTMLElement);
-  Polymer.Element = Element;
-})();
-
-
-
-/***/ }),
-/* 5 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-__webpack_require__(3);
-
-
-(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 element specified by the css `selector` in the module
-     * registered by `id`. For example, this.import('foo', 'img');
-     * @param {string} id The id of the dom-module in which to search.
-     * @param {string=} selector The css selector by which to find the element.
-     * @return {Element} Returns the element which matches `selector` in the
-     * module registered at the specified `id`.
-     */
-    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')`.
-     * @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;
-
-})();
-
-
-
-/***/ }),
-/* 6 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-__webpack_require__(1);
-
-__webpack_require__(2);
-
-__webpack_require__(12);
-
-__webpack_require__(3);
-
-__webpack_require__(5);
-
-__webpack_require__(8);
-
-
-(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(base => {
-
-    /**
-     * @constructor
-     * @extends {base}
-     * @implements {Polymer_PropertyEffects}
-     */
-    const polymerElementBase = Polymer.PropertyEffects(base);
-
-    let caseMap = Polymer.CaseMap;
-
-    const DISABLED = 'disable-upgrade';
-
-    /**
-     * 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 Element class
-     * @return {Object} Object containing own properties for this class
-     * @private
-     */
-    function ownPropertiesForClass(klass) {
-      if (!klass.hasOwnProperty(
-        JSCompiler_renameProperty('__ownProperties', klass))) {
-        klass.__ownProperties =
-          klass.hasOwnProperty(JSCompiler_renameProperty('properties', klass)) ?
-          klass.properties : {};
-      }
-      return klass.__ownProperties;
-    }
-
-    /**
-     * Returns the `observers` array specifically on `klass`. Use for
-     * setting up observers.
-     *
-     * @param {HTMLElement} klass Element class
-     * @return {Array} Array containing own observers for this class
-     * @private
-     */
-    function ownObserversForClass(klass) {
-      if (!klass.hasOwnProperty(
-        JSCompiler_renameProperty('__ownObservers', klass))) {
-        klass.__ownObservers =
-          klass.hasOwnProperty(JSCompiler_renameProperty('observers', klass)) ?
-          klass.observers : [];
-      }
-      return klass.__ownObservers;
-    }
-
-    /**
-     * Mixes `props` into `flattenedProps` but upgrades shorthand type
-     * syntax to { type: Type}.
-     *
-     * @param {Object} flattenedProps Bag to collect flattened properties into
-     * @param {Object} props Bag of properties to add to `flattenedProps`
-     * @return {Objecg} The input `flattenedProps` bag
-     * @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 Element class
-     * @return {PolymerElementProperties} Flattened properties for this class
-     * @private
-     */
-    function propertiesForClass(klass) {
-      if (!klass.hasOwnProperty(
-        JSCompiler_renameProperty('__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 Element class
-     * @return {PolymerElementProperties} Flattened properties for this class
-     *   that have default values
-     * @private
-     */
-    function propertyDefaultsForClass(klass) {
-      if (!klass.hasOwnProperty(
-        JSCompiler_renameProperty('__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 Element class
-     * @return {boolean} True if all metaprogramming for this class has been
-     *   completed
-     * @private
-     */
-    function hasClassFinalized(klass) {
-      return klass.hasOwnProperty(JSCompiler_renameProperty('__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 Element class
-     * @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.
-     *
-     * @param {HTMLElement} klass Element class
-     * @private
-     */
-    function finalizeClass(klass) {
-      klass.__finalized = true;
-      let proto = klass.prototype;
-      if (klass.hasOwnProperty(
-        JSCompiler_renameProperty('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 Element class prototype to add accessors
-     *    and effects to
-     * @param {Object} properties Flattened bag of property descriptors for
-     *    this class
-     * @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 Element class prototype to add accessors
-     *   and effects to
-     * @param {Object} observers Flattened array of observer descriptors for
-     *   this class
-     * @param {Object} dynamicFns Object containing keys for any properties
-     *   that are functions and should trigger the effect when the function
-     *   reference is changed
-     * @private
-     */
-    function finalizeObservers(proto, observers, dynamicFns) {
-      for (let i=0; i < observers.length; i++) {
-        proto._createMethodObserver(observers[i], dynamicFns);
-      }
-    }
-
-    /**
-     * 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 Element class prototype to add accessors
-     *   and effects to
-     * @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 Element class prototype to add accessors
-     *   and effects to
-     * @param {HTMLTemplateElement} template Template to process and bind
-     * @param {string} baseURI URL against which to resolve urls in
-     *   style element cssText
-     * @param {string} is Tag name (or type extension name) for this element
-     * @param {string=} ext For type extensions, the tag name that was extended
-     * @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);
-    }
-
-    function flushPropertiesStub() {}
-
-    /**
-     * @polymerMixinClass
-     * @unrestricted
-     * @implements {Polymer_ElementMixin}
-     */
-    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(JSCompiler_renameProperty('__observedAttributes', this))) {
-          let list = [DISABLED];
-          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 that will be stamped into this element's shadow root.
-       *
-       * If a `static get is()` getter is defined, the default implementation
-       * will return the first `<template>` in a `dom-module` whose `id`
-       * matches this element's `is`.
-       *
-       * 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;
-       *     }
-       *   }
-       *
-       * @return {HTMLTemplateElement|string} Template to be stamped
-       */
-      static get template() {
-        if (!this.hasOwnProperty(JSCompiler_renameProperty('_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 `/`.
-       *
-       * @return {string} The import path for this element class
-       */
-      static get importPath() {
-        if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {
-            const module = Polymer.DomModule.import(this.is);
-            this._importPath = module ? module.assetpath : '' ||
-            Object.getPrototypeOf(this.prototype).constructor.importPath;
-        }
-        return this._importPath;
-      }
-
-      /**
-       * 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() {
-        Polymer.telemetry.instanceCount++;
-        hostStack.registerHost(this);
-        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];
-          // Don't set default value if there is already an own property, which
-          // happens when a `properties` property with default but no effects had
-          // a property set (e.g. bound) by its host before upgrade
-          if (!this.hasOwnProperty(p)) {
-            let value = typeof info.value == 'function' ?
-              info.value.call(this) :
-              info.value;
-            // Set via `_setProperty` if there is an accessor, to enable
-            // initializing readOnly property defaults
-            if (this._hasAccessor(p)) {
-              this._setPendingProperty(p, value, true);
-            } 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 && this._template) {
-          window.ShadyCSS.styleElement(this);
-        }
-        if (!this.__dataInitialized) {
-          this._flushProperties();
-        }
-      }
-
-      /**
-       * Provides a default implementation of the standard Custom Elements
-       * `disconnectedCallback`.
-       *
-       * @override
-       */
-      disconnectedCallback() {}
-
-      /**
-       * Stamps the element template.
-       *
-       * @override
-       */
-      ready() {
-        if (this._template) {
-          hostStack.beginHosting(this);
-          this.root = this._stampTemplate(this._template);
-          hostStack.endHosting(this);
-          this.$ = this.root.$;
-        }
-        super.ready();
-      }
-
-      /**
-       * Implements `PropertyEffects`'s `_readyClients` call. Attaches
-       * element dom by calling `_attachDom` with the dom stamped from the
-       * element's template via `_stampTemplate`. Note that this allows
-       * client dom to be attached to the element prior to any observers
-       * running.
-       *
-       * @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.
-       *
-       * @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) {
-        // process `disable-upgrade` specially:
-        // First we see `disable-upgrade` added and disable `_flushProperties`,
-        // then when it's removed, restore regular flushing and flush.
-        // This should only be allowed before "readying".
-        if (name === DISABLED && !this.__dataInitialized) {
-          if (value !== null) {
-            this.__flushProperties = this._flushProperties;
-            this._flushProperties = flushPropertiesStub;
-          } else {
-            this._flushProperties = this.__flushProperties;
-            this._flushProperties();
-          }
-        } else 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);
-      }
-
-      /**
-       * Overrides `PropertyAccessors` to add map of dynamic functions on
-       * template info, for consumption by `PropertyEffects` template binding
-       * code. This map determines which method templates should have accessors
-       * created for them.
-       *
-       * @override
-       */
-      static _parseTemplateContent(template, templateInfo, nodeInfo) {
-        templateInfo.dynamicFns = templateInfo.dynamicFns || propertiesForClass(this);
-        return super._parseTemplateContent(template, templateInfo, nodeInfo);
-      }
-
-    }
-
-    return PolymerElement;
-  });
-
-  /**
-   * Helper api for enqueing client dom created by a host element.
-   *
-   * By default elements are flushed via `_flushProperties` when
-   * `connectedCallback` is called. Elements attach their client dom to
-   * themselves at `ready` time which results from this first flush.
-   * This provides an ordering guarantee that the client dom an element
-   * creates is flushed before the element itself (i.e. client `ready`
-   * fires before host `ready`).
-   *
-   * However, if `_flushProperties` is called *before* an element is connected,
-   * as for example `Templatize` does, this ordering guarantee cannot be
-   * satisfied because no elements are connected. (Note: Bound elements that
-   * receive data do become enqueued clients and are properly ordered but
-   * unbound elements are not.)
-   *
-   * To maintain the desired "client before host" ordering guarantee for this
-   * case we rely on the "host stack. Client nodes registers themselves with
-   * the creating host element when created. This ensures that all client dom
-   * is readied in the proper order, maintaining the desired guarantee.
-   *
-   * @private
-   */
-  let hostStack = {
-
-    stack: [],
-
-    registerHost(inst) {
-      if (this.stack.length) {
-        let host = this.stack[this.stack.length-1];
-        host._enqueueClient(inst);
-      }
-    },
-
-    beginHosting(inst) {
-      this.stack.push(inst);
-    },
-
-    endHosting(inst) {
-      let stackLen = this.stack.length;
-      if (stackLen && this.stack[stackLen-1] == inst) {
-        this.stack.pop();
-      }
-    }
-
-  }
-
-  /**
-   * Provides basic tracking of element definitions (registrations) and
-   * instance counts.
-   *
-   * @namespace
-   * @summary Provides basic tracking of element definitions (registrations) and
-   * instance counts.
-   */
-  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: [],
-    /**
-     * @param {HTMLElement} prototype Element prototype to log
-     * @private
-     */
-    _regLog: function(prototype) {
-      console.log('[' + prototype.is + ']: registered')
-    },
-    /**
-     * Registers a class prototype for telemetry purposes.
-     * @param {HTMLElement} prototype Element prototype to register
-     * @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=} props 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);
-
-})();
-
-
-
-/***/ }),
-/* 7 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-__webpack_require__(1);
-
-__webpack_require__(2);
-
-__webpack_require__(10);
-
-
-(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(JSCompiler_renameProperty('__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.  Last, call `this._flushProperties()` once to enable
-   * the accessors.
-   *
-   * 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(superClass => {
-
-    /**
-     * @polymerMixinClass
-     * @implements {Polymer_PropertyAccessors}
-     * @unrestricted
-     */
-    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.__dataInitialized = false;
-        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);
-          this.__dataProto = null;
-        }
-        // 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.__dataHasAccessor) {
-          if (this.hasOwnProperty(p)) {
-            this.__dataInstanceProps = this.__dataInstanceProps || {};
-            this.__dataInstanceProps[p] = this[p];
-            delete this[p];
-          }
-        }
-      }
-
-      /**
-       * 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]);
-        }
-      }
-
-      /**
-       * Called at ready time with bag of instance properties that overwrote
-       * accessors when the element upgraded.
-       *
-       * The default implementation sets these properties back into the
-       * setter at ready time.  This method is provided as an override
-       * point for customizing or providing more efficient initialization.
-       *
-       * @param {Object} props Bag of property values that were overwritten
-       *   when creating property accessors.
-       * @protected
-       */
-      _initializeInstanceProperties(props) {
-        Object.assign(this, props);
-      }
-
-      /**
-       * Ensures the element has the given attribute. If it does not,
-       * assigns the given value to the attribute.
-       *
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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`).
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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: ${value}`);
-            }
-            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) {
-        if (!this.hasOwnProperty('__dataHasAccessor')) {
-          this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
-        }
-        if (!this.__dataHasAccessor[property]) {
-          this.__dataHasAccessor[property] = true;
-          saveAccessorValue(this, property);
-          Object.defineProperty(this, property, {
-            get: function() {
-              return this.__data[property];
-            },
-            set: readOnly ? function() { } : function(value) {
-              this._setProperty(property, value);
-            }
-          });
-        }
-      }
-
-      /**
-       * Returns true if this library created an accessor for the given property.
-       *
-       * @param {string} property Property name
-       * @return {boolean} True if an accessor was created
-       */
-      _hasAccessor(property) {
-        return this.__dataHasAccessor && this.__dataHasAccessor[property];
-      }
-
-      /**
-       * 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
-       * @return {boolean} Returns true if the property changed
-       * @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.__dataInitialized) {
-          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.
-       *
-       * Note that this method must be called once to enable the property
-       * accessors system.  For elements, generally `connectedCallback`
-       * is a normal spot to do so.
-       *
-       * @protected
-       */
-      _flushProperties() {
-        if (!this.__dataInitialized) {
-          this.ready()
-        } else if (this.__dataPending) {
-          let changedProps = this.__dataPending;
-          this.__dataPending = null;
-          this.__dataCounter++;
-          this._propertiesChanged(this.__data, changedProps, this.__dataOld);
-          this.__dataCounter--;
-        }
-      }
-
-      /**
-       * 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 values propagated from host e.g. via
-       * bindings.  `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 constructor or attributeChangedCallback
-        if (this.__dataInstanceProps) {
-          this._initializeInstanceProperties(this.__dataInstanceProps);
-          this.__dataInstanceProps = null;
-        }
-        this.__dataInitialized = true;
-        // Run normal flush
-        this._flushProperties();
-      }
-
-      /**
-       * 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))
-        );
-      }
-
-    }
-
-    return PropertyAccessors;
-
-  });
-
-})();
-
-
-
-/***/ }),
-/* 8 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-__webpack_require__(1);
-
-__webpack_require__(11);
-
-__webpack_require__(2);
-
-__webpack_require__(7);
-
-__webpack_require__(9);
-
-
-(function() {
-
-  'use strict';
-
-  /** @const {Object} */
-  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 = {
-    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 {Object} effects Object map of property-to-Array of effects
-   * @param {Object} props Bag of current property changes
-   * @param {Object=} oldProps Bag of previous values for changed properties
-   * @param {boolean=} hasPaths True with `props` contains one or more paths
-   * @param {*=} extraArgs Additional metadata to pass to effect function
-   * @return {boolean} True if an effect ran for this property
-   * @private
-   */
-  function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {
-    if (effects) {
-      let ran = false;
-      let id = dedupeId++;
-      for (let prop in props) {
-        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths, extraArgs)) {
-          ran = true;
-        }
-      }
-      return ran;
-    }
-    return false;
-  }
-
-  /**
-   * Runs a list of effects for a given property.
-   *
-   * @param {Object} inst The instance with effects to run
-   * @param {Object} effects Object map of property-to-Array of effects
-   * @param {number} dedupeId Counter used for de-duping effects
-   * @param {string} prop Name of changed property
-   * @param {*} props Changed properties
-   * @param {*} oldProps Old properties
-   * @param {boolean=} hasPaths True with `props` contains one or more paths
-   * @param {*=} extraArgs Additional metadata to pass to effect function
-   * @return {boolean} True if an effect ran for this property
-   * @private
-   */
-  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {
-    let ran = false;
-    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))) {
-          if (fx.info) {
-            fx.info.lastRun = dedupeId;
-          }
-          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
-          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 {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @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} notifyProps Bag of properties to notify
-   * @param {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @param {boolean} hasPaths True with `props` contains one or more paths
-   * @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 {Object} props Bag of current property changes
-   * @return {boolean} Returns true if the path was notified
-   * @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 {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @param {Object} info Effect metadata
-   * @param {boolean} hasPaths True with `props` contains one or more paths
-   * @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);
-  }
-
-  /**
-   * 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} event Notification event (e.g. '<property>-changed')
-   * @param {Object} inst Host element instance handling the notification event
-   * @param {string} fromProp Child element property that was bound
-   * @param {string} toPath Host property/path that was bound
-   * @param {boolean} negate Whether the binding was negated
-   * @private
-   */
-  function handleNotification(event, inst, fromProp, toPath, negate) {
-    let value;
-    let detail = event.detail;
-    let fromPath = detail && detail.path;
-    if (fromPath) {
-      toPath = Polymer.Path.translate(fromProp, toPath, fromPath);
-      value = detail && detail.value;
-    } else {
-      value = event.target[fromProp];
-    }
-    value = negate ? !value : value;
-    if (!inst.__readOnly || !inst.__readOnly[toPath]) {
-      if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath))
-        && (!detail || !detail.queueProperty)) {
-        inst._invalidateProperties();
-      }
-    }
-  }
-
-  /**
-   * 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 {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @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
-   * @param {boolean} hasPaths True with `props` contains one or more paths
-   * @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 {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @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.__dataHasAccessor && inst.__dataHasAccessor[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 {string} path Path that has changed
-   * @param {*} value Value of changed path
-   * @private
-   */
-  function computeLinkedPaths(inst, path, value) {
-    let links = inst.__dataLinkedPaths;
-    if (links) {
-      let link;
-      for (let a in links) {
-        let b = links[a];
-        if (Polymer.Path.isDescendant(a, path)) {
-          link = Polymer.Path.translate(a, b, path);
-          inst._setPendingPropertyOrPath(link, value, true, true);
-        } else if (Polymer.Path.isDescendant(b, path)) {
-          link = Polymer.Path.translate(b, a, path);
-          inst._setPendingPropertyOrPath(link, value, true, true);
-        }
-      }
-    }
-  }
-
-  // -- bindings ----------------------------------------------
-
-  /**
-   * Adds binding metadata to the current `nodeInfo`, and binding effects
-   * for all part dependencies to `templateInfo`.
-   *
-   * @param {Function} constructor Class that `_parseTemplate` is currently
-   *   running on
-   * @param {Object} templateInfo Template metadata for current template
-   * @param {Object} nodeInfo Node metadata for current template node
-   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'
-   * @param {string} target Target property name
-   * @param {Array<Object>} parts Array of binding part metadata
-   * @param {string} literal Literal text surrounding binding parts (specified
-   *   only for 'property' bindings, since these must be initialized as part
-   *   of boot-up)
-   * @private
-   */
-  function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
-    // Create binding metadata and add to nodeInfo
-    nodeInfo.bindings = nodeInfo.bindings || [];
-    let binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };
-    nodeInfo.bindings.push(binding);
-    // Add listener info to binding metadata
-    if (shouldAddListener(binding)) {
-      let {event, negate} = binding.parts[0];
-      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');
-      binding.listenerNegate = negate;
-    }
-    // Add "propagate" property effects to templateInfo
-    let index = templateInfo.nodeInfoList.length;
-    for (let i=0; i<binding.parts.length; i++) {
-      let part = binding.parts[i];
-      part.compoundIndex = i;
-      addEffectForBindingPart(constructor, templateInfo, binding, part, index);
-    }
-  }
-
-  /**
-   * Adds property effects to the given `templateInfo` for the given binding
-   * part.
-   *
-   * @param {Function} constructor Class that `_parseTemplate` is currently
-   *   running on
-   * @param {Object} templateInfo Template metadata for current template
-   * @param {Object} binding Binding metadata
-   * @param {Object} part Binding part metadata
-   * @param {number} index Index into `nodeInfoList` for this node
-   */
-  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
-    if (!part.literal) {
-      if (binding.kind === 'attribute' && binding.target[0] === '-') {
-        console.warn('Cannot set attribute ' + binding.target +
-          ' because "-" is not a valid attribute starting character');
-      } else {
-        let dependencies = part.dependencies;
-        let info = { index, binding, part, evaluator: constructor };
-        for (let j=0; j<dependencies.length; j++) {
-          let trigger = dependencies[j];
-          if (typeof trigger == 'string') {
-            trigger = parseArg(trigger);
-            trigger.wildcard = true;
-          }
-          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
-            fn: runBindingEffect,
-            info, trigger
-          });
-        }
-      }
-    }
-  }
-
-  /**
-   * Implements the "binding" (property/path binding) effect.
-   *
-   * Note that binding syntax is overridable via `_parseBindings` and
-   * `_evaluateBindings`.  This method will call `_evaluateBinding` for any
-   * non-literal parts returned from `_parseBindings`.  However,
-   * there is no support for _path_ bindings via custom binding parts,
-   * as this is specific to Polymer's path binding syntax.
-   *
-   * @param {Element} inst The instance the effect will be run on
-   * @param {string} path Name of property
-   * @param {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @param {Object} info Effect metadata
-   * @param {boolean} hasPaths True with `props` contains one or more paths
-   * @param {Array} nodeList List of nodes associated with `nodeInfoList` template
-   *   metadata
-   * @private
-   */
-  function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {
-    let node = nodeList[info.index];
-    let binding = info.binding;
-    let part = info.part;
-    // 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 && part.source && (path.length > part.source.length) &&
-        (binding.kind == 'property') && !binding.isCompound &&
-        node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {
-      let value = props[path];
-      path = Polymer.Path.translate(part.source, binding.target, path);
-      if (node._setPendingPropertyOrPath(path, value, false, true)) {
-        inst._enqueueClient(node);
-      }
-    } else {
-      let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);
-      // Propagate value to child
-      applyBindingValue(inst, node, binding, part, 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 {Node} node Target node for binding
-   * @param {Object} binding Binding metadata
-   * @param {Object} part Binding part metadata
-   * @param {*} value Value to set
-   * @private
-   */
-  function applyBindingValue(inst, node, binding, part, value) {
-    value = computeBindingValue(node, value, binding, part);
-    if (Polymer.sanitizeDOMValue) {
-      value = Polymer.sanitizeDOMValue(value, binding.target, binding.kind, node);
-    }
-    if (binding.kind == 'attribute') {
-      // Attribute binding
-      inst._valueToNodeAttribute(node, value, binding.target);
-    } else {
-      // Property binding
-      let prop = binding.target;
-      if (node.__dataHasAccessor && node.__dataHasAccessor[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} binding Binding metadata
-   * @param {Object} part Binding part metadata
-   * @return {*} Transformed value to set
-   * @private
-   */
-  function computeBindingValue(node, value, binding, part) {
-    if (binding.isCompound) {
-      let storage = node.__dataCompoundStorage[binding.target];
-      storage[part.compoundIndex] = value;
-      value = storage.join('');
-    }
-    if (binding.kind !== 'attribute') {
-      // Some browsers serialize `undefined` to `"undefined"`
-      if (binding.target === 'textContent' ||
-          (node.localName == 'input' && binding.target == 'value')) {
-        value = value == undefined ? '' : value;
-      }
-    }
-    return value;
-  }
-
-  /**
-   * 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.target &&
-           binding.kind != 'attribute' &&
-           binding.kind != 'text' &&
-           !binding.isCompound &&
-           binding.parts[0].mode === '{';
-  }
-
-  /**
-   * Setup compound binding storage structures, notify listeners, and dataHost
-   * references onto the bound nodeList.
-   *
-   * @param {Object} inst Instance that bas been previously bound
-   * @param {Object} templateInfo Template metadata
-   * @private
-   */
-  function setupBindings(inst, templateInfo) {
-    // Setup compound storage, dataHost, and notify listeners
-    let {nodeList, nodeInfoList} = templateInfo;
-    if (nodeInfoList.length) {
-      for (let i=0; i < nodeInfoList.length; i++) {
-        let info = nodeInfoList[i];
-        let node = nodeList[i];
-        let bindings = info.bindings;
-        if (bindings) {
-          for (let i=0; i<bindings.length; i++) {
-            let binding = bindings[i];
-            setupCompoundStorage(node, binding);
-            addNotifyListener(node, inst, binding);
-          }
-        }
-        node.__dataHost = inst;
-      }
-    }
-  }
-
-  /**
-   * 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 {Node} node Bound node to initialize
-   * @param {Object} binding Binding metadata
-   * @private
-   */
-  function setupCompoundStorage(node, binding) {
-    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 target = binding.target;
-      storage[target] = literals;
-      // Configure properties with their literal parts
-      if (binding.literal && binding.kind == 'property') {
-        node[target] = binding.literal;
-      }
-    }
-  }
-
-  /**
-   * 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} binding Binding metadata
-   * @private
-   */
-  function addNotifyListener(node, inst, binding) {
-    if (binding.listenerEvent) {
-      let part = binding.parts[0];
-      node.addEventListener(binding.listenerEvent, function(e) {
-        handleNotification(e, inst, binding.target, part.source, part.negate);
-      });
-    }
-  }
-
-  // -- 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 Type of property effect to add
-   * @param {Function} effectFn Function to run when arguments change
-   * @param {*=} methodInfo Effect-specific information to be included in
-   *   method effect metadata
-   * @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 {Object} props Bag of current property changes
-   * @param {Object} oldProps Bag of previous values for changed properties
-   * @param {Object} info Effect metadata
-   * @return {*} Returns the return value from the method invocation
-   * @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 = [];
-
-  // Regular expressions used for binding
-  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
-  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
-  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
-  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
-  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
-  const ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
-  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
-  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
-                                '(?:' + ARGUMENTS + '?' + ')' +
-                              '\\)\\s*' + ')';
-  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
-  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
-  const CLOSE_BRACKET = '(?:]]|}})';
-  const NEGATE = '(?:(!)\\s*)?'; // Group 2
-  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
-  const bindingRegex = new RegExp(EXPRESSION, "g");
-
-  function literalFromParts(parts) {
-    let s = '';
-    for (let i=0; i<parts.length; i++) {
-      let literal = parts[i].literal;
-      s += literal || '';
-    }
-    return s;
-  }
-
-  /**
-   * 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 methodName = m[1];
-      let sig = { methodName, 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.isPath(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
-   * @param {string} path Property/path name that triggered the method effect
-   * @param {Object} props Bag of current property changes
-   * @return {Array<*>} Array of argument values
-   * @private
-   */
-  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;
-  }
-
-  // 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);
-  }
-
-  /**
-   * 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.
-   *
-   * Note that this mixin overrides several `PropertyAccessors` methods, in
-   * many cases to maintain guarantees provided by the Polymer 1.x features;
-   * notably it changes property accessors to be synchronous by default
-   * whereas the default when using `PropertyAccessors` standalone is to be
-   * async by default.
-   *
-   * @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(superClass => {
-
-    /**
-     * @constructor
-     * @extends {superClass}
-     * @implements {Polymer_PropertyAccessors}
-     * @implements {Polymer_TemplateStamp}
-     */
-    const propertyEffectsBase = Polymer.TemplateStamp(Polymer.PropertyAccessors(superClass));
-
-    /**
-     * @polymerMixinClass
-     * @unrestricted
-     * @implements {Polymer_PropertyEffects}
-     */
-    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.__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 = {};
-      }
-
-      /**
-       * 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 = {};
-      }
-
-      /**
-       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
-       * `_setProperty`'s `shouldNotify: true`.
-       *
-       * @override
-       */
-      _initializeInstanceProperties(props) {
-        let readOnly = this.__readOnly;
-        for (let prop in props) {
-          if (!readOnly || !readOnly[prop]) {
-            this.__dataPending = this.__dataPending || {};
-            this.__dataOld = this.__dataOld || {};
-            this.__data[prop] = this.__dataPending[prop] = props[prop];
-          }
-        }
-      }
-
-      // Prototype setup ----------------------------------------
-
-      /**
-       * Ensures an accessor exists for the specified property, and adds
-       * to a list of "property effects" that will run when the accessor for
-       * the specified property is set.  Effects are grouped by "type", which
-       * roughly corresponds to a phase in effect processing.  The effect
-       * metadata should be in the following form:
-       *
-       *   {
-       *     fn: effectFunction, // Reference to function to call to perform effect
-       *     info: { ... }       // Effect metadata passed to function
-       *     trigger: {          // Optional triggering metadata; if not provided
-       *       name: string      // the property is treated as a wildcard
-       *       structured: boolean
-       *       wildcard: boolean
-       *     }
-       *   }
-       *
-       * Effects are called from `_propertiesChanged` in the following order by
-       * type:
-       *
-       * 1. COMPUTE
-       * 2. PROPAGATE
-       * 3. REFLECT
-       * 4. OBSERVE
-       * 5. NOTIFY
-       *
-       * Effect functions are called with the following signature:
-       *
-       *   effectFunction(inst, path, props, oldProps, info, hasPaths)
-       *
-       * 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} property Property 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) {
-        this._createPropertyAccessor(property, type == TYPES.READ_ONLY);
-        // effects are accumulated into arrays per property based on type
-        let effects = ensureOwnEffectMap(this, type)[property];
-        if (!effects) {
-          effects = this[type][property] = [];
-        }
-        effects.push(effect);
-      }
-
-      /**
-       * Removes the given property effect.
-       *
-       * @param {string} property Property the effect was associated with
-       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
-       * @param {Object=} effect Effect metadata object to remove
-       */
-      _removePropertyEffect(property, type, effect) {
-        let effects = ensureOwnEffectMap(this, type)[property];
-        let idx = effects.indexOf(effect);
-        if (idx >= 0) {
-          effects.splice(idx, 1);
-        }
-      }
-
-      /**
-       * Returns whether the current prototype/instance has a property effect
-       * of a certain type.
-       *
-       * @param {string} property Property name
-       * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
-       * @return {boolean} True if the prototype/instance has an effect of this type
-       * @protected
-       */
-      _hasPropertyEffect(property, type) {
-        let effects = this[type];
-        return Boolean(effects && effects[property]);
-      }
-
-      /**
-       * Returns whether the current prototype/instance has a "read only"
-       * accessor for the given property.
-       *
-       * @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=} shouldNotify Set to true if this change should
-       *  cause a property notification event dispatch
-       * @param {boolean=} isPathNotification If the path being set is a path
-       *   notification of an already changed value, as opposed to a request
-       *   to set and notify the change.  In the latter `false` case, a dirty
-       *   check is performed and then the value is set to the path before
-       *   enqueuing the pending property change.
-       * @return {boolean} Returns true if the property/path was enqueued in
-       *   the pending changes bag.
-       * @protected
-       */
-      _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
-        if (isPathNotification ||
-            Polymer.Path.root(Array.isArray(path) ? path[0] : path) !== path) {
-          // 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
-          if (!isPathNotification) {
-            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;
-          if (this._setPendingProperty(path, value, shouldNotify)) {
-            computeLinkedPaths(this, path, value);
-            return true;
-          }
-        } else {
-          if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {
-            return this._setPendingProperty(path, value, shouldNotify);
-          } else {
-            this[path] = value;
-          }
-        }
-        return false;
-      }
-
-      /**
-       * Applies a value to a non-Polymer element/node's property.
-       *
-       * The implementation makes a best-effort at binding interop:
-       * Some native element properties have side-effects when
-       * re-setting the same value (e.g. setting <input>.value resets the
-       * cursor position), so we do a dirty-check before setting the value.
-       * However, for better interop with non-Polymer custom elements that
-       * accept objects, we explicitly re-set object changes coming from the
-       * Polymer world (which may include deep object changes without the
-       * top reference changing), erring on the side of providing more
-       * information.
-       *
-       * Users may override this method to provide alternate approaches.
-       *
-       * @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.
-       * @param {boolean=} setReadOnly When true, any private values set in
-       *   `props` will be set. By default, `setProperties` will not set
-       *   `readOnly: true` root properties.
-       * @public
-       */
-      setProperties(props, setReadOnly) {
-        for (let path in props) {
-          if (setReadOnly || !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 `PropertyAccessors` to call `_readyClients` callback
-       * if it was not called as a result of flushing properties.
-       *
-       * @override
-       */
-      ready() {
-        super.ready();
-        if (!this.__dataClientsInitialized) {
-          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;
-      }
-
-      /**
-       * 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);
-        // 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
-        this._propagatePropertyChanges(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);
-        }
-        // Clear temporary cache at end of turn
-        if (this.__dataCounter == 1) {
-          this.__dataTemp = {};
-        }
-        // ----------------------------
-        // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);
-        // ----------------------------
-      }
-
-      /**
-       * Called to propagate any property changes to stamped template nodes
-       * managed by this element.
-       *
-       * @param {Object} changedProps Bag of changed properties
-       * @param {Object} oldProps Bag of previous values for changed properties
-       * @param {boolean} hasPaths True with `props` contains one or more paths
-       * @protected
-       */
-      _propagatePropertyChanges(changedProps, oldProps, hasPaths) {
-        if (this.__propagateEffects) {
-          runEffects(this, this.__propagateEffects, changedProps, oldProps, hasPaths);
-        }
-        let templateInfo = this.__templateInfo;
-        while (templateInfo) {
-          runEffects(this, templateInfo.propertyEffects, changedProps, oldProps,
-            hasPaths, templateInfo.nodeList);
-          templateInfo = templateInfo.nextTemplateInfo;
-        }
-      }
-
-      /**
-       * Aliases one data path as another, such that path notifications from one
-       * are routed to the other.
-       *
-       * @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.
-       *
-       * @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).
-       *
-       * @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).
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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.
-       *
-       * @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 ----------------------------------------------
-
-      /**
-       * Parses the provided template to ensure binding effects are created
-       * for them, and then ensures property accessors are created for any
-       * dependent properties in the template.  Binding effects for bound
-       * templates are stored in a linked list on the instance so that
-       * templates can be efficiently stamped and unstamped.
-       *
-       * This method may be called on the prototype (for prototypical template
-       * binding, to avoid creating accessors every instance) once per prototype,
-       * and will be called with `runtimeBinding: true` by `_stampTemplate` to
-       * create and link an instance of the template metadata associated with a
-       * particular stamping.
-       *
-       * @param {HTMLTemplateElement} template Template containing binding
-       *   bindings
-       * @param {boolean=} instanceBinding When false (default), performs
-       *   "prototypical" binding of the template and overwrites any previously
-       *   bound template for the class. When true (as passed from
-       *   `_stampTemplate`), the template info is instanced and linked into
-       *   the list of bound templates.
-       * @return {Object} Template metadata object; for `runtimeBinding`,
-       *   this is an instance of the prototypical template info
-       * @protected
-       */
-      _bindTemplate(template, instanceBinding) {
-        let templateInfo = this.constructor._parseTemplate(template);
-        let wasPreBound = this.__templateInfo == templateInfo;
-        // Optimization: since this is called twice for proto-bound templates,
-        // don't attempt to recreate accessors if this template was pre-bound
-        if (!wasPreBound) {
-          for (let prop in templateInfo.propertyEffects) {
-            this._createPropertyAccessor(prop);
-          }
-        }
-        if (instanceBinding) {
-          // For instance-time binding, create instance of template metadata
-          // and link into list of templates if necessary
-          templateInfo = Object.create(templateInfo);
-          templateInfo.wasPreBound = wasPreBound;
-          if (!wasPreBound && this.__templateInfo) {
-            templateInfo.nextTemplateInfo = this.__templateInfo;
-            this.__templateInfo.previousTemplateInfo = templateInfo;
-          }
-        }
-        return this.__templateInfo = templateInfo;
-      }
-
-      /**
-       * Adds a property effect to the given template metadata, which is run
-       * at the "propagate" stage of `_propertiesChanged` when the template
-       * has been bound to the element via `_bindTemplate`.
-       *
-       * The `effect` object should match the format in `_addPropertyEffect`.
-       *
-       * @param {Object} templateInfo Template metadata to add effect to
-       * @param {string} prop Property that should trigger the effect
-       * @param {Object=} effect Effect metadata object
-       * @protected
-       */
-      static _addTemplatePropertyEffect(templateInfo, prop, effect) {
-        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
-        hostProps[prop] = true;
-        let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};
-        let propEffects = effects[prop] = effects[prop] || [];
-        propEffects.push(effect);
-      }
-
-      /**
-       * Stamps the provided template and performs instance-time setup for
-       * Polymer template features, including data bindings, declarative event
-       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
-       * is returned containing the stamped DOM, ready for insertion into the
-       * DOM.
-       *
-       * This method may be called more than once; however note that due to
-       * `shadycss` polyfill limitations, only styles from templates prepared
-       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
-       * to the shadow root and support CSS custom properties), and note that
-       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
-       * any styles required by in runtime-stamped templates must be included
-       * in the main element template.
-       *
-       * @param {HTMLTemplateElement} template Template to stamp
-       * @return {DocumentFragment} Cloned template content
-       * @protected
-       */
-      _stampTemplate(template) {
-        let dom = super._stampTemplate(template);
-        let templateInfo = this._bindTemplate(template, true);
-        // Add template-instance-specific data to instanced templateInfo
-        templateInfo.nodeList = dom.nodeList;
-        // Capture child nodes to allow unstamping of non-prototypical templates
-        if (!templateInfo.wasPreBound) {
-          let nodes = templateInfo.childNodes = [];
-          for (let n=dom.firstChild; n; n=n.nextSibling) {
-            nodes.push(n);
-          }
-        }
-        dom.templateInfo = templateInfo;
-        // Setup compound storage, 2-way listeners, and dataHost for bindings
-        setupBindings(this, templateInfo);
-        // Flush properties into template nodes if already booted
-        if (this.__dataInitialized) {
-          runEffects(this, templateInfo.propertyEffects, this.__data, null,
-            false, templateInfo.nodeList);
-        }
-        return dom;
-      }
-
-      /**
-       * Removes and unbinds the nodes previously contained in the provided
-       * DocumentFragment returned from `_stampTemplate`.
-       *
-       * @param {DocumentFragment} dom DocumentFragment previously returned
-       *   from `_stampTemplate` associated with the nodes to be removed
-       * @protected
-       */
-      _removeBoundDom(dom) {
-        // Unlink template info
-        let templateInfo = dom.templateInfo;
-        if (templateInfo.previousTemplateInfo) {
-          templateInfo.previousTemplateInfo.nextTemplateInfo =
-            templateInfo.nextTemplateInfo;
-        }
-        if (templateInfo.nextTemplateInfo) {
-          templateInfo.nextTemplateInfo.previousTemplateInfo =
-            templateInfo.previousTemplateInfo;
-        }
-        // Remove stamped nodes
-        let nodes = templateInfo.childNodes;
-        for (let i=0; i<nodes.length; i++) {
-          let node = nodes[i];
-          node.parentNode.removeChild(node);
-        }
-      }
-
-      /**
-       * Overrides default `TemplateStamp` implementation to add support for
-       * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`
-       * array is added to `nodeInfo` and populated with binding metadata
-       * with information capturing the binding target, and a `parts` array
-       * with one or more metadata objects capturing the source(s) of the
-       * binding.
-       *
-       * @override
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template node
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       * @protected
-       */
-      static _parseTemplateNode(node, templateInfo, nodeInfo) {
-        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
-        if (node.nodeType === Node.TEXT_NODE) {
-          let parts = this._parseBindings(node.textContent, templateInfo);
-          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) || ' ';
-            addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);
-            noted = true;
-          }
-        }
-        return noted;
-      }
-
-      /**
-       * Overrides default `TemplateStamp` implementation to add support for
-       * parsing bindings from attributes.  A `bindings`
-       * array is added to `nodeInfo` and populated with binding metadata
-       * with information capturing the binding target, and a `parts` array
-       * with one or more metadata objects capturing the source(s) of the
-       * binding.
-       *
-       * @override
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template node
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       * @protected
-       */
-      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
-        let parts = this._parseBindings(value, templateInfo);
-        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.
-          if (kind === 'property') {
-            name = Polymer.CaseMap.dashToCamelCase(name);
-          }
-          addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
-          return true;
-        } else {
-          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
-        }
-      }
-
-      /**
-       * Overrides default `TemplateStamp` implementation to add support for
-       * binding the properties that a nested template depends on to the template
-       * as `_host_<property>`.
-       *
-       * @override
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template node
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       * @protected
-       */
-      static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {
-        let noted = super._parseTemplateNestedTemplate(node, templateInfo, nodeInfo);
-        // Merge host props into outer template and add bindings
-        let hostProps = nodeInfo.templateInfo.hostProps;
-        let mode = '{';
-        for (let source in hostProps) {
-          let parts = [{ mode, source, dependencies: [source] }];
-          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);
-        }
-        return noted;
-      }
-
-      /**
-       * Called to parse text in a template (either attribute values or
-       * textContent) into binding metadata.
-       *
-       * Any overrides of this method should return an array of binding part
-       * metadata  representing one or more bindings found in the provided text
-       * and any "literal" text in between.  Any non-literal parts will be passed
-       * to `_evaluateBinding` when any dependencies change.  The only required
-       * fields of each "part" in the returned array are as follows:
-       *
-       * - `dependencies` - Array containing trigger metadata for each property
-       *   that should trigger the binding to update
-       * - `literal` - String containing text if the part represents a literal;
-       *   in this case no `dependencies` are needed
-       *
-       * Additional metadata for use by `_evaluateBinding` may be provided in
-       * each part object as needed.
-       *
-       * The default implementation handles the following types of bindings
-       * (one or more may be intermixed with literal strings):
-       * - Property binding: `[[prop]]`
-       * - Path binding: `[[object.prop]]`
-       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
-       * - Two-way property or path bindings (supports negation):
-       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
-       * - Inline computed method (supports negation):
-       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
-       *
-       * @param {string} text Text to parse from attribute or textContent
-       * @param {Object} templateInfo Current template metadata
-       * @return {Array<Object>} Array of binding part metadata
-       * @protected
-       */
-      static _parseBindings(text, templateInfo) {
-        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
-          let mode = m[1][0];
-          let negate = Boolean(m[2]);
-          let source = m[3].trim();
-          let customEvent, notifyEvent, colon;
-          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
-            notifyEvent = source.substring(colon + 2);
-            source = source.substring(0, colon);
-            customEvent = true;
-          }
-          let signature = parseMethod(source);
-          let dependencies = [];
-          if (signature) {
-            // Inline computed function
-            let {args, methodName} = signature;
-            for (let i=0; i<args.length; i++) {
-              let arg = args[i];
-              if (!arg.literal) {
-                dependencies.push(arg);
-              }
-            }
-            let dynamicFns = templateInfo.dynamicFns;
-            if (dynamicFns && dynamicFns[methodName] || signature.static) {
-              dependencies.push(methodName);
-            }
-          } else {
-            // Property or path
-            dependencies.push(source);
-          }
-          parts.push({
-            source, mode, negate, customEvent, signature, dependencies,
-            event: notifyEvent
-          });
-          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;
-        }
-      }
-
-      /**
-       * Called to evaluate a previously parsed binding part based on a set of
-       * one or more changed dependencies.
-       *
-       * @param {HTMLElement} inst Element that should be used as scope for
-       *   binding dependencies
-       * @param {Object} part Binding part metadata
-       * @param {string} path Property/path that triggered this effect
-       * @param {Object} props Bag of current property changes
-       * @param {Object} oldProps Bag of previous values for changed properties
-       * @param {boolean} hasPaths True with `props` contains one or more paths
-       * @return {*} Value the binding part evaluated to
-       * @protected
-       */
-      static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {
-        let value;
-        if (part.signature) {
-          value = runMethodEffect(inst, path, props, oldProps, part.signature);
-        } else if (path != part.source) {
-          value = Polymer.Path.get(inst, part.source);
-        } else {
-          if (hasPaths && Polymer.Path.isPath(path)) {
-            value = Polymer.Path.get(inst, path);
-          } else {
-            value = inst.__data[path];
-          }
-        }
-        if (part.negate) {
-          value = !value;
-        }
-        return value;
-      }
-
-    }
-
-    return PropertyEffects;
-  });
-
-})();
-
-
-
-/***/ }),
-/* 9 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-__webpack_require__(1);
-
-
-(function() {
-
-  'use strict';
-
-  // 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;
-  }
-
-  function findTemplateNode(root, nodeInfo) {
-    // recursively ascend tree until we hit root
-    let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);
-    // 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 (nodeInfo.parentIndex === i++) {
-          return n;
-        }
-      }
-    } else {
-      return root;
-    }
-  }
-
-  // construct `$` map (from id annotations)
-  function applyIdToMap(inst, map, node, nodeInfo) {
-    if (nodeInfo.id) {
-      map[nodeInfo.id] = node;
-    }
-  }
-
-  // install event listeners (from event annotations)
-  function applyEventListener(inst, node, nodeInfo) {
-    if (nodeInfo.events && nodeInfo.events.length) {
-      for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {
-        inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
-      }
-    }
-  }
-
-  // push configuration references at configure time
-  function applyTemplateContent(inst, node, nodeInfo) {
-    if (nodeInfo.templateInfo) {
-      node._templateInfo = nodeInfo.templateInfo;
-    }
-  }
-
-  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)
-   *
-   * @polymerMixin
-   * @memberof Polymer
-   * @summary Element class mixin that provides basic template parsing and stamping
-   */
-  Polymer.TemplateStamp = Polymer.dedupingMixin(superClass => {
-
-    /**
-     * @polymerMixinClass
-     * @implements {Polymer_TemplateStamp}
-     */
-    class TemplateStamp extends superClass {
-
-      _initializeProperties() {
-        super._initializeProperties();
-        this.$ = null;
-      }
-
-      /**
-       * Scans a template to produce template metadata.
-       *
-       * Template-specific metadata are stored in the object returned, and node-
-       * specific metadata are stored in objects in its flattened `nodeInfoList`
-       * array.  Only nodes in the template that were parsed as nodes of
-       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
-       * contains an `index` (`childNodes` index in parent) and optionally
-       * `parent`, which points to node info of its parent (including its index).
-       *
-       * The template metadata object returned from this method has the following
-       * structure (many fields optional):
-       *
-       *   {
-       *     // Flattened list of node metadata (for nodes that generated metadata)
-       *     nodeInfoList: [
-       *       {
-       *         // `id` attribute for any nodes with id's for generating `$` map
-       *         id: '<id>',
-       *         // `on-event="handler"` metadata
-       *         events: [
-       *           {
-       *             name: '<name>'
-       *             value: '<handler name>'
-       *           }, ...
-       *         ],
-       *         // Notes when the template contained a `<slot>` for shady DOM
-       *         // optimization purposes
-       *         hasInsertionPoint: <boolean>,
-       *         // For nested <template> nodes, nested template metadata
-       *         templateInfo: <nested template metadata>,
-       *         // Metadata to allow efficient retrieval of instanced node
-       *         // corresponding to this metadata
-       *         parentInfo: <reference to parent nodeInfo>,
-       *         parentIndex: <integer index in parent's `childNodes` collection>
-       *         infoIndex: <integer index of this `nodeInfo` in `templateInfo.nodeInfoList`
-       *       },
-       *       ...
-       *     ],
-       *     // When true, the template had the `strip-whitespace` attribute
-       *     // or was nested in a template with that setting
-       *     stripWhitespace: <boolean>
-       *     // For nested templates, nested template content is moved into
-       *     // a document fragment stored here; this is an optimization to
-       *     // avoid the cost of nested template cloning
-       *     content: <DocumentFragment>
-       *   }
-       *
-       * This method kicks off a recursive treewalk as follows:
-       *
-       *    _parseTemplate <---------------------+
-       *      _parseTemplateContent              |
-       *        _parseTemplateNode  <------------|--+
-       *          _parseTemplateNestedTemplate --+  |
-       *          _parseTemplateChildNodes ---------+
-       *          _parseTemplateNodeAttributes
-       *            _parseTemplateNodeAttribute
-       *
-       * These methods may be overridden to add custom metadata about templates
-       * to either `templateInfo` or `nodeInfo`.
-       *
-       * Note that this method may be destructive to the template, in that
-       * e.g. event annotations may be removed after being noted in the
-       * template metadata.
-       *
-       * @param {HTMLTemplateElement} template Template to parse
-       * @param {Object=} outerTemplateInfo Template metadata from the outer
-       *   template, for parsing nested templates
-       * @return {Object} Parsed template metadata
-       */
-      static _parseTemplate(template, outerTemplateInfo) {
-        // since a template may be re-used, memo-ize metadata
-        if (!template._templateInfo) {
-          let templateInfo = template._templateInfo = {};
-          templateInfo.nodeInfoList = [];
-          templateInfo.stripWhiteSpace =
-            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
-            template.hasAttribute('strip-whitespace');
-          this._parseTemplateContent(template, templateInfo, {parent: null});
-        }
-        return template._templateInfo;
-      }
-
-      static _parseTemplateContent(template, templateInfo, nodeInfo) {
-        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
-      }
-
-      /**
-       * Parses template node and adds template and node metadata based on
-       * the current node, and its `childNodes` and `attributes`.
-       *
-       * This method may be overridden to add custom node or template specific
-       * metadata based on this node.
-       *
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       */
-      static _parseTemplateNode(node, templateInfo, nodeInfo) {
-        let noted;
-        if (node.localName == 'template' && !node.hasAttribute('preserve-content')) {
-          noted = this._parseTemplateNestedTemplate(node, templateInfo, nodeInfo) || noted;
-        } else if (node.localName === 'slot') {
-          // For ShadyDom optimization, indicating there is an insertion point
-          templateInfo.hasInsertionPoint = true;
-        }
-        if (node.firstChild) {
-          noted = this._parseTemplateChildNodes(node, templateInfo, nodeInfo) || noted;
-        }
-        if (node.hasAttributes && node.hasAttributes()) {
-          noted = this._parseTemplateNodeAttributes(node, templateInfo, nodeInfo) || noted;
-        }
-        return noted;
-      }
-
-      /**
-       * Parses template child nodes for the given root node.
-       *
-       * This method also wraps whitelisted legacy template extensions
-       * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
-       * wrappers, collapses text nodes, and strips whitespace from the template
-       * if the `templateInfo.stripWhitespace` setting was provided.
-       *
-       * @param {Node} root Root node whose `childNodes` will be parsed
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
-       */
-      static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {
-        for (let node=root.firstChild, parentIndex=0, next; node; node=next) {
-          // Wrap templates
-          if (node.localName == 'template') {
-            node = wrapTemplateExtension(node);
-          }
-          // 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.
-          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 (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
-              root.removeChild(node);
-              continue;
-            }
-          }
-          let childInfo = { parentIndex, parentInfo: nodeInfo };
-          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
-            childInfo.infoIndex = templateInfo.nodeInfoList.push(childInfo) - 1;
-          }
-          parentIndex++;
-        }
-      }
-
-      /**
-       * Parses template content for the given nested `<template>`.
-       *
-       * Nested template info is stored as `templateInfo` in the current node's
-       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
-       * It will then be the responsibility of the host to set it back to the
-       * template and for users stamping nested templates to use the
-       * `_contentForTemplate` method to retrieve the content for this template
-       * (an optimization to avoid the cost of cloning nested template content).
-       *
-       * @param {HTMLTemplateElement} node Node to parse (a <template>)
-       * @param {Object} outerTemplateInfo Template metadata for current template
-       *   that includes the template `node`
-       * @param {Object} nodeInfo Node metadata for current template.
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       */
-      static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {
-        let templateInfo = this._parseTemplate(node, outerTemplateInfo);
-        let content = templateInfo.content =
-          node.content.ownerDocument.createDocumentFragment();
-        content.appendChild(node.content);
-        nodeInfo.templateInfo = templateInfo;
-        return true;
-      }
-
-      /**
-       * Parses template node attributes and adds node metadata to `nodeInfo`
-       * for nodes of interest.
-       *
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       */
-      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
-        // Make copy of original attribute list, since the order may change
-        // as attributes are added and removed
-        let noted;
-        let attrs = Array.from(node.attributes);
-        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
-          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
-        }
-        return noted;
-      }
-
-      /**
-       * Parses a single template node attribute and adds node metadata to
-       * `nodeInfo` for attributes of interest.
-       *
-       * This implementation adds metadata for `on-event="handler"` attributes
-       * and `id` attributes.
-       *
-       * @param {Node} node Node to parse
-       * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
-       * @param {string} name Attribute name
-       * @param {*} value Attribute value
-       * @return {boolean} `true` if the visited node added node-specific
-       *   metadata to `nodeInfo`
-       */
-      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
-        // events (on-*)
-        if (name.slice(0, 3) === 'on-') {
-          node.removeAttribute(name);
-          nodeInfo.events = nodeInfo.events || [];
-          nodeInfo.events.push({
-            name: name.slice(3),
-            value
-          });
-          return true;
-        }
-        // static id
-        else if (name === 'id') {
-          nodeInfo.id = value;
-          return true;
-        }
-      }
-
-      /**
-       * Returns the `content` document fragment for a given template.
-       *
-       * For nested templates, Polymer performs an optimization to cache nested
-       * template content to avoid the cost of cloning deeply nested templates.
-       * This method retrieves the cached content for a given template.
-       *
-       * @param {HTMLTemplateElement} template Template to retrieve `content` for
-       * @return {DocumentFragment} Content fragment
-       */
-      static _contentForTemplate(template) {
-        let templateInfo = template.__templateInfo;
-        return (templateInfo && templateInfo.content) || template.content;
-      }
-
-      /**
-       * Clones the provided template content and returns a document fragment
-       * containing the cloned dom.
-       *
-       * The template is parsed (once and memoized) using this library's
-       * template parsing features, and provides the following value-added
-       * features:
-       * * Adds declarative event listeners for `on-event="handler"` attributes
-       * * Generates an "id map" for all nodes with id's under `$` on returned
-       *   document fragment
-       * * Passes template info including `content` back to templates as
-       *   `_templateInfo` (a performance optimization to avoid deep template
-       *   cloning)
-       *
-       * Note that the memoized template parsing process is destructive to the
-       * template: attributes for bindings and declarative event listeners are
-       * removed after being noted in notes, and any nested <template>.content
-       * is removed and stored in notes as well.
-       *
-       * @param {HTMLTemplateElement} template Template to stamp
-       * @return {DocumentFragment} Cloned template content
-       */
-      _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 templateInfo = this.constructor._parseTemplate(template);
-        let nodeInfo = templateInfo.nodeInfoList;
-        let content = templateInfo.content || template.content;
-        let dom = document.importNode(content, true);
-        // NOTE: ShadyDom optimization indicating there is an insertion point
-        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
-        let nodes = dom.nodeList = new Array(nodeInfo.length);
-        dom.$ = {};
-        for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {
-          let node = nodes[i] = findTemplateNode(dom, info);
-          applyIdToMap(this, dom.$, node, info);
-          applyTemplateContent(this, node, info);
-          applyEventListener(this, node, info);
-        }
-        return dom;
-      }
-
-      /**
-       * Adds an event listener by method name for the event provided.
-       *
-       * This method generates a handler function that looks up the method
-       * name at handling time.
-       *
-       * @param {Node} node Node to add listener on
-       * @param {string} eventName Name of event
-       * @param {string} methodName Name of method
-       * @param {*=} context Context the method will be called on (defaults
-       *   to `node`)
-       * @return {Function} Generated handler function
-       */
-      _addMethodEventListenerToNode(node, eventName, methodName, context) {
-        context = context || node;
-        let handler = createNodeEventHandler(context, eventName, methodName);
-        this._addEventListenerToNode(node, eventName, handler);
-        return handler;
-      }
-
-      /**
-       * Override point for adding custom or simulated event handling.
-       *
-       * @param {Node} node Node to add event listener to
-       * @param {string} eventName Name of event
-       * @param {Function} handler Listener function to add
-       */
-      _addEventListenerToNode(node, eventName, handler) {
-        node.addEventListener(eventName, handler);
-      }
-
-      /**
-       * Override point for adding custom or simulated event handling.
-       *
-       * @param {Node} node Node to remove event listener from
-       * @param {string} eventName Name of event
-       * @param {Function} handler Listener function to remove
-       */
-      _removeEventListenerFromNode(node, eventName, handler) {
-        node.removeEventListener(eventName, handler);
-      }
-
-    }
-
-    return TemplateStamp;
-
-  });
-
-})();
-
-
-
-/***/ }),
-/* 10 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-
-(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 {number} Handle used for canceling task
-       */
-      run: window.setTimeout.bind(window),
-      /**
-       * Cancels a previously enqueued `timeOut` callback.
-       *
-       * @memberof Polymer.Async.timeOut
-       * @param {number} 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 {number} Handle used for canceling task
-       */
-      run: window.requestAnimationFrame.bind(window),
-      /**
-       * Cancels a previously enqueued `animationFrame` callback.
-       *
-       * @memberof Polymer.Async.timeOut
-       * @param {number} 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(IdleDeadline)} fn Callback to run
-       * @return {number} 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 {number} handle Handle returned from `run` of callback to cancel
-       */
-      cancel(handle) {
-        window.cancelIdleCallback ?
-          window.cancelIdleCallback(handle) :
-          window.clearTimeout(handle);
-      }
-    },
-
-    /**
-     * 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} callback Callback to run
-       * @return {*} Handle used for canceling task
-       */
-      run(callback) {
-        microtaskNode.textContent = microtaskNodeContent++;
-        microtaskCallbacks.push(callback);
-        return microtaskCurrHandle++;
-      },
-
-      /**
-       * Cancels a previously enqueued `microTask` callback.
-       *
-       * @param {number} 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;
-        }
-      }
-
-    }
-  };
-
-})();
-
-
-
-/***/ }),
-/* 11 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(0);
-
-
-(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} base Path string to test against.
-     * @param {string} path Path string to test.
-     * @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
-     * @param {string} base Path string to test against.
-     * @param {string} path Path string to test.
-     * @return {boolean} True if `path` is a descendant of `base`.
-     */
-    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;
-
-})();
-
-
-
-/***/ }),
-/* 12 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/*__wc__loader*/
-__webpack_require__(3);
-
-
-(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 List of dom-module id's within which to
-     * search for css.
-     * @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;
-})();
-
-
-
-/***/ }),
-/* 13 */
-/***/ (function(module, exports, __webpack_require__) {
-
-module.exports = __webpack_require__(4);
-
-
-/***/ })
-/******/ ]);
-//# sourceMappingURL=polymer-element.js.map
\ No newline at end of file
diff --git a/polymer-element.js.map b/polymer-element.js.map
deleted file mode 100644
index e6873ff..0000000
--- a/polymer-element.js.map
+++ /dev/null
@@ -1 +0,0 @@
-{"version":3,"sources":["webpack:///webpack/bootstrap c288755b7be4389f5d8d","webpack:///./~/@polymer/polymer/lib/utils/boot.html","webpack:///./~/@polymer/polymer/lib/utils/mixin.html","webpack:///./~/@polymer/polymer/lib/utils/case-map.html","webpack:///./~/@polymer/polymer/lib/utils/resolve-url.html","webpack:///./~/@polymer/polymer/polymer-element.html","webpack:///./~/@polymer/polymer/lib/elements/dom-module.html","webpack:///./~/@polymer/polymer/lib/mixins/element-mixin.html","webpack:///./~/@polymer/polymer/lib/mixins/property-accessors.html","webpack:///./~/@polymer/polymer/lib/mixins/property-effects.html","webpack:///./~/@polymer/polymer/lib/mixins/template-stamp.html","webpack:///./~/@polymer/polymer/lib/utils/async.html","webpack:///./~/@polymer/polymer/lib/utils/path.html","webpack:///./~/@polymer/polymer/lib/utils/style-gather.html"],"names":[],"mappings":";AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA,mDAA2C,cAAc;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;AChEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,CAAC;;;;;;;;AClDD;AACA;;;;AAIA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,aAAa,SAAS;AACtB,cAAc,SAAS;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB,cAAc,SAAS;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,CAAC;;;;;;;;;AChED;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,CAAC;;;;;;;;ACvDD;AACA;;;;AAIA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,GAAG;;;;;;;;;ACjGH;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;ACxBD;AACA;;AAEA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,QAAQ;AACvB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,CAAC;;;;;;;;AC9HD;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,+BAA+B;;AAE/B;AACA,+CAA+C;AAC/C,aAAa,qBAAqB;AAClC;AACA,aAAa,qBAAqB;AAClC;AACA,aAAa,wCAAwC;AACrD;AACA,aAAa,6BAA6B;AAC1C;AACA,aAAa,4CAA4C;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,OAAO;AAChC;AACA,2BAA2B,OAAO;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB;AACjB,oBAAoB;AACpB;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,gBAAgB,MAAM;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,YAAY;AAC9B;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,gBAAgB,yBAAyB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B,gBAAgB,yBAAyB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,eAAe,YAAY;AAC3B,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA,eAAe,OAAO;AACtB;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA;AACA;AACA,sBAAsB,QAAQ;AAC9B;AACA;AACA;AACA,sBAAsB,OAAO;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,QAAQ;AACvC;AACA;AACA;AACA,oBAAoB,QAAQ;AAC5B;AACA;AACA;AACA;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB;AACA,eAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA,eAAe,oBAAoB;AACnC,eAAe,OAAO;AACtB;AACA,eAAe,OAAO;AACtB,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,MAAM;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,2BAA2B;AAC7C;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB,oBAAoB;AACpB,iBAAiB,SAAS;AAC1B,kBAAkB,KAAK;AACvB;AACA;AACA;AACA;AACA;AACA,iCAAiC,aAAa;AAC9C;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,kDAAkD;AAClD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,kBAAkB;AACxD;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,eAAe,YAAY;AAC3B;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,kBAAkB;AACvD;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,CAAC;;;;;;;;AC55BD;AACA;;AAEA;;AAEA;;AAEA;;;AAGA;;AAEA;;AAEA;;AAEA;;AAEA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA,SAAS;AACT,sCAAsC;AACtC;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,eAAe;AACpC;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB,iBAAiB,GAAG;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB,iBAAiB,EAAE;AACnB,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,EAAE;AACnB,kBAAkB,mBAAmB;AACrC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,eAAe;AACf;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB,kBAAkB,EAAE;AACpB;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA,kFAAkF,MAAM;AACxF;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,SAAS,0CAA0C;AACpE;AACA;AACA;AACA;AACA;AACA,mDAAmD;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,wCAAwC,EAAE;AAC1C;AACA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA,gEAAgE;AAChE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB,iBAAiB,EAAE;AACnB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,GAAG;;AAEH,CAAC;;;;;;;;ACxjBD;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;;AAGA;;AAEA;;AAEA,cAAc,OAAO;AACrB;;AAEA;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,qBAAqB,kBAAkB;AACvC;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB,aAAa,SAAS;AACtB,aAAa,GAAG;AAChB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,EAAE;AACf,aAAa,EAAE;AACf,aAAa,SAAS;AACtB,aAAa,GAAG;AAChB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,sBAAsB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO,4CAA4C,SAAS;AACzE,aAAa,EAAE;AACf,aAAa,0BAA0B;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,SAAS;AAC5D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,MAAM;AACnB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,cAAc;AAC3B,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA,WAAW,cAAc;AACzB;AACA;AACA;AACA;AACA;AACA,iBAAiB,wBAAwB;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,oBAAoB;AACpB,qBAAqB,uBAAuB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,QAAQ;AACrB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,KAAK;AAClB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa,KAAK;AAClB,aAAa,EAAE;AACf,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,EAAE;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;;AAEA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA,SAAS,uBAAuB;AAChC;AACA,mBAAmB,yBAAyB;AAC5C;AACA;AACA;AACA;AACA,uBAAuB,mBAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,KAAK;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA,mBAAmB,gBAAgB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,iBAAiB;AAC9B,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,SAAS;AACtB,aAAa,GAAG;AAChB;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,0CAA0C;AAChE;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,EAAE;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE,kCAAkC;AAClC,iCAAiC;AACjC,gCAAgC;AAChC;AACA;;AAEA;AACA;AACA,iBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,gDAAgD;AAChD;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,cAAc;AAC3B,aAAa,OAAO;AACpB,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,cAAc;AAC3B,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,cAAc,SAAS;AACvB;AACA;AACA;AACA;AACA,gCAAgC,KAAK;AACrC;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,MAAM;AACnB,aAAa,OAAO;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA,kCAAkC,wBAAwB;AAC1D;AACA;AACA,gCAAgC;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB,aAAa,MAAM;AACnB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,OAAO;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB;AACjB,oBAAoB;AACpB,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,MAAM;AAC1B,uBAAuB,0CAA0C;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,KAAK;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,+BAA+B;AAChD,iBAAiB,EAAE;AACnB,iBAAiB,SAAS;AAC1B;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,OAAO;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,yEAAyE,IAAI;AAC7E;AACA,yDAAyD,IAAI;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,oBAAoB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,YAAY,IAAI;AAC5C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE;AAChE;AACA,8BAA8B,UAAU;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,+BAA+B;AAChD,iBAAiB,+BAA+B;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,+BAA+B;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,6BAA6B,YAAY,GAAG,aAAa,GAAG,aAAa;AACzE;AACA,sCAAsC,YAAY;AAClD,8BAA8B,YAAY;AAC1C;AACA,gBAAgB,sBAAsB,aAAa,qDAAqD;AACxG,gBAAgB;AAChB;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,MAAM;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,iCAAiC;AAClD;AACA;AACA,mDAAmD;AACnD;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB,kBAAkB,EAAE;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,iCAAiC;AAClD;AACA;AACA,mDAAmD;AACnD;AACA;AACA;AACA,iBAAiB,EAAE;AACnB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,8DAA8D,OAAO;AACrE;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,KAAK;AACtB,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,EAAE;AACpB;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,KAAK;AACtB,kBAAkB,MAAM;AACxB;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,EAAE;AACpB;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,KAAK;AACtB,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,GAAG;AACpB;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT,+BAA+B,OAAO;AACtC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,iDAAiD;AACjD,SAAS;AACT;AACA;AACA,mDAAmD;AACnD,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA,kBAAkB,OAAO,0BAA0B;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,GAAG;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,gBAAgB;AACrC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,wBAAwB,uCAAuC;AAC/D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,MAAM,MAAM,aAAa,MAAM,OAAO,QAAQ,cAAc;AAC1E;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,cAAc;AAChC;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,MAAM;AACrC;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA,wBAAwB,wCAAwC;AAChE;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,iBAAiB;AAClC,yBAAyB,eAAe;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,QAAQ;AACzB,kBAAkB,EAAE;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,GAAG;;AAEH,CAAC;;;;;;;;ACt0ED;AACA;;AAEA;;;AAGA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,GAAG;AAC3C;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,0CAA0C,4BAA4B;AACtE;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC,iBAAiB,QAAQ;AACzB;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,aAAa;AAC3E;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB;AACA;AACA,2DAA2D,MAAM;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC,iBAAiB,OAAO;AACxB;AACA,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,cAAc;AACnD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,EAAE;AACnB,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oBAAoB;AACrC,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,6BAA6B;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,OAAO;AACxB,iBAAiB,GAAG;AACpB;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,KAAK;AACtB,iBAAiB,OAAO;AACxB,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,GAAG;;AAEH,CAAC;;;;;;;;ACndD;AACA;;;AAGA;;AAEA;;AAEA,iBAAiB,qEAAqE;AACtF,qBAAqB;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,oBAAoB;;AAE1F;AACA;AACA,mBAAmB,SAAS;AAC5B;AACA;AACA;AACA;AACA,SAAS;AACT,4BAA4B,UAAU;AACtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kBAAkB,eAAe;AACjC;AACA;AACA;AACA,mBAAmB,+BAA+B;AAClD;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,uBAAuB;AACxC,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B,kBAAkB,EAAE;AACpB;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,CAAC;;;;;;;;ACjMD;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,QAAQ;AACxB;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,+BAA+B;AAC9C,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA,qBAAqB,eAAe;AACpC;AACA,uBAAuB,eAAe;AACtC;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,+BAA+B;AAC9C,gBAAgB,eAAe;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,+BAA+B;AAC9C,eAAe,QAAQ;AACvB;AACA,gBAAgB,EAAE;AAClB;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,gBAAgB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,eAAe,+BAA+B;AAC9C,eAAe,EAAE;AACjB,gBAAgB,mBAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,kBAAkB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,cAAc,QAAQ;AACtB;AACA;;AAEA;;AAEA,CAAC;;;;;;;;ACvQD;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA,mBAAmB,oBAAoB;AACvC;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,oBAAoB;AACnC,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA,mBAAmB,eAAe;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,eAAe,OAAO;AACtB,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,eAAe;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,CAAC","file":"polymer-element.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 13);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap c288755b7be4389f5d8d","/*__wc__loader*/\n\n(function() {\n  'use strict';\n\n  const userPolymer = window.Polymer;\n\n  /**\n   * @namespace Polymer\n   * @summary Polymer is a lightweight library built on top of the web\n   * standards-based Web Components API's, and makes it easy to build your\n   * own custom HTML elements.\n   * @param {Object} info Prototype for the custom element. It must contain\n   * an `is` property to specify the element name. Other properties populate\n   * the element prototype. The `properties`, `observers`, `hostAttributes`,\n   * and `listeners` properties are processed to create element features.\n   * @return {Object} Returns a custom element class for the given provided\n   * prototype `info` object. The name of the element if given by `info.is`.\n   */\n  window.Polymer = function(info) {\n    return window.Polymer._polymerFn(info);\n  }\n\n  // support user settings on the Polymer object\n  if (userPolymer) {\n    Object.assign(Polymer, userPolymer);\n  }\n\n  // To be plugged by legacy implementation if loaded\n  /**\n   * @param {Object} info Prototype for the custom element. It must contain\n   * an `is` property to specify the element name. Other properties populate\n   * the element prototype. The `properties`, `observers`, `hostAttributes`,\n   * and `listeners` properties are processed to create element features.\n   */\n  window.Polymer._polymerFn = function(info) { // eslint-disable-line no-unused-vars\n    throw new Error('Load polymer.html to use the Polymer() function.');\n  }\n  window.Polymer.version = '2.0-preview';\n\n  /* eslint-disable no-unused-vars */\n  /*\n  When using Closure Compiler, JSCompiler_renameProperty(property, object) is replaced by the munged name for object[property]\n  We cannot alias this function, so we have to use a small shim that has the same behavior when not compiling.\n  */\n  window.JSCompiler_renameProperty = function(prop, obj) {\n    return prop;\n  }\n  /* eslint-enable */\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/boot.html\n// module id = 0\n// module chunks = 0","/*__wc__loader*/\nrequire('./boot.html');\n\n\n\n(function() {\n\n  'use strict';\n\n  // unique global id for deduping mixins.\n  let dedupeId = 0;\n\n  /**\n   * Given a mixin producing function, memoize applications of mixin to base\n   * @private\n   * @param {Function} mixin Mixin for which to create a caching mixin.\n   * @return {Function} Returns a mixin which when applied multiple times to the\n   * same base will always return the same extended class.\n   */\n  function cachingMixin(mixin) {\n    return function(base) {\n      if (!mixin.__mixinApplications) {\n        mixin.__mixinApplications = new WeakMap();\n      }\n      let map = mixin.__mixinApplications;\n      let application = map.get(base);\n      if (!application) {\n        application = mixin(base);\n        map.set(base, application);\n      }\n      return application;\n    };\n  }\n\n  /**\n   * Wraps an ES6 class expression mixin such that the mixin is only applied\n   * if it has not already been applied its base argument.  Also memoizes mixin\n   * applications.\n   *\n   * @memberof Polymer\n   * @param {Function} mixin ES6 class expression mixin to wrap\n   * @return {Function} Wrapped mixin that deduplicates and memoizes\n   *   mixin applications to base\n   */\n  Polymer.dedupingMixin = function(mixin) {\n    mixin = cachingMixin(mixin);\n    // maintain a unique id for each mixin\n    mixin.__dedupeId = ++dedupeId;\n    return function(base) {\n      let baseSet = base.__mixinSet;\n      if (baseSet && baseSet[mixin.__dedupeId]) {\n        return base;\n      }\n      let extended = mixin(base);\n      // copy inherited mixin set from the extended class, or the base class\n      // NOTE: we avoid use of Set here because some browser (IE11)\n      // cannot extend a base Set via the constructor.\n      extended.__mixinSet =\n        Object.create(extended.__mixinSet || baseSet || null);\n      extended.__mixinSet[mixin.__dedupeId] = true;\n      return extended;\n    }\n  };\n\n})();\n\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/mixin.html\n// module id = 1\n// module chunks = 0","/*__wc__loader*/\nrequire('./boot.html');\n\n\n(function() {\n  'use strict';\n\n  const caseMap = {};\n  const DASH_TO_CAMEL = /-[a-z]/g;\n  const CAMEL_TO_DASH = /([A-Z])/g;\n\n  /**\n   * Module with utilities for converting between \"dash-case\" and \"camelCase\"\n   * identifiers.\n   *\n   * @namespace\n   * @memberof Polymer\n   * @summary Module that provides utilities for converting between \"dash-case\"\n   *   and \"camelCase\".\n   */\n  const CaseMap = {\n\n    /**\n     * Converts \"dash-case\" identifier (e.g. `foo-bar-baz`) to \"camelCase\"\n     * (e.g. `fooBarBaz`).\n     *\n     * @memberof Polymer.CaseMap\n     * @param {string} dash Dash-case identifier\n     * @return {string} Camel-case representation of the identifier\n     */\n    dashToCamelCase(dash) {\n      return caseMap[dash] || (\n        caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(DASH_TO_CAMEL,\n          (m) => m[1].toUpperCase()\n        )\n      );\n    },\n\n    /**\n     * Converts \"camelCase\" identifier (e.g. `fooBarBaz`) to \"dash-case\"\n     * (e.g. `foo-bar-baz`).\n     *\n     * @memberof Polymer.CaseMap\n     * @param {string} camel Camel-case identifier\n     * @return {string} Dash-case representation of the identifier\n     */\n    camelToDashCase(camel) {\n      return caseMap[camel] || (\n        caseMap[camel] = camel.replace(CAMEL_TO_DASH, '-$1').toLowerCase()\n      );\n    }\n\n  };\n\n  Polymer.CaseMap = CaseMap;\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/case-map.html\n// module id = 2\n// module chunks = 0","/*__wc__loader*/\nrequire('./boot.html');\n\n\n\n  (function() {\n    'use strict';\n\n    let CSS_URL_RX = /(url\\()([^)]*)(\\))/g;\n    let ABS_URL = /(^\\/)|(^#)|(^[\\w-\\d]*:)/;\n    let workingURL;\n    let resolveDoc;\n    /**\n     * Resolves the given URL against the provided `baseUri'.\n     *\n     * @memberof Polymer.ResolveUrl\n     * @param {string} url Input URL to resolve\n     * @param {string} baseURI Base URI to resolve the URL against\n     * @return {string} resolved URL\n     */\n    function resolveUrl(url, baseURI) {\n      if (url && ABS_URL.test(url)) {\n        return url;\n      }\n      // Lazy feature detection.\n      if (workingURL === undefined) {\n        workingURL = false;\n        try {\n          const u = new URL('b', 'http://a');\n          u.pathname = 'c%20d';\n          workingURL = (u.href === 'http://a/c%20d');\n        } catch (e) {\n          // silently fail\n        }\n      }\n      if (!baseURI) {\n        baseURI = document.baseURI || window.location.href;\n      }\n      if (workingURL) {\n        return (new URL(url, baseURI)).href;\n      }\n      // Fallback to creating an anchor into a disconnected document.\n      if (!resolveDoc) {\n        resolveDoc = document.implementation.createHTMLDocument('temp');\n        resolveDoc.base = resolveDoc.createElement('base');\n        resolveDoc.head.appendChild(resolveDoc.base);\n        resolveDoc.anchor = resolveDoc.createElement('a');\n        resolveDoc.body.appendChild(resolveDoc.anchor);\n      }\n      resolveDoc.base.href = baseURI;\n      resolveDoc.anchor.href = url;\n      return resolveDoc.anchor.href || url;\n\n    }\n\n    /**\n     * Resolves any relative URL's in the given CSS text against the provided\n     * `ownerDocument`'s `baseURI`.\n     *\n     * @memberof Polymer.ResolveUrl\n     * @param {string} cssText CSS text to process\n     * @param {string} baseURI Base URI to resolve the URL against\n     * @return {string} Processed CSS text with resolved URL's\n     */\n    function resolveCss(cssText, baseURI) {\n      return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {\n        return pre + '\\'' +\n          resolveUrl(url.replace(/[\"']/g, ''), baseURI) +\n          '\\'' + post;\n      });\n    }\n\n    /**\n     * Returns a path from a given `url`. The path includes the trailing\n     * `/` from the url.\n     *\n     * @memberof Polymer.ResolveUrl\n     * @param {string} url Input URL to transform\n     * @return {string} resolved path\n     */\n    function pathFromUrl(url) {\n      return url.substring(0, url.lastIndexOf('/') + 1);\n    }\n\n    /**\n     * Module with utilities for resolving relative URL's.\n     *\n     * @namespace\n     * @memberof Polymer\n     * @summary Module with utilities for resolving relative URL's.\n     */\n    Polymer.ResolveUrl = {\n      resolveCss: resolveCss,\n      resolveUrl: resolveUrl,\n      pathFromUrl: pathFromUrl\n    };\n\n  })();\n\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/resolve-url.html\n// module id = 3\n// module chunks = 0","/*__wc__loader*/\nrequire('./lib/mixins/element-mixin.html');\n\n\n(function() {\n  'use strict';\n\n  /**\n   * Base class that provides the core API for Polymer's meta-programming\n   * features including template stamping, data-binding, attribute deserialization,\n   * and property change observation.\n   *\n   * @polymerElement\n   * @memberof Polymer\n   * @constructor\n   * @implements {Polymer_ElementMixin}\n   * @extends HTMLElement\n   * @mixes Polymer.ElementMixin\n   * @summary Custom element base class that provides the core API for Polymer's\n   *   key meta-programming features including template stamping, data-binding,\n   *   attribute deserialization, and property change observation\n   */\n  const Element = Polymer.ElementMixin(HTMLElement);\n  Polymer.Element = Element;\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/polymer-element.html\n// module id = 4\n// module chunks = 0","/*__wc__loader*/\nrequire('../utils/boot.html');\n\nrequire('../utils/resolve-url.html');\n\n\n(function() {\n  'use strict';\n\n  let modules = {};\n  let lcModules = {};\n  function findModule(id) {\n    return modules[id] || lcModules[id.toLowerCase()];\n  }\n\n  function styleOutsideTemplateCheck(inst) {\n    if (inst.querySelector('style')) {\n      console.warn('dom-module %s has style outside template', inst.id);\n    }\n  }\n\n  /**\n   * The `dom-module` element registers the dom it contains to the name given\n   * by the module's id attribute. It provides a unified database of dom\n   * accessible via its static `import` API.\n   *\n   * A key use case of `dom-module` is for providing custom element `<template>`s\n   * via HTML imports that are parsed by the native HTML parser, that can be\n   * relocated during a bundling pass and still looked up by `id`.\n   *\n   * Example:\n   *\n   *     <dom-module id=\"foo\">\n   *       <img src=\"stuff.png\">\n   *     </dom-module>\n   *\n   * Then in code in some other location that cannot access the dom-module above\n   *\n   *     let img = document.createElement('dom-module').import('foo', 'img');\n   *\n   * @extends HTMLElement\n   * @memberof Polymer\n   * @summary Custom element that provides a registry of relocatable DOM content\n   *   by `id` that is agnostic to bundling.\n   */\n  class DomModule extends HTMLElement {\n\n    static get observedAttributes() { return ['id'] }\n\n    /**\n     * Retrieves the element specified by the css `selector` in the module\n     * registered by `id`. For example, this.import('foo', 'img');\n     * @param {string} id The id of the dom-module in which to search.\n     * @param {string=} selector The css selector by which to find the element.\n     * @return {Element} Returns the element which matches `selector` in the\n     * module registered at the specified `id`.\n     */\n    static import(id, selector) {\n      if (id) {\n        let m = findModule(id);\n        if (m && selector) {\n          return m.querySelector(selector);\n        }\n        return m;\n      }\n      return null;\n    }\n\n    attributeChangedCallback(name, old, value) {\n      if (old !== value) {\n        this.register();\n      }\n    }\n\n    /**\n     * The absolute URL of the original location of this `dom-module`.\n     *\n     * This value will differ from this element's `ownerDocument` in the\n     * following ways:\n     * - Takes into account any `assetpath` attribute added during bundling\n     *   to indicate the original location relative to the bundled location\n     * - Uses the HTMLImports polyfill's `importForElement` API to ensure\n     *   the path is relative to the import document's location since\n     *   `ownerDocument` is not currently polyfilled\n     */\n    get assetpath() {\n      // Don't override existing assetpath.\n      if (!this.__assetpath) {\n        // note: assetpath set via an attribute must be relative to this\n        // element's location; accomodate polyfilled HTMLImports\n        const owner = window.HTMLImports && HTMLImports.importForElement ?\n          HTMLImports.importForElement(this) || document : this.ownerDocument;\n        const url = Polymer.ResolveUrl.resolveUrl(\n          this.getAttribute('assetpath') || '', owner.baseURI);\n        this.__assetpath = Polymer.ResolveUrl.pathFromUrl(url);\n      }\n      return this.__assetpath;\n    }\n\n    /**\n     * Registers the dom-module at a given id. This method should only be called\n     * when a dom-module is imperatively created. For\n     * example, `document.createElement('dom-module').register('foo')`.\n     * @param {string=} id The id at which to register the dom-module.\n     */\n    register(id) {\n      id = id || this.id;\n      if (id) {\n        this.id = id;\n        // store id separate from lowercased id so that\n        // in all cases mixedCase id will stored distinctly\n        // and lowercase version is a fallback\n        modules[id] = this;\n        lcModules[id.toLowerCase()] = this;\n        styleOutsideTemplateCheck(this);\n      }\n    }\n  }\n\n  DomModule.prototype['modules'] = modules;\n\n  customElements.define('dom-module', DomModule);\n\n  // export\n  Polymer.DomModule = DomModule;\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/elements/dom-module.html\n// module id = 5\n// module chunks = 0","/*__wc__loader*/\nrequire('../utils/boot.html');\n\nrequire('../utils/mixin.html');\n\nrequire('../utils/case-map.html');\n\nrequire('../utils/style-gather.html');\n\nrequire('../utils/resolve-url.html');\n\nrequire('../elements/dom-module.html');\n\nrequire('./property-effects.html');\n\n\n(function() {\n  'use strict';\n  /**\n   * @typedef Object<string, {\n   *   value: *,\n   *   type: (Function | undefined),\n   *   readOnly: (boolean | undefined),\n   *   computed: (string | undefined),\n   *   reflectToAttribute: (boolean | undefined),\n   *   notify: (boolean | undefined),\n   *   observer: (string | undefined)\n   * }>)\n   */\n  let PolymerElementProperties; // eslint-disable-line no-unused-vars\n\n  /** @record */\n  let PolymerElementConstructor = function(){}; // eslint-disable-line no-unused-vars\n  /** @type {(string | undefined)} */\n  PolymerElementConstructor.is;\n  /** @type {(string | undefined)} */\n  PolymerElementConstructor.extends;\n  /** @type {(!PolymerElementProperties | undefined)} */\n  PolymerElementConstructor.properties;\n  /** @type {(!Array<string> | undefined)} */\n  PolymerElementConstructor.observers;\n  /** @type {(!HTMLTemplateElement | string | undefined)} */\n  PolymerElementConstructor.template;\n\n  /**\n   * Element class mixin that provides the core API for Polymer's meta-programming\n   * features including template stamping, data-binding, attribute deserialization,\n   * and property change observation.\n   *\n   * Subclassers may provide the following static getters to return metadata\n   * used to configure Polymer's features for the class:\n   *\n   * - `static get is()`: When the template is provided via a `dom-module`,\n   *   users should return the `dom-module` id from a static `is` getter.  If\n   *   no template is needed or the template is provided directly via the\n   *   `template` getter, there is no need to define `is` for the element.\n   *\n   * - `static get template()`: Users may provide the template directly (as\n   *   opposed to via `dom-module`) by implementing a static `template` getter.\n   *   The getter may return an `HTMLTemplateElement` or a string, which will\n   *   automatically be parsed into a template.\n   *\n   * - `static get properties()`: Should return an object describing\n   *   property-related metadata used by Polymer features (key: property name\n   *   value: object containing property metadata). Valid keys in per-property\n   *   metadata include:\n   *   - `type` (String|Number|Object|Array|...): Used by\n   *     `attributeChangedCallback` to determine how string-based attributes\n   *     are deserialized to JavaScript property values.\n   *   - `notify` (boolean): Causes a change in the property to fire a\n   *     non-bubbling event called `<property>-changed`. Elements that have\n   *     enabled two-way binding to the property use this event to observe changes.\n   *   - `readOnly` (boolean): Creates a getter for the property, but no setter.\n   *     To set a read-only property, use the private setter method\n   *     `_setProperty(property, value)`.\n   *   - `observer` (string): Observer method name that will be called when\n   *     the property changes. The arguments of the method are\n   *     `(value, previousValue)`.\n   *   - `computed` (string): String describing method and dependent properties\n   *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).\n   *     Computed properties are read-only by default and can only be changed\n   *     via the return value of the computing method.\n   *\n   * - `static get observers()`: Array of strings describing multi-property\n   *   observer methods and their dependent properties (e.g.\n   *   `'observeABC(a, b, c)'`).\n   *\n   * The base class provides default implementations for the following standard\n   * custom element lifecycle callbacks; users may override these, but should\n   * call the super method to ensure\n   * - `constructor`: Run when the element is created or upgraded\n   * - `connectedCallback`: Run each time the element is connected to the\n   *   document\n   * - `disconnectedCallback`: Run each time the element is disconnected from\n   *   the document\n   * - `attributeChangedCallback`: Run each time an attribute in\n   *   `observedAttributes` is set or removed (note: this element's default\n   *   `observedAttributes` implementation will automatically return an array\n   *   of dash-cased attributes based on `properties`)\n   *\n   * @polymerMixin\n   * @mixes Polymer.PropertyEffects\n   * @memberof Polymer\n   * @property rootPath {string} Set to the value of `Polymer.rootPath`,\n   *   which defaults to the main document path\n   * @property importPath {string} Set to the value of the class's static\n   *   `importPath` property, which defaults to the path of this element's\n   *   `dom-module` (when `is` is used), but can be overridden for other\n   *   import strategies.\n   * @summary Element class mixin that provides the core API for Polymer's\n   * meta-programming features.\n   */\n  Polymer.ElementMixin = Polymer.dedupingMixin(base => {\n\n    /**\n     * @constructor\n     * @extends {base}\n     * @implements {Polymer_PropertyEffects}\n     */\n    const polymerElementBase = Polymer.PropertyEffects(base);\n\n    let caseMap = Polymer.CaseMap;\n\n    const DISABLED = 'disable-upgrade';\n\n    /**\n     * Returns the `properties` object specifically on `klass`. Use for:\n     * (1) super chain mixes togther to make `propertiesForClass` which is\n     * then used to make `observedAttributes`.\n     * (2) properties effects and observers are created from it at `finalize` time.\n     *\n     * @param {HTMLElement} klass Element class\n     * @return {Object} Object containing own properties for this class\n     * @private\n     */\n    function ownPropertiesForClass(klass) {\n      if (!klass.hasOwnProperty(\n        JSCompiler_renameProperty('__ownProperties', klass))) {\n        klass.__ownProperties =\n          klass.hasOwnProperty(JSCompiler_renameProperty('properties', klass)) ?\n          klass.properties : {};\n      }\n      return klass.__ownProperties;\n    }\n\n    /**\n     * Returns the `observers` array specifically on `klass`. Use for\n     * setting up observers.\n     *\n     * @param {HTMLElement} klass Element class\n     * @return {Array} Array containing own observers for this class\n     * @private\n     */\n    function ownObserversForClass(klass) {\n      if (!klass.hasOwnProperty(\n        JSCompiler_renameProperty('__ownObservers', klass))) {\n        klass.__ownObservers =\n          klass.hasOwnProperty(JSCompiler_renameProperty('observers', klass)) ?\n          klass.observers : [];\n      }\n      return klass.__ownObservers;\n    }\n\n    /**\n     * Mixes `props` into `flattenedProps` but upgrades shorthand type\n     * syntax to { type: Type}.\n     *\n     * @param {Object} flattenedProps Bag to collect flattened properties into\n     * @param {Object} props Bag of properties to add to `flattenedProps`\n     * @return {Objecg} The input `flattenedProps` bag\n     * @private\n     */\n    function flattenProperties(flattenedProps, props) {\n      for (let p in props) {\n        let o = props[p];\n        if (typeof o == 'function') {\n          o = { type: o };\n        }\n        flattenedProps[p] = o;\n      }\n      return flattenedProps;\n    }\n\n    /**\n     * Returns a flattened list of properties mixed together from the chain of all\n     * constructor's `config.properties`. This list is used to create\n     * (1) observedAttributes,\n     * (2) class property default values\n     *\n     * @param {HTMLElement} klass Element class\n     * @return {PolymerElementProperties} Flattened properties for this class\n     * @private\n     */\n    function propertiesForClass(klass) {\n      if (!klass.hasOwnProperty(\n        JSCompiler_renameProperty('__classProperties', klass))) {\n        klass.__classProperties =\n        flattenProperties({}, ownPropertiesForClass(klass));\n        let superCtor = Object.getPrototypeOf(klass.prototype).constructor;\n        if (superCtor.prototype instanceof PolymerElement) {\n          klass.__classProperties = Object.assign(\n            Object.create(propertiesForClass(superCtor)),\n            klass.__classProperties);\n        }\n      }\n      return klass.__classProperties;\n    }\n\n    /**\n     * Returns a list of properties with default values.\n     * This list is created as an optimization since it is a subset of\n     * the list returned from `propertiesForClass`.\n     * This list is used in `_initializeProperties` to set property defaults.\n     *\n     * @param {HTMLElement} klass Element class\n     * @return {PolymerElementProperties} Flattened properties for this class\n     *   that have default values\n     * @private\n     */\n    function propertyDefaultsForClass(klass) {\n      if (!klass.hasOwnProperty(\n        JSCompiler_renameProperty('__classPropertyDefaults', klass))) {\n        klass.__classPropertyDefaults = null;\n        let props = propertiesForClass(klass);\n        for (let p in props) {\n          let info = props[p];\n          if ('value' in info) {\n            klass.__classPropertyDefaults = klass.__classPropertyDefaults || {};\n            klass.__classPropertyDefaults[p] = info;\n          }\n        }\n      }\n      return klass.__classPropertyDefaults;\n    }\n\n    /**\n     * Returns true if a `klass` has finalized. Called in `ElementClass.finalize()`\n     * @param {HTMLElement} klass Element class\n     * @return {boolean} True if all metaprogramming for this class has been\n     *   completed\n     * @private\n     */\n    function hasClassFinalized(klass) {\n      return klass.hasOwnProperty(JSCompiler_renameProperty('__finalized', klass));\n    }\n\n    /**\n     * Called by `ElementClass.finalize()`. Ensures this `klass` and\n     * *all superclasses* are finalized by traversing the prototype chain\n     * and calling `klass.finalize()`.\n     *\n     * @param {HTMLElement} klass Element class\n     * @private\n     */\n    function finalizeClassAndSuper(klass) {\n      let proto = klass.prototype;\n      let superCtor = Object.getPrototypeOf(proto).constructor;\n      if (superCtor.prototype instanceof PolymerElement) {\n        superCtor.finalize();\n      }\n      finalizeClass(klass);\n    }\n\n    /**\n     * Configures a `klass` based on a staic `klass.config` object and\n     * a `template`. This includes creating accessors and effects\n     * for properties in `config` and the `template` as well as preparing the\n     * `template` for stamping.\n     *\n     * @param {HTMLElement} klass Element class\n     * @private\n     */\n    function finalizeClass(klass) {\n      klass.__finalized = true;\n      let proto = klass.prototype;\n      if (klass.hasOwnProperty(\n        JSCompiler_renameProperty('is', klass)) && klass.is) {\n        Polymer.telemetry.register(proto);\n      }\n      let props = ownPropertiesForClass(klass);\n      if (props) {\n        finalizeProperties(proto, props);\n      }\n      let observers = ownObserversForClass(klass);\n      if (observers) {\n        finalizeObservers(proto, observers, props);\n      }\n      // note: create \"working\" template that is finalized at instance time\n      let template = klass.template;\n      if (template) {\n        if (typeof template === 'string') {\n          let t = document.createElement('template');\n          t.innerHTML = template;\n          template = t;\n        } else {\n          template = template.cloneNode(true);\n        }\n        proto._template = template;\n      }\n    }\n\n    /**\n     * Configures a `proto` based on a `properties` object.\n     * Leverages `PropertyEffects` to create property accessors and effects\n     * supporting, observers, reflecting to attributes, change notification,\n     * computed properties, and read only properties.\n     * @param {HTMLElement} proto Element class prototype to add accessors\n     *    and effects to\n     * @param {Object} properties Flattened bag of property descriptors for\n     *    this class\n     * @private\n     */\n    function finalizeProperties(proto, properties) {\n      for (let p in properties) {\n        createPropertyFromConfig(proto, p, properties[p], properties);\n      }\n    }\n\n    /**\n     * Configures a `proto` based on a `observers` array.\n     * Leverages `PropertyEffects` to create observers.\n     * @param {HTMLElement} proto Element class prototype to add accessors\n     *   and effects to\n     * @param {Object} observers Flattened array of observer descriptors for\n     *   this class\n     * @param {Object} dynamicFns Object containing keys for any properties\n     *   that are functions and should trigger the effect when the function\n     *   reference is changed\n     * @private\n     */\n    function finalizeObservers(proto, observers, dynamicFns) {\n      for (let i=0; i < observers.length; i++) {\n        proto._createMethodObserver(observers[i], dynamicFns);\n      }\n    }\n\n    /**\n     * Creates effects for a property.\n     *\n     * Note, once a property has been set to\n     * `readOnly`, `computed`, `reflectToAttribute`, or `notify`\n     * these values may not be changed. For example, a subclass cannot\n     * alter these settings. However, additional `observers` may be added\n     * by subclasses.\n     *\n     * The info object should may contain property metadata as follows:\n     *\n     * * `type`: {function} type to which an attribute matching the property\n     * is deserialized. Note the property is camel-cased from a dash-cased\n     * attribute. For example, 'foo-bar' attribute is dersialized to a\n     * property named 'fooBar'.\n     *\n     * * `readOnly`: {boolean} creates a readOnly property and\n     * makes a private setter for the private of the form '_setFoo' for a\n     * property 'foo',\n     *\n     * * `computed`: {string} creates a computed property. A computed property\n     * also automatically is set to `readOnly: true`. The value is calculated\n     * by running a method and arguments parsed from the given string. For\n     * example 'compute(foo)' will compute a given property when the\n     * 'foo' property changes by executing the 'compute' method. This method\n     * must return the computed value.\n     *\n     * * `reflectToAttriute`: {boolean} If true, the property value is reflected\n     * to an attribute of the same name. Note, the attribute is dash-cased\n     * so a property named 'fooBar' is reflected as 'foo-bar'.\n     *\n     * * `notify`: {boolean} sends a non-bubbling notification event when\n     * the property changes. For example, a property named 'foo' sends an\n     * event named 'foo-changed' with `event.detail` set to the value of\n     * the property.\n     *\n     * * observer: {string} name of a method that runs when the property\n     * changes. The arguments of the method are (value, previousValue).\n     *\n     * Note: Users may want control over modifying property\n     * effects via subclassing. For example, a user might want to make a\n     * reflectToAttribute property not do so in a subclass. We've chosen to\n     * disable this because it leads to additional complication.\n     * For example, a readOnly effect generates a special setter. If a subclass\n     * disables the effect, the setter would fail unexpectedly.\n     * Based on feedback, we may want to try to make effects more malleable\n     * and/or provide an advanced api for manipulating them.\n     * Also consider adding warnings when an effect cannot be changed.\n     *\n     * @param {HTMLElement} proto Element class prototype to add accessors\n     *   and effects to\n     * @param {string} name Name of the property.\n     * @param {Object} info Info object from which to create property effects.\n     * Supported keys:\n     * @param {Object} allProps Flattened map of all properties defined in this\n     *   element (including inherited properties)\n     * @private\n     */\n    function createPropertyFromConfig(proto, name, info, allProps) {\n      // computed forces readOnly...\n      if (info.computed) {\n        info.readOnly = true;\n      }\n      // Note, since all computed properties are readOnly, this prevents\n      // adding additional computed property effects (which leads to a confusing\n      // setup where multiple triggers for setting a property)\n      // While we do have `hasComputedEffect` this is set on the property's\n      // dependencies rather than itself.\n      if (info.computed  && !proto._hasReadOnlyEffect(name)) {\n        proto._createComputedProperty(name, info.computed, allProps);\n      }\n      if (info.readOnly && !proto._hasReadOnlyEffect(name)) {\n        proto._createReadOnlyProperty(name, !info.computed);\n      }\n      if (info.reflectToAttribute && !proto._hasReflectEffect(name)) {\n        proto._createReflectedProperty(name);\n      }\n      if (info.notify && !proto._hasNotifyEffect(name)) {\n        proto._createNotifyingProperty(name);\n      }\n      // always add observer\n      if (info.observer) {\n        proto._createPropertyObserver(name, info.observer, allProps[info.observer]);\n      }\n    }\n\n    /**\n     * Configures an element `proto` to function with a given `template`.\n     * The element name `is` and extends `ext` must be specified for ShadyCSS\n     * style scoping.\n     *\n     * @param {HTMLElement} proto Element class prototype to add accessors\n     *   and effects to\n     * @param {HTMLTemplateElement} template Template to process and bind\n     * @param {string} baseURI URL against which to resolve urls in\n     *   style element cssText\n     * @param {string} is Tag name (or type extension name) for this element\n     * @param {string=} ext For type extensions, the tag name that was extended\n     * @private\n     */\n    function finalizeTemplate(proto, template, baseURI, is, ext) {\n      // support `include=\"module-name\"`\n      let cssText =\n        Polymer.StyleGather.cssFromTemplate(template, baseURI) +\n        Polymer.StyleGather.cssFromModuleImports(is);\n      if (cssText) {\n        let style = document.createElement('style');\n        style.textContent = cssText;\n        template.content.insertBefore(style, template.content.firstChild);\n      }\n      if (window.ShadyCSS) {\n        window.ShadyCSS.prepareTemplate(template, is, ext);\n      }\n      proto._bindTemplate(template);\n    }\n\n    function flushPropertiesStub() {}\n\n    /**\n     * @polymerMixinClass\n     * @unrestricted\n     * @implements {Polymer_ElementMixin}\n     */\n    class PolymerElement extends polymerElementBase {\n\n      /**\n       * Standard Custom Elements V1 API.  The default implementation returns\n       * a list of dash-cased attributes based on a flattening of all properties\n       * declared in `static get properties()` for this element and any\n       * superclasses.\n       *\n       * @return {Array} Observed attribute list\n       */\n      static get observedAttributes() {\n        if (!this.hasOwnProperty(JSCompiler_renameProperty('__observedAttributes', this))) {\n          let list = [DISABLED];\n          let properties = propertiesForClass(this);\n          for (let prop in properties) {\n            list.push(Polymer.CaseMap.camelToDashCase(prop));\n          }\n          this.__observedAttributes = list;\n        }\n        return this.__observedAttributes;\n      }\n\n      /**\n       * Called automatically when the first element instance is created to\n       * ensure that class finalization work has been completed.\n       * May be called by users to eagerly perform class finalization work\n       * prior to the creation of the first element instance.\n       *\n       * Class finalization work generally includes meta-programming such as\n       * creating property accessors and any property effect metadata needed for\n       * the features used.\n       *\n       * @public\n       */\n      static finalize() {\n        if (!hasClassFinalized(this)) {\n          finalizeClassAndSuper(this);\n        }\n      }\n\n      /**\n       * Returns the template that will be stamped into this element's shadow root.\n       *\n       * If a `static get is()` getter is defined, the default implementation\n       * will return the first `<template>` in a `dom-module` whose `id`\n       * matches this element's `is`.\n       *\n       * Users may override this getter to return an arbitrary template\n       * (in which case the `is` getter is unnecessary). The template returned\n       * may be either an `HTMLTemplateElement` or a string that will be\n       * automatically parsed into a template.\n       *\n       * Note that when subclassing, if the super class overrode the default\n       * implementation and the subclass would like to provide an alternate\n       * template via a `dom-module`, it should override this getter and\n       * return `Polymer.DomModule.import(this.is, 'template')`.\n       *\n       * If a subclass would like to modify the super class template, it should\n       * clone it rather than modify it in place.  If the getter does expensive\n       * work such as cloning/modifying a template, it should memoize the\n       * template for maximum performance:\n       *\n       *   let memoizedTemplate;\n       *   class MySubClass extends MySuperClass {\n       *     static get template() {\n       *       if (!memoizedTemplate) {\n       *         memoizedTemplate = super.template.cloneNode(true);\n       *         let subContent = document.createElement('div');\n       *         subContent.textContent = 'This came from MySubClass';\n       *         memoizedTemplate.content.appendChild(subContent);\n       *       }\n       *       return memoizedTemplate;\n       *     }\n       *   }\n       *\n       * @return {HTMLTemplateElement|string} Template to be stamped\n       */\n      static get template() {\n        if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {\n          this._template = Polymer.DomModule.import(this.is, 'template') ||\n            // note: implemented so a subclass can retrieve the super\n            // template; call the super impl this way so that `this` points\n            // to the superclass.\n            Object.getPrototypeOf(this.prototype).constructor.template;\n        }\n        return this._template;\n      }\n\n      /**\n       * Path matching the url from which the element was imported.\n       * This path is used to resolve url's in template style cssText.\n       * The `importPath` property is also set on element instances and can be\n       * used to create bindings relative to the import path.\n       * Defaults to the path matching the url containing a `dom-module` element\n       * matching this element's static `is` property.\n       * Note, this path should contain a trailing `/`.\n       *\n       * @return {string} The import path for this element class\n       */\n      static get importPath() {\n        if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {\n            const module = Polymer.DomModule.import(this.is);\n            this._importPath = module ? module.assetpath : '' ||\n            Object.getPrototypeOf(this.prototype).constructor.importPath;\n        }\n        return this._importPath;\n      }\n\n      /**\n       * Overrides the default `Polymer.PropertyAccessors` to ensure class\n       * metaprogramming related to property accessors and effects has\n       * completed (calls `finalize`).\n       *\n       * It also initializes any property defaults provided via `value` in\n       * `properties` metadata.\n       *\n       * @override\n       */\n      _initializeProperties() {\n        Polymer.telemetry.instanceCount++;\n        hostStack.registerHost(this);\n        this.constructor.finalize();\n        const importPath = this.constructor.importPath;\n        // note: finalize template when we have access to `localName` to\n        // avoid dependence on `is` for polyfilling styling.\n        if (this._template && !this._template.__polymerFinalized) {\n          this._template.__polymerFinalized = true;\n          const baseURI =\n            importPath ? Polymer.ResolveUrl.resolveUrl(importPath) : '';\n          finalizeTemplate(this.__proto__, this._template, baseURI,\n            this.localName);\n        }\n        super._initializeProperties();\n        // set path defaults\n        this.rootPath = Polymer.rootPath;\n        this.importPath = importPath;\n        // apply property defaults...\n        let p$ = propertyDefaultsForClass(this.constructor);\n        if (!p$) {\n          return;\n        }\n        for (let p in p$) {\n          let info = p$[p];\n          // Don't set default value if there is already an own property, which\n          // happens when a `properties` property with default but no effects had\n          // a property set (e.g. bound) by its host before upgrade\n          if (!this.hasOwnProperty(p)) {\n            let value = typeof info.value == 'function' ?\n              info.value.call(this) :\n              info.value;\n            // Set via `_setProperty` if there is an accessor, to enable\n            // initializing readOnly property defaults\n            if (this._hasAccessor(p)) {\n              this._setPendingProperty(p, value, true);\n            } else {\n              this[p] = value;\n            }\n          }\n        }\n      }\n\n      /**\n       * Provides a default implementation of the standard Custom Elements\n       * `connectedCallback`.\n       *\n       * The default implementation enables the property effects system and\n       * flushes any pending properties, and updates shimmed CSS properties\n       * when using the ShadyCSS scoping/custom properties polyfill.\n       *\n       * @override\n       */\n      connectedCallback() {\n        if (window.ShadyCSS && this._template) {\n          window.ShadyCSS.styleElement(this);\n        }\n        if (!this.__dataInitialized) {\n          this._flushProperties();\n        }\n      }\n\n      /**\n       * Provides a default implementation of the standard Custom Elements\n       * `disconnectedCallback`.\n       *\n       * @override\n       */\n      disconnectedCallback() {}\n\n      /**\n       * Stamps the element template.\n       *\n       * @override\n       */\n      ready() {\n        if (this._template) {\n          hostStack.beginHosting(this);\n          this.root = this._stampTemplate(this._template);\n          hostStack.endHosting(this);\n          this.$ = this.root.$;\n        }\n        super.ready();\n      }\n\n      /**\n       * Implements `PropertyEffects`'s `_readyClients` call. Attaches\n       * element dom by calling `_attachDom` with the dom stamped from the\n       * element's template via `_stampTemplate`. Note that this allows\n       * client dom to be attached to the element prior to any observers\n       * running.\n       *\n       * @override\n       */\n      _readyClients() {\n        super._readyClients();\n        if (this._template) {\n          this.root = this._attachDom(this.root);\n        }\n      }\n\n\n      /**\n       * Attaches an element's stamped dom to itself. By default,\n       * this method creates a `shadowRoot` and adds the dom to it.\n       * However, this method may be overridden to allow an element\n       * to put its dom in another location.\n       *\n       * @throws {Error}\n       * @suppress {missingReturn}\n       * @param {NodeList} dom to attach to the element.\n       * @return {Node} node to which the dom has been attached.\n       */\n      _attachDom(dom) {\n        if (this.attachShadow) {\n          if (dom) {\n            if (!this.shadowRoot) {\n              this.attachShadow({mode: 'open'});\n            }\n            this.shadowRoot.appendChild(dom);\n            return this.shadowRoot;\n          }\n        } else {\n          throw new Error('ShadowDOM not available. ' +\n            // TODO(sorvell): move to compile-time conditional when supported\n          'Polymer.Element can create dom as children instead of in ' +\n          'ShadowDOM by setting `this.root = this;\\` before \\`ready\\`.');\n        }\n      }\n\n      /**\n       * Provides a default implementation of the standard Custom Elements\n       * `attributeChangedCallback`.\n       *\n       * By default, attributes declared in `properties` metadata are\n       * deserialized using their `type` information to properties of the\n       * same name.  \"Dash-cased\" attributes are deserialzed to \"camelCase\"\n       * properties.\n       *\n       * @override\n       */\n      attributeChangedCallback(name, old, value) {\n        // process `disable-upgrade` specially:\n        // First we see `disable-upgrade` added and disable `_flushProperties`,\n        // then when it's removed, restore regular flushing and flush.\n        // This should only be allowed before \"readying\".\n        if (name === DISABLED && !this.__dataInitialized) {\n          if (value !== null) {\n            this.__flushProperties = this._flushProperties;\n            this._flushProperties = flushPropertiesStub;\n          } else {\n            this._flushProperties = this.__flushProperties;\n            this._flushProperties();\n          }\n        } else if (old !== value) {\n          let property = caseMap.dashToCamelCase(name);\n          let type = propertiesForClass(this.constructor)[property].type;\n          if (!this._hasReadOnlyEffect(property)) {\n            this._attributeToProperty(name, value, type);\n          }\n        }\n      }\n\n      /**\n       * When using the ShadyCSS scoping and custom property shim, causes all\n       * shimmed styles in this element (and its subtree) to be updated\n       * based on current custom property values.\n       *\n       * The optional parameter overrides inline custom property styles with an\n       * object of properties where the keys are CSS properties, and the values\n       * are strings.\n       *\n       * Example: `this.updateStyles({'--color': 'blue'})`\n       *\n       * These properties are retained unless a value of `null` is set.\n       *\n       * @param {Object=} properties Bag of custom property key/values to\n       *   apply to this element.\n       */\n      updateStyles(properties) {\n        if (window.ShadyCSS) {\n          window.ShadyCSS.styleSubtree(this, properties);\n        }\n      }\n\n      /**\n       * Rewrites a given URL relative to a base URL. The base URL defaults to\n       * the original location of the document containing the `dom-module` for\n       * this element. This method will return the same URL before and after\n       * bundling.\n       *\n       * @param {string} url URL to resolve.\n       * @param {string=} base Optional base URL to resolve against, defaults\n       * to the element's `importPath`\n       * @return {string} Rewritten URL relative to base\n       */\n      resolveUrl(url, base) {\n        if (!base && this.importPath) {\n          base = Polymer.ResolveUrl.resolveUrl(this.importPath);\n        }\n        return Polymer.ResolveUrl.resolveUrl(url, base);\n      }\n\n      /**\n       * Overrides `PropertyAccessors` to add map of dynamic functions on\n       * template info, for consumption by `PropertyEffects` template binding\n       * code. This map determines which method templates should have accessors\n       * created for them.\n       *\n       * @override\n       */\n      static _parseTemplateContent(template, templateInfo, nodeInfo) {\n        templateInfo.dynamicFns = templateInfo.dynamicFns || propertiesForClass(this);\n        return super._parseTemplateContent(template, templateInfo, nodeInfo);\n      }\n\n    }\n\n    return PolymerElement;\n  });\n\n  /**\n   * Helper api for enqueing client dom created by a host element.\n   *\n   * By default elements are flushed via `_flushProperties` when\n   * `connectedCallback` is called. Elements attach their client dom to\n   * themselves at `ready` time which results from this first flush.\n   * This provides an ordering guarantee that the client dom an element\n   * creates is flushed before the element itself (i.e. client `ready`\n   * fires before host `ready`).\n   *\n   * However, if `_flushProperties` is called *before* an element is connected,\n   * as for example `Templatize` does, this ordering guarantee cannot be\n   * satisfied because no elements are connected. (Note: Bound elements that\n   * receive data do become enqueued clients and are properly ordered but\n   * unbound elements are not.)\n   *\n   * To maintain the desired \"client before host\" ordering guarantee for this\n   * case we rely on the \"host stack. Client nodes registers themselves with\n   * the creating host element when created. This ensures that all client dom\n   * is readied in the proper order, maintaining the desired guarantee.\n   *\n   * @private\n   */\n  let hostStack = {\n\n    stack: [],\n\n    registerHost(inst) {\n      if (this.stack.length) {\n        let host = this.stack[this.stack.length-1];\n        host._enqueueClient(inst);\n      }\n    },\n\n    beginHosting(inst) {\n      this.stack.push(inst);\n    },\n\n    endHosting(inst) {\n      let stackLen = this.stack.length;\n      if (stackLen && this.stack[stackLen-1] == inst) {\n        this.stack.pop();\n      }\n    }\n\n  }\n\n  /**\n   * Provides basic tracking of element definitions (registrations) and\n   * instance counts.\n   *\n   * @namespace\n   * @summary Provides basic tracking of element definitions (registrations) and\n   * instance counts.\n   */\n  Polymer.telemetry = {\n    /**\n     * Total number of Polymer element instances created.\n     * @type {number}\n     */\n    instanceCount: 0,\n    /**\n     * Array of Polymer element classes that have been finalized.\n     * @type {Array<Polymer.Element>}\n     */\n    registrations: [],\n    /**\n     * @param {HTMLElement} prototype Element prototype to log\n     * @private\n     */\n    _regLog: function(prototype) {\n      console.log('[' + prototype.is + ']: registered')\n    },\n    /**\n     * Registers a class prototype for telemetry purposes.\n     * @param {HTMLElement} prototype Element prototype to register\n     * @protected\n     */\n    register: function(prototype) {\n      this.registrations.push(prototype);\n      Polymer.log && this._regLog(prototype);\n    },\n    /**\n     * Logs all elements registered with an `is` to the console.\n     * @public\n     */\n    dumpRegistrations: function() {\n      this.registrations.forEach(this._regLog);\n    }\n  };\n\n  /**\n   * When using the ShadyCSS scoping and custom property shim, causes all\n   * shimmed `styles` (via `custom-style`) in the document (and its subtree)\n   * to be updated based on current custom property values.\n   *\n   * The optional parameter overrides inline custom property styles with an\n   * object of properties where the keys are CSS properties, and the values\n   * are strings.\n   *\n   * Example: `Polymer.updateStyles({'--color': 'blue'})`\n   *\n   * These properties are retained unless a value of `null` is set.\n   *\n   * @param {Object=} props Bag of custom property key/values to\n   *   apply to the document.\n   */\n  Polymer.updateStyles = function(props) {\n    if (window.ShadyCSS) {\n      window.ShadyCSS.styleDocument(props);\n    }\n  };\n\n  /**\n   * Globally settable property that is automatically assigned to\n   * `Polymer.ElementMixin` instances, useful for binding in templates to\n   * make URL's relative to an application's root.  Defaults to the main\n   * document URL, but can be overridden by users.  It may be useful to set\n   * `Polymer.rootPath` to provide a stable application mount path when\n   * using client side routing.\n   *\n   * @memberof Polymer\n   */\n  Polymer.rootPath = Polymer.rootPath ||\n    Polymer.ResolveUrl.pathFromUrl(document.baseURI || window.location.href);\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/mixins/element-mixin.html\n// module id = 6\n// module chunks = 0","/*__wc__loader*/\nrequire('../utils/boot.html');\n\nrequire('../utils/mixin.html');\n\nrequire('../utils/case-map.html');\n\nrequire('../utils/async.html');\n\n\n(function() {\n\n  'use strict';\n\n  let caseMap = Polymer.CaseMap;\n\n  let microtask = Polymer.Async.microTask;\n\n  // Save map of native properties; this forms a blacklist or properties\n  // that won't have their values \"saved\" by `saveAccessorValue`, since\n  // reading from an HTMLElement accessor from the context of a prototype throws\n  const nativeProperties = {};\n  let proto = HTMLElement.prototype;\n  while (proto) {\n    let props = Object.getOwnPropertyNames(proto);\n    for (let i=0; i<props.length; i++) {\n      nativeProperties[props[i]] = true;\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  /**\n   * Used to save the value of a property that will be overridden with\n   * an accessor. If the `model` is a prototype, the values will be saved\n   * in `__dataProto`, and it's up to the user (or downstream mixin) to\n   * decide how/when to set these values back into the accessors.\n   * If `model` is already an instance (it has a `__data` property), then\n   * the value will be set as a pending property, meaning the user should\n   * call `_invalidateProperties` or `_flushProperties` to take effect\n   *\n   * @param {Object} model Prototype or instance\n   * @param {string} property Name of property\n   * @private\n   */\n  function saveAccessorValue(model, property) {\n    // Don't read/store value for any native properties since they could throw\n    if (!nativeProperties[property]) {\n      let value = model[property];\n      if (value !== undefined) {\n        if (model.__data) {\n          // Adding accessor to instance; update the property\n          // It is the user's responsibility to call _flushProperties\n          model._setPendingProperty(property, value);\n        } else {\n          // Adding accessor to proto; save proto's value for instance-time use\n          if (!model.__dataProto) {\n            model.__dataProto = {};\n          } else if (!model.hasOwnProperty(JSCompiler_renameProperty('__dataProto', model))) {\n            model.__dataProto = Object.create(model.__dataProto);\n          }\n          model.__dataProto[property] = value;\n        }\n      }\n    }\n  }\n\n  /**\n   * Element class mixin that provides basic meta-programming for creating one\n   * or more property accessors (getter/setter pair) that enqueue an async\n   * (batched) `_propertiesChanged` callback.\n   *\n   * For basic usage of this mixin, simply declare attributes to observe via\n   * the standard `static get observedAttributes()`, implement `_propertiesChanged`\n   * on the class, and then call `MyClass.createPropertiesForAttributes()` once\n   * on the class to generate property accessors for each observed attribute\n   * prior to instancing.  Last, call `this._flushProperties()` once to enable\n   * the accessors.\n   *\n   * Any `observedAttributes` will automatically be\n   * deserialized via `attributeChangedCallback` and set to the associated\n   * property using `dash-case`-to-`camelCase` convention.\n   *\n   * @polymerMixin\n   * @memberof Polymer\n   * @summary Element class mixin for reacting to property changes from\n   *   generated property accessors.\n   */\n  Polymer.PropertyAccessors = Polymer.dedupingMixin(superClass => {\n\n    /**\n     * @polymerMixinClass\n     * @implements {Polymer_PropertyAccessors}\n     * @unrestricted\n     */\n    class PropertyAccessors extends superClass {\n\n      /**\n       * Generates property accessors for all attributes in the standard\n       * static `observedAttributes` array.\n       *\n       * Attribute names are mapped to property names using the `dash-case` to\n       * `camelCase` convention\n       *\n       */\n      static createPropertiesForAttributes() {\n        let a$ = this.observedAttributes;\n        for (let i=0; i < a$.length; i++) {\n          this.prototype._createPropertyAccessor(caseMap.dashToCamelCase(a$[i]));\n        }\n      }\n\n      constructor() {\n        super();\n        this._initializeProperties();\n      }\n\n      attributeChangedCallback(name, old, value) {\n        if (old !== value) {\n          this._attributeToProperty(name, value);\n        }\n      }\n\n      /**\n       * Initializes the local storage for property accessors.\n       *\n       * Provided as an override point for performing any setup work prior\n       * to initializing the property accessor system.\n       *\n       * @protected\n       */\n      _initializeProperties() {\n        this.__serializing = false;\n        this.__dataCounter = 0;\n        this.__dataInitialized = false;\n        this.__dataInvalid = false;\n        // initialize data with prototype values saved when creating accessors\n        this.__data = {};\n        this.__dataPending = null;\n        this.__dataOld = null;\n        if (this.__dataProto) {\n          this._initializeProtoProperties(this.__dataProto);\n          this.__dataProto = null;\n        }\n        // Capture instance properties; these will be set into accessors\n        // during first flush. Don't set them here, since we want\n        // these to overwrite defaults/constructor assignments\n        for (let p in this.__dataHasAccessor) {\n          if (this.hasOwnProperty(p)) {\n            this.__dataInstanceProps = this.__dataInstanceProps || {};\n            this.__dataInstanceProps[p] = this[p];\n            delete this[p];\n          }\n        }\n      }\n\n      /**\n       * Called at instance time with bag of properties that were overwritten\n       * by accessors on the prototype when accessors were created.\n       *\n       * The default implementation sets these properties back into the\n       * setter at instance time.  This method is provided as an override\n       * point for customizing or providing more efficient initialization.\n       *\n       * @param {Object} props Bag of property values that were overwritten\n       *   when creating property accessors.\n       * @protected\n       */\n      _initializeProtoProperties(props) {\n        for (let p in props) {\n          this._setProperty(p, props[p]);\n        }\n      }\n\n      /**\n       * Called at ready time with bag of instance properties that overwrote\n       * accessors when the element upgraded.\n       *\n       * The default implementation sets these properties back into the\n       * setter at ready time.  This method is provided as an override\n       * point for customizing or providing more efficient initialization.\n       *\n       * @param {Object} props Bag of property values that were overwritten\n       *   when creating property accessors.\n       * @protected\n       */\n      _initializeInstanceProperties(props) {\n        Object.assign(this, props);\n      }\n\n      /**\n       * Ensures the element has the given attribute. If it does not,\n       * assigns the given value to the attribute.\n       *\n       *\n       * @param {string} attribute Name of attribute to ensure is set.\n       * @param {string} value of the attribute.\n       */\n      _ensureAttribute(attribute, value) {\n        if (!this.hasAttribute(attribute)) {\n          this._valueToNodeAttribute(this, value, attribute);\n        }\n      }\n\n      /**\n       * Deserializes an attribute to its associated property.\n       *\n       * This method calls the `_deserializeValue` method to convert the string to\n       * a typed value.\n       *\n       * @param {string} attribute Name of attribute to deserialize.\n       * @param {string} value of the attribute.\n       * @param {*} type type to deserialize to.\n       */\n      _attributeToProperty(attribute, value, type) {\n        // Don't deserialize back to property if currently reflecting\n        if (!this.__serializing) {\n          let property = caseMap.dashToCamelCase(attribute);\n          this[property] = this._deserializeValue(value, type);\n        }\n      }\n\n      /**\n       * Serializes a property to its associated attribute.\n       *\n       * @param {string} property Property name to reflect.\n       * @param {string=} attribute Attribute name to reflect.\n       * @param {*=} value Property value to refect.\n       */\n      _propertyToAttribute(property, attribute, value) {\n        this.__serializing = true;\n        value = (arguments.length < 3) ? this[property] : value;\n        this._valueToNodeAttribute(this, value,\n          attribute || caseMap.camelToDashCase(property));\n        this.__serializing = false;\n      }\n\n      /**\n       * Sets a typed value to an HTML attribute on a node.\n       *\n       * This method calls the `_serializeValue` method to convert the typed\n       * value to a string.  If the `_serializeValue` method returns `undefined`,\n       * the attribute will be removed (this is the default for boolean\n       * type `false`).\n       *\n       * @param {Element} node Element to set attribute to.\n       * @param {*} value Value to serialize.\n       * @param {string} attribute Attribute name to serialize to.\n       */\n      _valueToNodeAttribute(node, value, attribute) {\n        let str = this._serializeValue(value);\n        if (str === undefined) {\n          node.removeAttribute(attribute);\n        } else {\n          node.setAttribute(attribute, str);\n        }\n      }\n\n      /**\n       * Converts a typed JavaScript value to a string.\n       *\n       * This method is called by Polymer when setting JS property values to\n       * HTML attributes.  Users may override this method on Polymer element\n       * prototypes to provide serialization for custom types.\n       *\n       * @param {*} value Property value to serialize.\n       * @return {string | undefined} String serialized from the provided property value.\n       */\n      _serializeValue(value) {\n        /* eslint-disable no-fallthrough */\n        switch (typeof value) {\n          case 'boolean':\n            return value ? '' : undefined;\n\n          case 'object':\n            if (value instanceof Date) {\n              return value.toString();\n            } else if (value) {\n              try {\n                return JSON.stringify(value);\n              } catch(x) {\n                return '';\n              }\n            }\n\n          default:\n            return value != null ? value.toString() : undefined;\n        }\n      }\n\n      /**\n       * Converts a string to a typed JavaScript value.\n       *\n       * This method is called by Polymer when reading HTML attribute values to\n       * JS properties.  Users may override this method on Polymer element\n       * prototypes to provide deserialization for custom `type`s.  Note,\n       * the `type` argument is the value of the `type` field provided in the\n       * `properties` configuration object for a given property, and is\n       * by convention the constructor for the type to deserialize.\n       *\n       * Note: The return value of `undefined` is used as a sentinel value to\n       * indicate the attribute should be removed.\n       *\n       * @param {string} value Attribute value to deserialize.\n       * @param {*} type Type to deserialize the string to.\n       * @return {*} Typed value deserialized from the provided string.\n       */\n      _deserializeValue(value, type) {\n        /**\n         * @type {*}\n         */\n        let outValue;\n        switch (type) {\n          case Number:\n            outValue = Number(value);\n            break;\n\n          case Boolean:\n            outValue = (value !== null);\n            break;\n\n          case Object:\n            try {\n              outValue = JSON.parse(value);\n            } catch(x) {\n              // allow non-JSON literals like Strings and Numbers\n            }\n            break;\n\n          case Array:\n            try {\n              outValue = JSON.parse(value);\n            } catch(x) {\n              outValue = null;\n              console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);\n            }\n            break;\n\n          case Date:\n            outValue = new Date(value);\n            break;\n\n          case String:\n          default:\n            outValue = value;\n            break;\n        }\n\n        return outValue;\n      }\n      /* eslint-enable no-fallthrough */\n\n      /**\n       * Creates a setter/getter pair for the named property with its own\n       * local storage.  The getter returns the value in the local storage,\n       * and the setter calls `_setProperty`, which updates the local storage\n       * for the property and enqueues a `_propertiesChanged` callback.\n       *\n       * This method may be called on a prototype or an instance.  Calling\n       * this method may overwrite a property value that already exists on\n       * the prototype/instance by creating the accessor.  When calling on\n       * a prototype, any overwritten values are saved in `__dataProto`,\n       * and it is up to the subclasser to decide how/when to set those\n       * properties back into the accessor.  When calling on an instance,\n       * the overwritten value is set via `_setPendingProperty`, and the\n       * user should call `_invalidateProperties` or `_flushProperties`\n       * for the values to take effect.\n       *\n       * @param {string} property Name of the property\n       * @param {boolean=} readOnly When true, no setter is created; the\n       *   protected `_setProperty` function must be used to set the property\n       * @protected\n       */\n      _createPropertyAccessor(property, readOnly) {\n        if (!this.hasOwnProperty('__dataHasAccessor')) {\n          this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);\n        }\n        if (!this.__dataHasAccessor[property]) {\n          this.__dataHasAccessor[property] = true;\n          saveAccessorValue(this, property);\n          Object.defineProperty(this, property, {\n            get: function() {\n              return this.__data[property];\n            },\n            set: readOnly ? function() { } : function(value) {\n              this._setProperty(property, value);\n            }\n          });\n        }\n      }\n\n      /**\n       * Returns true if this library created an accessor for the given property.\n       *\n       * @param {string} property Property name\n       * @return {boolean} True if an accessor was created\n       */\n      _hasAccessor(property) {\n        return this.__dataHasAccessor && this.__dataHasAccessor[property];\n      }\n\n      /**\n       * Updates the local storage for a property (via `_setPendingProperty`)\n       * and enqueues a `_proeprtiesChanged` callback.\n       *\n       * @param {string} property Name of the property\n       * @param {*} value Value to set\n       * @protected\n       */\n      _setProperty(property, value) {\n        if (this._setPendingProperty(property, value)) {\n          this._invalidateProperties();\n        }\n      }\n\n      /**\n       * Updates the local storage for a property, records the previous value,\n       * and adds it to the set of \"pending changes\" that will be passed to the\n       * `_propertiesChanged` callback.  This method does not enqueue the\n       * `_propertiesChanged` callback.\n       *\n       * @param {string} property Name of the property\n       * @param {*} value Value to set\n       * @return {boolean} Returns true if the property changed\n       * @protected\n       */\n      _setPendingProperty(property, value) {\n        let old = this.__data[property];\n        if (this._shouldPropertyChange(property, value, old)) {\n          if (!this.__dataPending) {\n            this.__dataPending = {};\n            this.__dataOld = {};\n          }\n          // Ensure old is captured from the last turn\n          if (!(property in this.__dataOld)) {\n            this.__dataOld[property] = old;\n          }\n          this.__data[property] = value;\n          this.__dataPending[property] = value;\n          return true;\n        }\n      }\n\n      /**\n       * Returns true if the specified property has a pending change.\n       *\n       * @param {string} prop Property name\n       * @return {boolean} True if property has a pending change\n       * @protected\n       */\n      _isPropertyPending(prop) {\n        return this.__dataPending && (prop in this.__dataPending);\n      }\n\n      /**\n       * Marks the properties as invalid, and enqueues an async\n       * `_propertiesChanged` callback.\n       *\n       * @protected\n       */\n      _invalidateProperties() {\n        if (!this.__dataInvalid && this.__dataInitialized) {\n          this.__dataInvalid = true;\n          microtask.run(() => {\n            if (this.__dataInvalid) {\n              this.__dataInvalid = false;\n              this._flushProperties();\n            }\n          });\n        }\n      }\n\n      /**\n       * Calls the `_propertiesChanged` callback with the current set of\n       * pending changes (and old values recorded when pending changes were\n       * set), and resets the pending set of changes.\n       *\n       * Note that this method must be called once to enable the property\n       * accessors system.  For elements, generally `connectedCallback`\n       * is a normal spot to do so.\n       *\n       * @protected\n       */\n      _flushProperties() {\n        if (!this.__dataInitialized) {\n          this.ready()\n        } else if (this.__dataPending) {\n          let changedProps = this.__dataPending;\n          this.__dataPending = null;\n          this.__dataCounter++;\n          this._propertiesChanged(this.__data, changedProps, this.__dataOld);\n          this.__dataCounter--;\n        }\n      }\n\n      /**\n       * Lifecycle callback called the first time properties are being flushed.\n       * Prior to `ready`, all property sets through accessors are queued and\n       * their effects are flushed after this method returns.\n       *\n       * Users may override this function to implement behavior that is\n       * dependent on the element having its properties initialized, e.g.\n       * from defaults (initialized from `constructor`, `_initializeProperties`),\n       * `attributeChangedCallback`, or values propagated from host e.g. via\n       * bindings.  `super.ready()` must be called to ensure the data system\n       * becomes enabled.\n       *\n       * @public\n       */\n      ready() {\n        // Update instance properties that shadowed proto accessors; these take\n        // priority over any defaults set in constructor or attributeChangedCallback\n        if (this.__dataInstanceProps) {\n          this._initializeInstanceProperties(this.__dataInstanceProps);\n          this.__dataInstanceProps = null;\n        }\n        this.__dataInitialized = true;\n        // Run normal flush\n        this._flushProperties();\n      }\n\n      /**\n       * Callback called when any properties with accessors created via\n       * `_createPropertyAccessor` have been set.\n       *\n       * @param {Object} currentProps Bag of all current accessor values\n       * @param {Object} changedProps Bag of properties changed since the last\n       *   call to `_propertiesChanged`\n       * @param {Object} oldProps Bag of previous values for each property\n       *   in `changedProps`\n       * @protected\n       */\n      _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars\n      }\n\n      /**\n       * Method called to determine whether a property value should be\n       * considered as a change and cause the `_propertiesChanged` callback\n       * to be enqueued.\n       *\n       * The default implementation returns `true` for primitive types if a\n       * strict equality check fails, and returns `true` for all Object/Arrays.\n       * The method always returns false for `NaN`.\n       *\n       * Override this method to e.g. provide stricter checking for\n       * Objects/Arrays when using immutable patterns.\n       *\n       * @param {string} property Property name\n       * @param {*} value New property value\n       * @param {*} old Previous property value\n       * @return {boolean} Whether the property should be considered a change\n       *   and enqueue a `_proeprtiesChanged` callback\n       * @protected\n       */\n      _shouldPropertyChange(property, value, old) {\n        return (\n          // Strict equality check\n          (old !== value &&\n           // This ensures (old==NaN, value==NaN) always returns false\n           (old === old || value === value))\n        );\n      }\n\n    }\n\n    return PropertyAccessors;\n\n  });\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/mixins/property-accessors.html\n// module id = 7\n// module chunks = 0","/*__wc__loader*/\nrequire('../utils/boot.html');\n\nrequire('../utils/mixin.html');\n\nrequire('../utils/path.html');\n\nrequire('../utils/case-map.html');\n\nrequire('./property-accessors.html');\n\nrequire('./template-stamp.html');\n\n\n(function() {\n\n  'use strict';\n\n  /** @const {Object} */\n  const CaseMap = Polymer.CaseMap;\n\n  // Monotonically increasing unique ID used for de-duping effects triggered\n  // from multiple properties in the same turn\n  let dedupeId = 0;\n\n  // Property effect types; effects are stored on the prototype using these keys\n  const TYPES = {\n    COMPUTE: '__computeEffects',\n    REFLECT: '__reflectEffects',\n    NOTIFY: '__notifyEffects',\n    PROPAGATE: '__propagateEffects',\n    OBSERVE: '__observeEffects',\n    READ_ONLY: '__readOnly'\n  }\n\n  /**\n   * Ensures that the model has an own-property map of effects for the given type.\n   * The model may be a prototype or an instance.\n   *\n   * Property effects are stored as arrays of effects by property in a map,\n   * by named type on the model. e.g.\n   *\n   *   __computeEffects: {\n   *     foo: [ ... ],\n   *     bar: [ ... ]\n   *   }\n   *\n   * If the model does not yet have an effect map for the type, one is created\n   * and returned.  If it does, but it is not an own property (i.e. the\n   * prototype had effects), the the map is deeply cloned and the copy is\n   * set on the model and returned, ready for new effects to be added.\n   *\n   * @param {Object} model Prototype or instance\n   * @param {string} type Property effect type\n   * @return {Object} The own-property map of effects for the given type\n   * @private\n   */\n  function ensureOwnEffectMap(model, type) {\n    let effects = model[type];\n    if (!effects) {\n      effects = model[type] = {};\n    } else if (!model.hasOwnProperty(type)) {\n      effects = model[type] = Object.create(model[type]);\n      for (let p in effects) {\n        let protoFx = effects[p];\n        let instFx = effects[p] = Array(protoFx.length);\n        for (let i=0; i<protoFx.length; i++) {\n          instFx[i] = protoFx[i];\n        }\n      }\n    }\n    return effects;\n  }\n\n  // -- effects ----------------------------------------------\n\n  /**\n   * Runs all effects of a given type for the given set of property changes\n   * on an instance.\n   *\n   * @param {Object} inst The instance with effects to run\n   * @param {Object} effects Object map of property-to-Array of effects\n   * @param {Object} props Bag of current property changes\n   * @param {Object=} oldProps Bag of previous values for changed properties\n   * @param {boolean=} hasPaths True with `props` contains one or more paths\n   * @param {*=} extraArgs Additional metadata to pass to effect function\n   * @return {boolean} True if an effect ran for this property\n   * @private\n   */\n  function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {\n    if (effects) {\n      let ran = false;\n      let id = dedupeId++;\n      for (let prop in props) {\n        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths, extraArgs)) {\n          ran = true;\n        }\n      }\n      return ran;\n    }\n    return false;\n  }\n\n  /**\n   * Runs a list of effects for a given property.\n   *\n   * @param {Object} inst The instance with effects to run\n   * @param {Object} effects Object map of property-to-Array of effects\n   * @param {number} dedupeId Counter used for de-duping effects\n   * @param {string} prop Name of changed property\n   * @param {*} props Changed properties\n   * @param {*} oldProps Old properties\n   * @param {boolean=} hasPaths True with `props` contains one or more paths\n   * @param {*=} extraArgs Additional metadata to pass to effect function\n   * @return {boolean} True if an effect ran for this property\n   * @private\n   */\n  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {\n    let ran = false;\n    let rootProperty = hasPaths ? Polymer.Path.root(prop) : prop;\n    let fxs = effects[rootProperty];\n    if (fxs) {\n      for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {\n        if ((!fx.info || fx.info.lastRun !== dedupeId) &&\n            (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {\n          if (fx.info) {\n            fx.info.lastRun = dedupeId;\n          }\n          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);\n          ran = true;\n        }\n      }\n    }\n    return ran;\n  }\n\n  /**\n   * Determines whether a property/path that has changed matches the trigger\n   * criteria for an effect.  A trigger is a descriptor with the following\n   * structure, which matches the descriptors returned from `parseArg`.\n   * e.g. for `foo.bar.*`:\n   * ```\n   * trigger: {\n   *   name: 'a.b',\n   *   structured: true,\n   *   wildcard: true\n   * }\n   * ```\n   * If no trigger is given, the path is deemed to match.\n   *\n   * @param {string} path Path or property that changed\n   * @param {Object} trigger Descriptor\n   * @return {boolean} Whether the path matched the trigger\n   */\n  function pathMatchesTrigger(path, trigger) {\n    if (trigger) {\n      let triggerPath = trigger.name;\n      return (triggerPath == path) ||\n        (trigger.structured && Polymer.Path.isAncestor(triggerPath, path)) ||\n        (trigger.wildcard && Polymer.Path.isDescendant(triggerPath, path));\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Implements the \"observer\" effect.\n   *\n   * Calls the method with `info.methodName` on the instance, passing the\n   * new and old values.\n   *\n   * @param {Object} inst The instance the effect will be run on\n   * @param {string} property Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @private\n   */\n  function runObserverEffect(inst, property, props, oldProps, info) {\n    let fn = inst[info.methodName];\n    let changedProp = info.property;\n    if (fn) {\n      fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);\n    } else {\n      console.warn('observer method `' + info.methodName + '` not defined');\n    }\n  }\n\n  /**\n   * Runs \"notify\" effects for a set of changed properties.\n   *\n   * This method differs from the generic `runEffects` method in that it\n   * will dispatch path notification events in the case that the property\n   * changed was a path and the root property for that path didn't have a\n   * \"notify\" effect.  This is to maintain 1.0 behavior that did not require\n   * `notify: true` to ensure object sub-property notifications were\n   * sent.\n   *\n   * @param {Element} inst The instance with effects to run\n   * @param {Object} notifyProps Bag of properties to notify\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {boolean} hasPaths True with `props` contains one or more paths\n   * @private\n   */\n  function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {\n    // Notify\n    let fxs = inst.__notifyEffects;\n    let notified;\n    let id = dedupeId++;\n    // Try normal notify effects; if none, fall back to try path notification\n    for (let prop in notifyProps) {\n      if (notifyProps[prop]) {\n        if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {\n          notified = true;\n        } else if (hasPaths && notifyPath(inst, prop, props)) {\n          notified = true;\n        }\n      }\n    }\n    // Flush host if we actually notified and host was batching\n    let host;\n    if (notified && (host = inst.__dataHost) && host._flushProperties) {\n      host._flushProperties();\n    }\n  }\n\n  /**\n   * Dispatches {property}-changed events with path information in the detail\n   * object to indicate a sub-path of the property was changed.\n   *\n   * @param {Element} inst The element from which to fire the event\n   * @param {string} path The path that was changed\n   * @param {Object} props Bag of current property changes\n   * @return {boolean} Returns true if the path was notified\n   * @private\n   */\n  function notifyPath(inst, path, props) {\n    let rootProperty = Polymer.Path.root(path);\n    if (rootProperty !== path) {\n      let eventName = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';\n      dispatchNotifyEvent(inst, eventName, props[path], path);\n      return true;\n    }\n  }\n\n  /**\n   * Dispatches {property}-changed events to indicate a property (or path)\n   * changed.\n   *\n   * @param {Element} inst The element from which to fire the event\n   * @param {string} eventName The name of the event to send ('{property}-changed')\n   * @param {*} value The value of the changed property\n   * @param {string | null | undefined} path If a sub-path of this property changed, the path\n   *   that changed (optional).\n   * @private\n   */\n  function dispatchNotifyEvent(inst, eventName, value, path) {\n    let detail = {\n      value: value,\n      queueProperty: true\n    };\n    if (path) {\n      detail.path = path;\n    }\n    inst.dispatchEvent(new CustomEvent(eventName, { detail }));\n  }\n\n  /**\n   * Implements the \"notify\" effect.\n   *\n   * Dispatches a non-bubbling event named `info.eventName` on the instance\n   * with a detail object containing the new `value`.\n   *\n   * @param {Element} inst The instance the effect will be run on\n   * @param {string} property Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @param {boolean} hasPaths True with `props` contains one or more paths\n   * @private\n   */\n  function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {\n    let rootProperty = hasPaths ? Polymer.Path.root(property) : property;\n    let path = rootProperty != property ? property : null;\n    let value = path ? Polymer.Path.get(inst, path) : inst.__data[property];\n    if (path && value === undefined) {\n      value = props[property];  // specifically for .splices\n    }\n    dispatchNotifyEvent(inst, info.eventName, value, path);\n  }\n\n  /**\n   * Handler function for 2-way notification events. Receives context\n   * information captured in the `addNotifyListener` closure from the\n   * `__notifyListeners` metadata.\n   *\n   * Sets the value of the notified property to the host property or path.  If\n   * the event contained path information, translate that path to the host\n   * scope's name for that path first.\n   *\n   * @param {Event} event Notification event (e.g. '<property>-changed')\n   * @param {Object} inst Host element instance handling the notification event\n   * @param {string} fromProp Child element property that was bound\n   * @param {string} toPath Host property/path that was bound\n   * @param {boolean} negate Whether the binding was negated\n   * @private\n   */\n  function handleNotification(event, inst, fromProp, toPath, negate) {\n    let value;\n    let detail = event.detail;\n    let fromPath = detail && detail.path;\n    if (fromPath) {\n      toPath = Polymer.Path.translate(fromProp, toPath, fromPath);\n      value = detail && detail.value;\n    } else {\n      value = event.target[fromProp];\n    }\n    value = negate ? !value : value;\n    if (!inst.__readOnly || !inst.__readOnly[toPath]) {\n      if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath))\n        && (!detail || !detail.queueProperty)) {\n        inst._invalidateProperties();\n      }\n    }\n  }\n\n  /**\n   * Implements the \"reflect\" effect.\n   *\n   * Sets the attribute named `info.attrName` to the given property value.\n   *\n   * @param {Object} inst The instance the effect will be run on\n   * @param {string} property Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @private\n   */\n  function runReflectEffect(inst, property, props, oldProps, info) {\n    let value = inst.__data[property];\n    if (Polymer.sanitizeDOMValue) {\n      value = Polymer.sanitizeDOMValue(value, info.attrName, 'attribute', inst);\n    }\n    inst._propertyToAttribute(property, info.attrName, value);\n  }\n\n  /**\n   * Runs \"computed\" effects for a set of changed properties.\n   *\n   * This method differs from the generic `runEffects` method in that it\n   * continues to run computed effects based on the output of each pass until\n   * there are no more newly computed properties.  This ensures that all\n   * properties that will be computed by the initial set of changes are\n   * computed before other effects (binding propagation, observers, and notify)\n   * run.\n   *\n   * @param {Element} inst The instance the effect will be run on\n   * @param {Object} changedProps Bag of changed properties\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {boolean} hasPaths True with `props` contains one or more paths\n   * @private\n   */\n  function runComputedEffects(inst, changedProps, oldProps, hasPaths) {\n    let computeEffects = inst.__computeEffects;\n    if (computeEffects) {\n      let inputProps = changedProps;\n      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {\n        Object.assign(oldProps, inst.__dataOld);\n        Object.assign(changedProps, inst.__dataPending);\n        inputProps = inst.__dataPending;\n        inst.__dataPending = null;\n      }\n    }\n  }\n\n  /**\n   * Implements the \"computed property\" effect by running the method with the\n   * values of the arguments specified in the `info` object and setting the\n   * return value to the computed property specified.\n   *\n   * @param {Object} inst The instance the effect will be run on\n   * @param {string} property Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @private\n   */\n  function runComputedEffect(inst, property, props, oldProps, info) {\n    let result = runMethodEffect(inst, property, props, oldProps, info);\n    let computedProp = info.methodInfo;\n    if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {\n      inst._setPendingProperty(computedProp, result, true);\n    } else {\n      inst[computedProp] = result;\n    }\n  }\n\n  /**\n   * Computes path changes based on path links set up using the `linkPaths`\n   * API.\n   *\n   * @param {Element} inst The instance whose props are changing\n   * @param {string} path Path that has changed\n   * @param {*} value Value of changed path\n   * @private\n   */\n  function computeLinkedPaths(inst, path, value) {\n    let links = inst.__dataLinkedPaths;\n    if (links) {\n      let link;\n      for (let a in links) {\n        let b = links[a];\n        if (Polymer.Path.isDescendant(a, path)) {\n          link = Polymer.Path.translate(a, b, path);\n          inst._setPendingPropertyOrPath(link, value, true, true);\n        } else if (Polymer.Path.isDescendant(b, path)) {\n          link = Polymer.Path.translate(b, a, path);\n          inst._setPendingPropertyOrPath(link, value, true, true);\n        }\n      }\n    }\n  }\n\n  // -- bindings ----------------------------------------------\n\n  /**\n   * Adds binding metadata to the current `nodeInfo`, and binding effects\n   * for all part dependencies to `templateInfo`.\n   *\n   * @param {Function} constructor Class that `_parseTemplate` is currently\n   *   running on\n   * @param {Object} templateInfo Template metadata for current template\n   * @param {Object} nodeInfo Node metadata for current template node\n   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'\n   * @param {string} target Target property name\n   * @param {Array<Object>} parts Array of binding part metadata\n   * @param {string} literal Literal text surrounding binding parts (specified\n   *   only for 'property' bindings, since these must be initialized as part\n   *   of boot-up)\n   * @private\n   */\n  function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {\n    // Create binding metadata and add to nodeInfo\n    nodeInfo.bindings = nodeInfo.bindings || [];\n    let binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };\n    nodeInfo.bindings.push(binding);\n    // Add listener info to binding metadata\n    if (shouldAddListener(binding)) {\n      let {event, negate} = binding.parts[0];\n      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');\n      binding.listenerNegate = negate;\n    }\n    // Add \"propagate\" property effects to templateInfo\n    let index = templateInfo.nodeInfoList.length;\n    for (let i=0; i<binding.parts.length; i++) {\n      let part = binding.parts[i];\n      part.compoundIndex = i;\n      addEffectForBindingPart(constructor, templateInfo, binding, part, index);\n    }\n  }\n\n  /**\n   * Adds property effects to the given `templateInfo` for the given binding\n   * part.\n   *\n   * @param {Function} constructor Class that `_parseTemplate` is currently\n   *   running on\n   * @param {Object} templateInfo Template metadata for current template\n   * @param {Object} binding Binding metadata\n   * @param {Object} part Binding part metadata\n   * @param {number} index Index into `nodeInfoList` for this node\n   */\n  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {\n    if (!part.literal) {\n      if (binding.kind === 'attribute' && binding.target[0] === '-') {\n        console.warn('Cannot set attribute ' + binding.target +\n          ' because \"-\" is not a valid attribute starting character');\n      } else {\n        let dependencies = part.dependencies;\n        let info = { index, binding, part, evaluator: constructor };\n        for (let j=0; j<dependencies.length; j++) {\n          let trigger = dependencies[j];\n          if (typeof trigger == 'string') {\n            trigger = parseArg(trigger);\n            trigger.wildcard = true;\n          }\n          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {\n            fn: runBindingEffect,\n            info, trigger\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * Implements the \"binding\" (property/path binding) effect.\n   *\n   * Note that binding syntax is overridable via `_parseBindings` and\n   * `_evaluateBindings`.  This method will call `_evaluateBinding` for any\n   * non-literal parts returned from `_parseBindings`.  However,\n   * there is no support for _path_ bindings via custom binding parts,\n   * as this is specific to Polymer's path binding syntax.\n   *\n   * @param {Element} inst The instance the effect will be run on\n   * @param {string} path Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @param {boolean} hasPaths True with `props` contains one or more paths\n   * @param {Array} nodeList List of nodes associated with `nodeInfoList` template\n   *   metadata\n   * @private\n   */\n  function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {\n    let node = nodeList[info.index];\n    let binding = info.binding;\n    let part = info.part;\n    // Subpath notification: transform path and set to client\n    // e.g.: foo=\"{{obj.sub}}\", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop\n    if (hasPaths && part.source && (path.length > part.source.length) &&\n        (binding.kind == 'property') && !binding.isCompound &&\n        node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {\n      let value = props[path];\n      path = Polymer.Path.translate(part.source, binding.target, path);\n      if (node._setPendingPropertyOrPath(path, value, false, true)) {\n        inst._enqueueClient(node);\n      }\n    } else {\n      let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);\n      // Propagate value to child\n      applyBindingValue(inst, node, binding, part, value);\n    }\n  }\n\n  /**\n   * Sets the value for an \"binding\" (binding) effect to a node,\n   * either as a property or attribute.\n   *\n   * @param {Object} inst The instance owning the binding effect\n   * @param {Node} node Target node for binding\n   * @param {Object} binding Binding metadata\n   * @param {Object} part Binding part metadata\n   * @param {*} value Value to set\n   * @private\n   */\n  function applyBindingValue(inst, node, binding, part, value) {\n    value = computeBindingValue(node, value, binding, part);\n    if (Polymer.sanitizeDOMValue) {\n      value = Polymer.sanitizeDOMValue(value, binding.target, binding.kind, node);\n    }\n    if (binding.kind == 'attribute') {\n      // Attribute binding\n      inst._valueToNodeAttribute(node, value, binding.target);\n    } else {\n      // Property binding\n      let prop = binding.target;\n      if (node.__dataHasAccessor && node.__dataHasAccessor[prop]) {\n        if (!node.__readOnly || !node.__readOnly[prop]) {\n          if (node._setPendingProperty(prop, value)) {\n            inst._enqueueClient(node);\n          }\n        }\n      } else  {\n        inst._setUnmanagedPropertyToNode(node, prop, value);\n      }\n    }\n  }\n\n  /**\n   * Transforms an \"binding\" effect value based on compound & negation\n   * effect metadata, as well as handling for special-case properties\n   *\n   * @param {Node} node Node the value will be set to\n   * @param {*} value Value to set\n   * @param {Object} binding Binding metadata\n   * @param {Object} part Binding part metadata\n   * @return {*} Transformed value to set\n   * @private\n   */\n  function computeBindingValue(node, value, binding, part) {\n    if (binding.isCompound) {\n      let storage = node.__dataCompoundStorage[binding.target];\n      storage[part.compoundIndex] = value;\n      value = storage.join('');\n    }\n    if (binding.kind !== 'attribute') {\n      // Some browsers serialize `undefined` to `\"undefined\"`\n      if (binding.target === 'textContent' ||\n          (node.localName == 'input' && binding.target == 'value')) {\n        value = value == undefined ? '' : value;\n      }\n    }\n    return value;\n  }\n\n  /**\n   * Returns true if a binding's metadata meets all the requirements to allow\n   * 2-way binding, and therefore a <property>-changed event listener should be\n   * added:\n   * - used curly braces\n   * - is a property (not attribute) binding\n   * - is not a textContent binding\n   * - is not compound\n   *\n   * @param {Object} binding Binding metadata\n   * @return {boolean} True if 2-way listener should be added\n   * @private\n   */\n  function shouldAddListener(binding) {\n    return binding.target &&\n           binding.kind != 'attribute' &&\n           binding.kind != 'text' &&\n           !binding.isCompound &&\n           binding.parts[0].mode === '{';\n  }\n\n  /**\n   * Setup compound binding storage structures, notify listeners, and dataHost\n   * references onto the bound nodeList.\n   *\n   * @param {Object} inst Instance that bas been previously bound\n   * @param {Object} templateInfo Template metadata\n   * @private\n   */\n  function setupBindings(inst, templateInfo) {\n    // Setup compound storage, dataHost, and notify listeners\n    let {nodeList, nodeInfoList} = templateInfo;\n    if (nodeInfoList.length) {\n      for (let i=0; i < nodeInfoList.length; i++) {\n        let info = nodeInfoList[i];\n        let node = nodeList[i];\n        let bindings = info.bindings;\n        if (bindings) {\n          for (let i=0; i<bindings.length; i++) {\n            let binding = bindings[i];\n            setupCompoundStorage(node, binding);\n            addNotifyListener(node, inst, binding);\n          }\n        }\n        node.__dataHost = inst;\n      }\n    }\n  }\n\n  /**\n   * Initializes `__dataCompoundStorage` local storage on a bound node with\n   * initial literal data for compound bindings, and sets the joined\n   * literal parts to the bound property.\n   *\n   * When changes to compound parts occur, they are first set into the compound\n   * storage array for that property, and then the array is joined to result in\n   * the final value set to the property/attribute.\n   *\n   * @param {Node} node Bound node to initialize\n   * @param {Object} binding Binding metadata\n   * @private\n   */\n  function setupCompoundStorage(node, binding) {\n    if (binding.isCompound) {\n      // Create compound storage map\n      let storage = node.__dataCompoundStorage ||\n        (node.__dataCompoundStorage = {});\n      let parts = binding.parts;\n      // Copy literals from parts into storage for this binding\n      let literals = new Array(parts.length);\n      for (let j=0; j<parts.length; j++) {\n        literals[j] = parts[j].literal;\n      }\n      let target = binding.target;\n      storage[target] = literals;\n      // Configure properties with their literal parts\n      if (binding.literal && binding.kind == 'property') {\n        node[target] = binding.literal;\n      }\n    }\n  }\n\n  /**\n   * Adds a 2-way binding notification event listener to the node specified\n   *\n   * @param {Object} node Child element to add listener to\n   * @param {Object} inst Host element instance to handle notification event\n   * @param {Object} binding Binding metadata\n   * @private\n   */\n  function addNotifyListener(node, inst, binding) {\n    if (binding.listenerEvent) {\n      let part = binding.parts[0];\n      node.addEventListener(binding.listenerEvent, function(e) {\n        handleNotification(e, inst, binding.target, part.source, part.negate);\n      });\n    }\n  }\n\n  // -- for method-based effects (complexObserver & computed) --------------\n\n  /**\n   * Adds property effects for each argument in the method signature (and\n   * optionally, for the method name if `dynamic` is true) that calls the\n   * provided effect function.\n   *\n   * @param {Element | Object} model Prototype or instance\n   * @param {Object} sig Method signature metadata\n   * @param {string} type Type of property effect to add\n   * @param {Function} effectFn Function to run when arguments change\n   * @param {*=} methodInfo Effect-specific information to be included in\n   *   method effect metadata\n   * @param {Object=} dynamicFns Map indicating whether method names should\n   *   be included as a dependency to the effect. Note, defaults to true\n   *   if the signature is statci (sig.static is true).\n   * @private\n   */\n  function createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFns) {\n    let dynamicFn = sig.static || dynamicFns && dynamicFns[sig.methodName];\n    let info = {\n      methodName: sig.methodName,\n      args: sig.args,\n      methodInfo,\n      dynamicFn\n    };\n    for (let i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {\n      if (!arg.literal) {\n        model._addPropertyEffect(arg.rootProperty, type, {\n          fn: effectFn, info: info, trigger: arg\n        });\n      }\n    }\n    if (dynamicFn) {\n      model._addPropertyEffect(sig.methodName, type, {\n        fn: effectFn, info: info\n      });\n    }\n  }\n\n  /**\n   * Calls a method with arguments marshaled from properties on the instance\n   * based on the method signature contained in the effect metadata.\n   *\n   * Multi-property observers, computed properties, and inline computing\n   * functions call this function to invoke the method, then use the return\n   * value accordingly.\n   *\n   * @param {Object} inst The instance the effect will be run on\n   * @param {string} property Name of property\n   * @param {Object} props Bag of current property changes\n   * @param {Object} oldProps Bag of previous values for changed properties\n   * @param {Object} info Effect metadata\n   * @return {*} Returns the return value from the method invocation\n   * @private\n   */\n  function runMethodEffect(inst, property, props, oldProps, info) {\n    // Instances can optionally have a _methodHost which allows redirecting where\n    // to find methods. Currently used by `templatize`.\n    let context = inst._methodHost || inst;\n    let fn = context[info.methodName];\n    if (fn) {\n      let args = marshalArgs(inst.__data, info.args, property, props);\n      return fn.apply(context, args);\n    } else if (!info.dynamicFn) {\n      console.warn('method `' + info.methodName + '` not defined');\n    }\n  }\n\n  const emptyArray = [];\n\n  // Regular expressions used for binding\n  const IDENT  = '(?:' + '[a-zA-Z_$][\\\\w.:$\\\\-*]*' + ')';\n  const NUMBER = '(?:' + '[-+]?[0-9]*\\\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';\n  const SQUOTE_STRING = '(?:' + '\\'(?:[^\\'\\\\\\\\]|\\\\\\\\.)*\\'' + ')';\n  const DQUOTE_STRING = '(?:' + '\"(?:[^\"\\\\\\\\]|\\\\\\\\.)*\"' + ')';\n  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';\n  const ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\\\s*' + ')';\n  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\\\s*' + ARGUMENT + ')*' + ')';\n  const ARGUMENT_LIST = '(?:' + '\\\\(\\\\s*' +\n                                '(?:' + ARGUMENTS + '?' + ')' +\n                              '\\\\)\\\\s*' + ')';\n  const BINDING = '(' + IDENT + '\\\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3\n  const OPEN_BRACKET = '(\\\\[\\\\[|{{)' + '\\\\s*';\n  const CLOSE_BRACKET = '(?:]]|}})';\n  const NEGATE = '(?:(!)\\\\s*)?'; // Group 2\n  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;\n  const bindingRegex = new RegExp(EXPRESSION, \"g\");\n\n  function literalFromParts(parts) {\n    let s = '';\n    for (let i=0; i<parts.length; i++) {\n      let literal = parts[i].literal;\n      s += literal || '';\n    }\n    return s;\n  }\n\n  /**\n   * Parses an expression string for a method signature, and returns a metadata\n   * describing the method in terms of `methodName`, `static` (whether all the\n   * arguments are literals), and an array of `args`\n   *\n   * @param {string} expression The expression to parse\n   * @return {?Object} The method metadata object if a method expression was\n   *   found, otherwise `undefined`\n   * @private\n   */\n  function parseMethod(expression) {\n    // tries to match valid javascript property names\n    let m = expression.match(/([^\\s]+?)\\(([\\s\\S]*)\\)/);\n    if (m) {\n      let methodName = m[1];\n      let sig = { methodName, static: true };\n      if (m[2].trim()) {\n        // replace escaped commas with comma entity, split on un-escaped commas\n        let args = m[2].replace(/\\\\,/g, '&comma;').split(',');\n        return parseArgs(args, sig);\n      } else {\n        sig.args = emptyArray;\n        return sig;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Parses an array of arguments and sets the `args` property of the supplied\n   * signature metadata object. Sets the `static` property to false if any\n   * argument is a non-literal.\n   *\n   * @param {Array<string>} argList Array of argument names\n   * @param {Object} sig Method signature metadata object\n   * @return {Object} The updated signature metadata object\n   * @private\n   */\n  function parseArgs(argList, sig) {\n    sig.args = argList.map(function(rawArg) {\n      let arg = parseArg(rawArg);\n      if (!arg.literal) {\n        sig.static = false;\n      }\n      return arg;\n    }, this);\n    return sig;\n  }\n\n  /**\n   * Parses an individual argument, and returns an argument metadata object\n   * with the following fields:\n   *\n   *   {\n   *     value: 'prop',        // property/path or literal value\n   *     literal: false,       // whether argument is a literal\n   *     structured: false,    // whether the property is a path\n   *     rootProperty: 'prop', // the root property of the path\n   *     wildcard: false       // whether the argument was a wildcard '.*' path\n   *   }\n   *\n   * @param {string} rawArg The string value of the argument\n   * @return {Object} Argument metadata object\n   * @private\n   */\n  function parseArg(rawArg) {\n    // clean up whitespace\n    let arg = rawArg.trim()\n      // replace comma entity with comma\n      .replace(/&comma;/g, ',')\n      // repair extra escape sequences; note only commas strictly need\n      // escaping, but we allow any other char to be escaped since its\n      // likely users will do this\n      .replace(/\\\\(.)/g, '\\$1')\n      ;\n    // basic argument descriptor\n    let a = {\n      name: arg\n    };\n    // detect literal value (must be String or Number)\n    let fc = arg[0];\n    if (fc === '-') {\n      fc = arg[1];\n    }\n    if (fc >= '0' && fc <= '9') {\n      fc = '#';\n    }\n    switch(fc) {\n      case \"'\":\n      case '\"':\n        a.value = arg.slice(1, -1);\n        a.literal = true;\n        break;\n      case '#':\n        a.value = Number(arg);\n        a.literal = true;\n        break;\n    }\n    // if not literal, look for structured path\n    if (!a.literal) {\n      a.rootProperty = Polymer.Path.root(arg);\n      // detect structured path (has dots)\n      a.structured = Polymer.Path.isPath(arg);\n      if (a.structured) {\n        a.wildcard = (arg.slice(-2) == '.*');\n        if (a.wildcard) {\n          a.name = arg.slice(0, -2);\n        }\n      }\n    }\n    return a;\n  }\n\n  /**\n   * Gather the argument values for a method specified in the provided array\n   * of argument metadata.\n   *\n   * The `path` and `value` arguments are used to fill in wildcard descriptor\n   * when the method is being called as a result of a path notification.\n   *\n   * @param {Object} data Instance data storage object to read properties from\n   * @param {Array<Object>} args Array of argument metadata\n   * @param {string} path Property/path name that triggered the method effect\n   * @param {Object} props Bag of current property changes\n   * @return {Array<*>} Array of argument values\n   * @private\n   */\n  function marshalArgs(data, args, path, props) {\n    let values = [];\n    for (let i=0, l=args.length; i<l; i++) {\n      let arg = args[i];\n      let name = arg.name;\n      let v;\n      if (arg.literal) {\n        v = arg.value;\n      } else {\n        if (arg.structured) {\n          v = Polymer.Path.get(data, name);\n          // when data is not stored e.g. `splices`\n          if (v === undefined) {\n            v = props[name];\n          }\n        } else {\n          v = data[name];\n        }\n      }\n      if (arg.wildcard) {\n        // Only send the actual path changed info if the change that\n        // caused the observer to run matched the wildcard\n        let baseChanged = (name.indexOf(path + '.') === 0);\n        let matches = (path.indexOf(name) === 0 && !baseChanged);\n        values[i] = {\n          path: matches ? path : name,\n          value: matches ? props[path] : v,\n          base: v\n        };\n      } else {\n        values[i] = v;\n      }\n    }\n    return values;\n  }\n\n  // data api\n\n  /**\n   * Sends array splice notifications (`.splices` and `.length`)\n   *\n   * Note: this implementation only accepts normalized paths\n   *\n   * @param {Element} inst Instance to send notifications to\n   * @param {Array} array The array the mutations occurred on\n   * @param {string} path The path to the array that was mutated\n   * @param {Array} splices Array of splice records\n   * @private\n   */\n  function notifySplices(inst, array, path, splices) {\n    let splicesPath = path + '.splices';\n    inst.notifyPath(splicesPath, { indexSplices: splices });\n    inst.notifyPath(path + '.length', array.length);\n    // Null here to allow potentially large splice records to be GC'ed.\n    inst.__data[splicesPath] = {indexSplices: null};\n  }\n\n  /**\n   * Creates a splice record and sends an array splice notification for\n   * the described mutation\n   *\n   * Note: this implementation only accepts normalized paths\n   *\n   * @param {Element} inst Instance to send notifications to\n   * @param {Array} array The array the mutations occurred on\n   * @param {string} path The path to the array that was mutated\n   * @param {number} index Index at which the array mutation occurred\n   * @param {number} addedCount Number of added items\n   * @param {Array} removed Array of removed items\n   * @private\n   */\n  function notifySplice(inst, array, path, index, addedCount, removed) {\n    notifySplices(inst, array, path, [{\n      index: index,\n      addedCount: addedCount,\n      removed: removed,\n      object: array,\n      type: 'splice'\n    }]);\n  }\n\n  /**\n   * Returns an upper-cased version of the string.\n   *\n   * @param {string} name String to uppercase\n   * @return {string} Uppercased string\n   * @private\n   */\n  function upper(name) {\n    return name[0].toUpperCase() + name.substring(1);\n  }\n\n  /**\n   * Element class mixin that provides meta-programming for Polymer's template\n   * binding and data observation (collectively, \"property effects\") system.\n   *\n   * This mixin uses provides the following key methods for adding property effects\n   * to this element:\n   * - `_createPropertyObserver`\n   * - `_createMethodObserver`\n   * - `_createNotifyingProperty`\n   * - `_createReadOnlyProperty`\n   * - `_createReflectedProperty`\n   * - `_createComputedProperty`\n   * - `_bindTemplate`\n   *\n   * Each method creates one or more property accessors, along with metadata\n   * used by this mixin's implementation of `_propertiesChanged` to perform\n   * the property effects.  These methods may be called on element instances,\n   * but are designed to be called on element prototypes such that the work to\n   * set up accessors and effect metadata are done once per element class.\n   *\n   * Note that this mixin overrides several `PropertyAccessors` methods, in\n   * many cases to maintain guarantees provided by the Polymer 1.x features;\n   * notably it changes property accessors to be synchronous by default\n   * whereas the default when using `PropertyAccessors` standalone is to be\n   * async by default.\n   *\n   * @polymerMixin\n   * @mixes Polymer.TemplateStamp\n   * @mixes Polymer.PropertyAccessors\n   * @memberof Polymer\n   * @summary Element class mixin that provides meta-programming for Polymer's\n   * template binding and data observation system.\n   */\n  Polymer.PropertyEffects = Polymer.dedupingMixin(superClass => {\n\n    /**\n     * @constructor\n     * @extends {superClass}\n     * @implements {Polymer_PropertyAccessors}\n     * @implements {Polymer_TemplateStamp}\n     */\n    const propertyEffectsBase = Polymer.TemplateStamp(Polymer.PropertyAccessors(superClass));\n\n    /**\n     * @polymerMixinClass\n     * @unrestricted\n     * @implements {Polymer_PropertyEffects}\n     */\n    class PropertyEffects extends propertyEffectsBase {\n\n      get PROPERTY_EFFECT_TYPES() {\n        return TYPES;\n      }\n\n      /**\n       * Overrides `Polymer.PropertyAccessors` implementation to initialize\n       * additional property-effect related properties.\n       *\n       * @override\n       */\n      _initializeProperties() {\n        super._initializeProperties();\n        this.__dataClientsInitialized = false;\n        this.__dataPendingClients = null;\n        this.__dataToNotify = null;\n        this.__dataLinkedPaths = null;\n        this.__dataHasPaths = false;\n        // May be set on instance prior to upgrade\n        this.__dataCompoundStorage = this.__dataCompoundStorage || null;\n        this.__dataHost = this.__dataHost || null;\n        this.__dataTemp = {};\n      }\n\n      /**\n       * Overrides `Polymer.PropertyAccessors` implementation to provide a\n       * more efficient implementation of initializing properties from\n       * the prototype on the instance.\n       *\n       * @override\n       */\n      _initializeProtoProperties(props) {\n        this.__data = Object.create(props);\n        this.__dataPending = Object.create(props);\n        this.__dataOld = {};\n      }\n\n      /**\n       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting\n       * `_setProperty`'s `shouldNotify: true`.\n       *\n       * @override\n       */\n      _initializeInstanceProperties(props) {\n        let readOnly = this.__readOnly;\n        for (let prop in props) {\n          if (!readOnly || !readOnly[prop]) {\n            this.__dataPending = this.__dataPending || {};\n            this.__dataOld = this.__dataOld || {};\n            this.__data[prop] = this.__dataPending[prop] = props[prop];\n          }\n        }\n      }\n\n      // Prototype setup ----------------------------------------\n\n      /**\n       * Ensures an accessor exists for the specified property, and adds\n       * to a list of \"property effects\" that will run when the accessor for\n       * the specified property is set.  Effects are grouped by \"type\", which\n       * roughly corresponds to a phase in effect processing.  The effect\n       * metadata should be in the following form:\n       *\n       *   {\n       *     fn: effectFunction, // Reference to function to call to perform effect\n       *     info: { ... }       // Effect metadata passed to function\n       *     trigger: {          // Optional triggering metadata; if not provided\n       *       name: string      // the property is treated as a wildcard\n       *       structured: boolean\n       *       wildcard: boolean\n       *     }\n       *   }\n       *\n       * Effects are called from `_propertiesChanged` in the following order by\n       * type:\n       *\n       * 1. COMPUTE\n       * 2. PROPAGATE\n       * 3. REFLECT\n       * 4. OBSERVE\n       * 5. NOTIFY\n       *\n       * Effect functions are called with the following signature:\n       *\n       *   effectFunction(inst, path, props, oldProps, info, hasPaths)\n       *\n       * This method may be called either on the prototype of a class\n       * using the PropertyEffects mixin (for best performance), or on\n       * an instance to add dynamic effects.  When called on an instance or\n       * subclass of a class that has already had property effects added to\n       * its prototype, the property effect lists will be cloned and added as\n       * own properties of the caller.\n       *\n       * @param {string} property Property that should trigger the effect\n       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES\n       * @param {Object=} effect Effect metadata object\n       * @protected\n       */\n      _addPropertyEffect(property, type, effect) {\n        this._createPropertyAccessor(property, type == TYPES.READ_ONLY);\n        // effects are accumulated into arrays per property based on type\n        let effects = ensureOwnEffectMap(this, type)[property];\n        if (!effects) {\n          effects = this[type][property] = [];\n        }\n        effects.push(effect);\n      }\n\n      /**\n       * Removes the given property effect.\n       *\n       * @param {string} property Property the effect was associated with\n       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES\n       * @param {Object=} effect Effect metadata object to remove\n       */\n      _removePropertyEffect(property, type, effect) {\n        let effects = ensureOwnEffectMap(this, type)[property];\n        let idx = effects.indexOf(effect);\n        if (idx >= 0) {\n          effects.splice(idx, 1);\n        }\n      }\n\n      /**\n       * Returns whether the current prototype/instance has a property effect\n       * of a certain type.\n       *\n       * @param {string} property Property name\n       * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES\n       * @return {boolean} True if the prototype/instance has an effect of this type\n       * @protected\n       */\n      _hasPropertyEffect(property, type) {\n        let effects = this[type];\n        return Boolean(effects && effects[property]);\n      }\n\n      /**\n       * Returns whether the current prototype/instance has a \"read only\"\n       * accessor for the given property.\n       *\n       * @param {string} property Property name\n       * @return {boolean} True if the prototype/instance has an effect of this type\n       * @protected\n       */\n      _hasReadOnlyEffect(property) {\n        return this._hasPropertyEffect(property, TYPES.READ_ONLY);\n      }\n\n      /**\n       * Returns whether the current prototype/instance has a \"notify\"\n       * property effect for the given property.\n       *\n       * @param {string} property Property name\n       * @return {boolean} True if the prototype/instance has an effect of this type\n       * @protected\n       */\n      _hasNotifyEffect(property) {\n        return this._hasPropertyEffect(property, TYPES.NOTIFY);\n      }\n\n      /**\n       * Returns whether the current prototype/instance has a \"reflect to attribute\"\n       * property effect for the given property.\n       *\n       * @param {string} property Property name\n       * @return {boolean} True if the prototype/instance has an effect of this type\n       * @protected\n       */\n      _hasReflectEffect(property) {\n        return this._hasPropertyEffect(property, TYPES.REFLECT);\n      }\n\n      /**\n       * Returns whether the current prototype/instance has a \"computed\"\n       * property effect for the given property.\n       *\n       * @param {string} property Property name\n       * @return {boolean} True if the prototype/instance has an effect of this type\n       * @protected\n       */\n      _hasComputedEffect(property) {\n        return this._hasPropertyEffect(property, TYPES.COMPUTE);\n      }\n\n      // Runtime ----------------------------------------\n\n      /**\n       * Sets a pending property or path.  If the root property of the path in\n       * question had no accessor, the path is set, otherwise it is enqueued\n       * via `_setPendingProperty`.\n       *\n       * This function isolates relatively expensive functionality necessary\n       * for the public API (`set`, `setProperties`, `notifyPath`, and property\n       * change listeners via {{...}} bindings), such that it is only done\n       * when paths enter the system, and not at every propagation step.  It\n       * also sets a `__dataHasPaths` flag on the instance which is used to\n       * fast-path slower path-matching code in the property effects host paths.\n       *\n       * `path` can be a path string or array of path parts as accepted by the\n       * public API.\n       *\n       * @param {string | !Array<number|string>} path Path to set\n       * @param {*} value Value to set\n       * @param {boolean=} shouldNotify Set to true if this change should\n       *  cause a property notification event dispatch\n       * @param {boolean=} isPathNotification If the path being set is a path\n       *   notification of an already changed value, as opposed to a request\n       *   to set and notify the change.  In the latter `false` case, a dirty\n       *   check is performed and then the value is set to the path before\n       *   enqueuing the pending property change.\n       * @return {boolean} Returns true if the property/path was enqueued in\n       *   the pending changes bag.\n       * @protected\n       */\n      _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {\n        if (isPathNotification ||\n            Polymer.Path.root(Array.isArray(path) ? path[0] : path) !== path) {\n          // Dirty check changes being set to a path against the actual object,\n          // since this is the entry point for paths into the system; from here\n          // the only dirty checks are against the `__dataTemp` cache to prevent\n          // duplicate work in the same turn only. Note, if this was a notification\n          // of a change already set to a path (isPathNotification: true),\n          // we always let the change through and skip the `set` since it was\n          // already dirty checked at the point of entry and the underlying\n          // object has already been updated\n          if (!isPathNotification) {\n            let old = Polymer.Path.get(this, path);\n            path = /** @type {string} */ (Polymer.Path.set(this, path, value));\n            // Use property-accessor's simpler dirty check\n            if (!path || !super._shouldPropertyChange(path, value, old)) {\n              return false;\n            }\n          }\n          this.__dataHasPaths = true;\n          if (this._setPendingProperty(path, value, shouldNotify)) {\n            computeLinkedPaths(this, path, value);\n            return true;\n          }\n        } else {\n          if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {\n            return this._setPendingProperty(path, value, shouldNotify);\n          } else {\n            this[path] = value;\n          }\n        }\n        return false;\n      }\n\n      /**\n       * Applies a value to a non-Polymer element/node's property.\n       *\n       * The implementation makes a best-effort at binding interop:\n       * Some native element properties have side-effects when\n       * re-setting the same value (e.g. setting <input>.value resets the\n       * cursor position), so we do a dirty-check before setting the value.\n       * However, for better interop with non-Polymer custom elements that\n       * accept objects, we explicitly re-set object changes coming from the\n       * Polymer world (which may include deep object changes without the\n       * top reference changing), erring on the side of providing more\n       * information.\n       *\n       * Users may override this method to provide alternate approaches.\n       *\n       * @param {Node} node The node to set a property on\n       * @param {string} prop The property to set\n       * @param {*} value The value to set\n       * @protected\n       */\n      _setUnmanagedPropertyToNode(node, prop, value) {\n        // It is a judgment call that resetting primitives is\n        // \"bad\" and resettings objects is also \"good\"; alternatively we could\n        // implement a whitelist of tag & property values that should never\n        // be reset (e.g. <input>.value && <select>.value)\n        if (value !== node[prop] || typeof value == 'object') {\n          node[prop] = value;\n        }\n      }\n\n      /**\n       * Overrides the `PropertyAccessors` implementation to introduce special\n       * dirty check logic depending on the property & value being set:\n       *\n       * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})\n       *    Stored in `__dataTemp`, dirty checked against `__dataTemp`\n       * 2. Object set to simple property (e.g. 'prop': {...})\n       *    Stored in `__dataTemp` and `__data`, dirty checked against\n       *    `__dataTemp` by default implementation of `_shouldPropertyChange`\n       * 3. Primitive value set to simple property (e.g. 'prop': 42)\n       *    Stored in `__data`, dirty checked against `__data`\n       *\n       * The dirty-check is important to prevent cycles due to two-way\n       * notification, but paths and objects are only dirty checked against any\n       * previous value set during this turn via a \"temporary cache\" that is\n       * cleared when the last `_propertiesChaged` exits. This is so:\n       * a. any cached array paths (e.g. 'array.3.prop') may be invalidated\n       *    due to array mutations like shift/unshift/splice; this is fine\n       *    since path changes are dirty-checked at user entry points like `set`\n       * b. dirty-checking for objects only lasts one turn to allow the user\n       *    to mutate the object in-place and re-set it with the same identity\n       *    and have all sub-properties re-propagated in a subsequent turn.\n       *\n       * The temp cache is not necessarily sufficient to prevent invalid array\n       * paths, since a splice can happen during the same turn (with pathological\n       * user code); we could introduce a \"fixup\" for temporarily cached array\n       * paths if needed: https://github.com/Polymer/polymer/issues/4227\n       *\n       * @override\n       */\n      _setPendingProperty(property, value, shouldNotify) {\n        let isPath = this.__dataHasPaths && Polymer.Path.isPath(property);\n        let prevProps = isPath ? this.__dataTemp : this.__data;\n        if (this._shouldPropertyChange(property, value, prevProps[property])) {\n          if (!this.__dataPending) {\n            this.__dataPending = {};\n            this.__dataOld = {};\n          }\n          // Ensure old is captured from the last turn\n          if (!(property in this.__dataOld)) {\n            this.__dataOld[property] = this.__data[property];\n          }\n          // Paths are stored in temporary cache (cleared at end of turn),\n          // which is used for dirty-checking, all others stored in __data\n          if (isPath) {\n            this.__dataTemp[property] = value;\n          } else {\n            this.__data[property] = value;\n          }\n          // All changes go into pending property bag, passed to _propertiesChanged\n          this.__dataPending[property] = value;\n          // Track properties that should notify separately\n          if (isPath || (this.__notifyEffects && this.__notifyEffects[property])) {\n            this.__dataToNotify = this.__dataToNotify || {};\n            this.__dataToNotify[property] = shouldNotify;\n          }\n          return true;\n        }\n      }\n\n      /**\n       * Overrides base implementation to ensure all accessors set `shouldNotify`\n       * to true, for per-property notification tracking.\n       *\n       * @override\n       */\n      _setProperty(property, value) {\n        if (this._setPendingProperty(property, value, true)) {\n          this._invalidateProperties();\n        }\n      }\n\n      /**\n       * Overrides `PropertyAccessor`'s default async queuing of\n       * `_propertiesChanged`: if `__dataInitialized` is false (has not yet been\n       * manually flushed), the function no-ops; otherwise flushes\n       * `_propertiesChanged` synchronously.\n       *\n       * @override\n       */\n      _invalidateProperties() {\n        if (this.__dataInitialized) {\n          this._flushProperties();\n        }\n      }\n\n      /**\n       * Enqueues the given client on a list of pending clients, whose\n       * pending property changes can later be flushed via a call to\n       * `_flushClients`.\n       *\n       * @param {Object} client PropertyEffects client to enqueue\n       * @protected\n       */\n      _enqueueClient(client) {\n        this.__dataPendingClients = this.__dataPendingClients || [];\n        if (client !== this) {\n          this.__dataPendingClients.push(client);\n        }\n      }\n\n      /**\n       * Flushes any clients previously enqueued via `_enqueueClient`, causing\n       * their `_flushProperties` method to run.\n       *\n       * @protected\n       */\n      _flushClients() {\n        if (!this.__dataClientsInitialized) {\n          this._readyClients();\n        }\n        // Flush all clients\n        let clients = this.__dataPendingClients;\n        if (clients) {\n          this.__dataPendingClients = null;\n          for (let i=0; i < clients.length; i++) {\n            let client = clients[i];\n            if (!client.__dataInitialized || client.__dataPending) {\n              client._flushProperties();\n            }\n          }\n        }\n      }\n\n      /**\n       * Sets a bag of property changes to this instance, and\n       * synchronously processes all effects of the properties as a batch.\n       *\n       * Property names must be simple properties, not paths.  Batched\n       * path propagation is not supported.\n       *\n       * @param {Object} props Bag of one or more key-value pairs whose key is\n       *   a property and value is the new value to set for that property.\n       * @param {boolean=} setReadOnly When true, any private values set in\n       *   `props` will be set. By default, `setProperties` will not set\n       *   `readOnly: true` root properties.\n       * @public\n       */\n      setProperties(props, setReadOnly) {\n        for (let path in props) {\n          if (setReadOnly || !this.__readOnly || !this.__readOnly[path]) {\n            //TODO(kschaaf): explicitly disallow paths in setProperty?\n            // wildcard observers currently only pass the first changed path\n            // in the `info` object, and you could do some odd things batching\n            // paths, e.g. {'foo.bar': {...}, 'foo': null}\n            this._setPendingPropertyOrPath(path, props[path], true);\n          }\n        }\n        this._invalidateProperties();\n      }\n\n      /**\n       * Overrides `PropertyAccessors` to call `_readyClients` callback\n       * if it was not called as a result of flushing properties.\n       *\n       * @override\n       */\n      ready() {\n        super.ready();\n        if (!this.__dataClientsInitialized) {\n          this._readyClients();\n        }\n      }\n\n      /**\n       * Perform any initial setup on client dom. Called before the first\n       * `_flushProperties` call on client dom and before any element\n       * observers are called.\n       *\n       * @protected\n       */\n      _readyClients() {\n        this.__dataClientsInitialized = true;\n      }\n\n      /**\n       * Implements `PropertyAccessors`'s properties changed callback.\n       *\n       * Runs each class of effects for the batch of changed properties in\n       * a specific order (compute, propagate, reflect, observe, notify).\n       *\n       * @override\n       */\n      _propertiesChanged(currentProps, changedProps, oldProps) {\n        // ----------------------------\n        // let c = Object.getOwnPropertyNames(changedProps || {});\n        // window.debug && console.group(this.localName + '#' + this.id + ': ' + c);\n        // if (window.debug) { debugger; }\n        // ----------------------------\n        let hasPaths = this.__dataHasPaths;\n        this.__dataHasPaths = false;\n        // Compute properties\n        runComputedEffects(this, changedProps, oldProps, hasPaths);\n        // Clear notify properties prior to possible reentry (propagate, observe),\n        // but after computing effects have a chance to add to them\n        let notifyProps = this.__dataToNotify;\n        this.__dataToNotify = null;\n        // Propagate properties to clients\n        this._propagatePropertyChanges(changedProps, oldProps, hasPaths);\n        // Flush clients\n        this._flushClients();\n        // Reflect properties\n        runEffects(this, this.__reflectEffects, changedProps, oldProps, hasPaths);\n        // Observe properties\n        runEffects(this, this.__observeEffects, changedProps, oldProps, hasPaths);\n        // Notify properties to host\n        if (notifyProps) {\n          runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);\n        }\n        // Clear temporary cache at end of turn\n        if (this.__dataCounter == 1) {\n          this.__dataTemp = {};\n        }\n        // ----------------------------\n        // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);\n        // ----------------------------\n      }\n\n      /**\n       * Called to propagate any property changes to stamped template nodes\n       * managed by this element.\n       *\n       * @param {Object} changedProps Bag of changed properties\n       * @param {Object} oldProps Bag of previous values for changed properties\n       * @param {boolean} hasPaths True with `props` contains one or more paths\n       * @protected\n       */\n      _propagatePropertyChanges(changedProps, oldProps, hasPaths) {\n        if (this.__propagateEffects) {\n          runEffects(this, this.__propagateEffects, changedProps, oldProps, hasPaths);\n        }\n        let templateInfo = this.__templateInfo;\n        while (templateInfo) {\n          runEffects(this, templateInfo.propertyEffects, changedProps, oldProps,\n            hasPaths, templateInfo.nodeList);\n          templateInfo = templateInfo.nextTemplateInfo;\n        }\n      }\n\n      /**\n       * Aliases one data path as another, such that path notifications from one\n       * are routed to the other.\n       *\n       * @param {string | !Array<string|number>} to Target path to link.\n       * @param {string | !Array<string|number>} from Source path to link.\n       * @public\n       */\n      linkPaths(to, from) {\n        to = Polymer.Path.normalize(to);\n        from = Polymer.Path.normalize(from);\n        this.__dataLinkedPaths = this.__dataLinkedPaths || {};\n        this.__dataLinkedPaths[to] = from;\n      }\n\n      /**\n       * Removes a data path alias previously established with `_linkPaths`.\n       *\n       * Note, the path to unlink should be the target (`to`) used when\n       * linking the paths.\n       *\n       * @param {string | !Array<string|number>} path Target path to unlink.\n       * @public\n       */\n      unlinkPaths(path) {\n        path = Polymer.Path.normalize(path);\n        if (this.__dataLinkedPaths) {\n          delete this.__dataLinkedPaths[path];\n        }\n      }\n\n      /**\n       * Notify that an array has changed.\n       *\n       * Example:\n       *\n       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];\n       *     ...\n       *     this.items.splice(1, 1, {name: 'Sam'});\n       *     this.items.push({name: 'Bob'});\n       *     this.notifySplices('items', [\n       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, obect: this.items, type: 'splice' },\n       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}\n       *     ]);\n       *\n       * @param {string} path Path that should be notified.\n       * @param {Array} splices Array of splice records indicating ordered\n       *   changes that occurred to the array. Each record should have the\n       *   following fields:\n       *    * index: index at which the change occurred\n       *    * removed: array of items that were removed from this index\n       *    * addedCount: number of new items added at this index\n       *    * object: a reference to the array in question\n       *    * type: the string literal 'splice'\n       *\n       *   Note that splice records _must_ be normalized such that they are\n       *   reported in index order (raw results from `Object.observe` are not\n       *   ordered and must be normalized/merged before notifying).\n       * @public\n      */\n      notifySplices(path, splices) {\n        let info = {};\n        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));\n        notifySplices(this, array, info.path, splices);\n      }\n\n      /**\n       * Convenience method for reading a value from a path.\n       *\n       * Note, if any part in the path is undefined, this method returns\n       * `undefined` (this method does not throw when dereferencing undefined\n       * paths).\n       *\n       * @param {(string|!Array<(string|number)>)} path Path to the value\n       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)\n       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that\n       *   bracketed expressions are not supported; string-based path parts\n       *   *must* be separated by dots.  Note that when dereferencing array\n       *   indices, the index may be used as a dotted part directly\n       *   (e.g. `users.12.name` or `['users', 12, 'name']`).\n       * @param {Object=} root Root object from which the path is evaluated.\n       * @return {*} Value at the path, or `undefined` if any part of the path\n       *   is undefined.\n       * @public\n       */\n      get(path, root) {\n        return Polymer.Path.get(root || this, path);\n      }\n\n      /**\n       * Convenience method for setting a value to a path and notifying any\n       * elements bound to the same path.\n       *\n       * Note, if any part in the path except for the last is undefined,\n       * this method does nothing (this method does not throw when\n       * dereferencing undefined paths).\n       *\n       * @param {(string|!Array<(string|number)>)} path Path to the value\n       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)\n       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that\n       *   bracketed expressions are not supported; string-based path parts\n       *   *must* be separated by dots.  Note that when dereferencing array\n       *   indices, the index may be used as a dotted part directly\n       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).\n       * @param {*} value Value to set at the specified path.\n       * @param {Object=} root Root object from which the path is evaluated.\n       *   When specified, no notification will occur.\n       * @public\n      */\n      set(path, value, root) {\n        if (root) {\n          Polymer.Path.set(root, path, value);\n        } else {\n          if (!this.__readOnly || !this.__readOnly[/** @type {string} */(path)]) {\n            if (this._setPendingPropertyOrPath(path, value, true)) {\n              this._invalidateProperties();\n            }\n          }\n        }\n      }\n\n      /**\n       * Adds items onto the end of the array at the path specified.\n       *\n       * The arguments after `path` and return value match that of\n       * `Array.prototype.push`.\n       *\n       * This method notifies other paths to the same array that a\n       * splice occurred to the array.\n       *\n       * @param {string} path Path to array.\n       * @param {...*} items Items to push onto array\n       * @return {number} New length of the array.\n       * @public\n       */\n      push(path, ...items) {\n        let info = {};\n        let array = /** @type {Array}*/(Polymer.Path.get(this, path, info));\n        let len = array.length;\n        let ret = array.push(...items);\n        if (items.length) {\n          notifySplice(this, array, info.path, len, items.length, []);\n        }\n        return ret;\n      }\n\n      /**\n       * Removes an item from the end of array at the path specified.\n       *\n       * The arguments after `path` and return value match that of\n       * `Array.prototype.pop`.\n       *\n       * This method notifies other paths to the same array that a\n       * splice occurred to the array.\n       *\n       * @param {string} path Path to array.\n       * @return {*} Item that was removed.\n       * @public\n       */\n      pop(path) {\n        let info = {};\n        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));\n        let hadLength = Boolean(array.length);\n        let ret = array.pop();\n        if (hadLength) {\n          notifySplice(this, array, info.path, array.length, 0, [ret]);\n        }\n        return ret;\n      }\n\n      /**\n       * Starting from the start index specified, removes 0 or more items\n       * from the array and inserts 0 or more new items in their place.\n       *\n       * The arguments after `path` and return value match that of\n       * `Array.prototype.splice`.\n       *\n       * This method notifies other paths to the same array that a\n       * splice occurred to the array.\n       *\n       * @param {string} path Path to array.\n       * @param {number} start Index from which to start removing/inserting.\n       * @param {number} deleteCount Number of items to remove.\n       * @param {...*} items Items to insert into array.\n       * @return {Array} Array of removed items.\n       * @public\n       */\n      splice(path, start, deleteCount, ...items) {\n        let info = {};\n        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));\n        // Normalize fancy native splice handling of crazy start values\n        if (start < 0) {\n          start = array.length - Math.floor(-start);\n        } else {\n          start = Math.floor(start);\n        }\n        if (!start) {\n          start = 0;\n        }\n        let ret = array.splice(start, deleteCount, ...items);\n        if (items.length || ret.length) {\n          notifySplice(this, array, info.path, start, items.length, ret);\n        }\n        return ret;\n      }\n\n      /**\n       * Removes an item from the beginning of array at the path specified.\n       *\n       * The arguments after `path` and return value match that of\n       * `Array.prototype.pop`.\n       *\n       * This method notifies other paths to the same array that a\n       * splice occurred to the array.\n       *\n       * @param {string} path Path to array.\n       * @return {*} Item that was removed.\n       * @public\n       */\n      shift(path) {\n        let info = {};\n        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));\n        let hadLength = Boolean(array.length);\n        let ret = array.shift();\n        if (hadLength) {\n          notifySplice(this, array, info.path, 0, 0, [ret]);\n        }\n        return ret;\n      }\n\n      /**\n       * Adds items onto the beginning of the array at the path specified.\n       *\n       * The arguments after `path` and return value match that of\n       * `Array.prototype.push`.\n       *\n       * This method notifies other paths to the same array that a\n       * splice occurred to the array.\n       *\n       * @param {string} path Path to array.\n       * @param {...*} items Items to insert info array\n       * @return {number} New length of the array.\n       * @public\n       */\n      unshift(path, ...items) {\n        let info = {};\n        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));\n        let ret = array.unshift(...items);\n        if (items.length) {\n          notifySplice(this, array, info.path, 0, items.length, []);\n        }\n        return ret;\n      }\n\n      /**\n       * Notify that a path has changed.\n       *\n       * Example:\n       *\n       *     this.item.user.name = 'Bob';\n       *     this.notifyPath('item.user.name');\n       *\n       * @param {string} path Path that should be notified.\n       * @param {*=} value Value at the path (optional).\n       * @public\n      */\n      notifyPath(path, value) {\n        /** @type {string} */\n        let propPath;\n        if (arguments.length == 1) {\n          // Get value if not supplied\n          let info = {};\n          value = Polymer.Path.get(this, path, info);\n          propPath = info.path;\n        } else if (Array.isArray(path)) {\n          // Normalize path if needed\n          propPath = Polymer.Path.normalize(path);\n        } else {\n          propPath = /** @type{string} */(path);\n        }\n        if (this._setPendingPropertyOrPath(propPath, value, true, true)) {\n          this._invalidateProperties();\n        }\n      }\n\n      /**\n       * Creates a read-only accessor for the given property.\n       *\n       * To set the property, use the protected `_setProperty` API.\n       * To create a custom protected setter (e.g. `_setMyProp()` for\n       * property `myProp`), pass `true` for `protectedSetter`.\n       *\n       * Note, if the property will have other property effects, this method\n       * should be called first, before adding other effects.\n       *\n       * @param {string} property Property name\n       * @param {boolean=} protectedSetter Creates a custom protected setter\n       *   when `true`.\n       * @protected\n       */\n      _createReadOnlyProperty(property, protectedSetter) {\n        this._addPropertyEffect(property, TYPES.READ_ONLY);\n        if (protectedSetter) {\n          this['_set' + upper(property)] = function(value) {\n            this._setProperty(property, value);\n          }\n        }\n      }\n\n      /**\n       * Creates a single-property observer for the given property.\n       *\n       * @param {string} property Property name\n       * @param {string} methodName Name of observer method to call\n       * @param {boolean=} dynamicFn Whether the method name should be included as\n       *   a dependency to the effect.\n       * @protected\n       */\n      _createPropertyObserver(property, methodName, dynamicFn) {\n        let info = { property, methodName };\n        this._addPropertyEffect(property, TYPES.OBSERVE, {\n          fn: runObserverEffect, info, trigger: {name: property}\n        });\n        if (dynamicFn) {\n          this._addPropertyEffect(methodName, TYPES.OBSERVE, {\n            fn: runObserverEffect, info, trigger: {name: methodName}\n          });\n        }\n      }\n\n      /**\n       * Creates a multi-property \"method observer\" based on the provided\n       * expression, which should be a string in the form of a normal Javascript\n       * function signature: `'methodName(arg1, [..., argn])'`.  Each argument\n       * should correspond to a property or path in the context of this\n       * prototype (or instance), or may be a literal string or number.\n       *\n       * @param {string} expression Method expression\n       * @param {Object=} dynamicFns Map indicating whether method names should\n       *   be included as a dependency to the effect.\n       * @protected\n       */\n      _createMethodObserver(expression, dynamicFns) {\n        let sig = parseMethod(expression);\n        if (!sig) {\n          throw new Error(\"Malformed observer expression '\" + expression + \"'\");\n        }\n        createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFns);\n      }\n\n      /**\n       * Causes the setter for the given property to dispatch `<property>-changed`\n       * events to notify of changes to the property.\n       *\n       * @param {string} property Property name\n       * @protected\n       */\n      _createNotifyingProperty(property) {\n        this._addPropertyEffect(property, TYPES.NOTIFY, {\n          fn: runNotifyEffect,\n          info: {\n            eventName: CaseMap.camelToDashCase(property) + '-changed',\n            property: property\n          }\n        });\n      }\n\n      /**\n       * Causes the setter for the given property to reflect the property value\n       * to a (dash-cased) attribute of the same name.\n       *\n       * @param {string} property Property name\n       * @protected\n       */\n      _createReflectedProperty(property) {\n        let attr = CaseMap.camelToDashCase(property);\n        if (attr[0] === '-') {\n          console.warn('Property ' + property + ' cannot be reflected to attribute ' +\n            attr + ' because \"-\" is not a valid starting attribute name. Use a lowercase first letter for the property thisead.');\n        } else {\n          this._addPropertyEffect(property, TYPES.REFLECT, {\n            fn: runReflectEffect,\n            info: {\n              attrName: attr\n            }\n          });\n        }\n      }\n\n      /**\n       * Creates a computed property whose value is set to the result of the\n       * method described by the given `expression` each time one or more\n       * arguments to the method changes.  The expression should be a string\n       * in the form of a normal Javascript function signature:\n       * `'methodName(arg1, [..., argn])'`\n       *\n       * @param {string} property Name of computed property to set\n       * @param {string} expression Method expression\n       * @param {Object=} dynamicFns Map indicating whether method names should\n       *   be included as a dependency to the effect.\n       * @protected\n       */\n      _createComputedProperty(property, expression, dynamicFns) {\n        let sig = parseMethod(expression);\n        if (!sig) {\n          throw new Error(\"Malformed computed expression '\" + expression + \"'\");\n        }\n        createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFns);\n      }\n\n      // -- binding ----------------------------------------------\n\n      /**\n       * Parses the provided template to ensure binding effects are created\n       * for them, and then ensures property accessors are created for any\n       * dependent properties in the template.  Binding effects for bound\n       * templates are stored in a linked list on the instance so that\n       * templates can be efficiently stamped and unstamped.\n       *\n       * This method may be called on the prototype (for prototypical template\n       * binding, to avoid creating accessors every instance) once per prototype,\n       * and will be called with `runtimeBinding: true` by `_stampTemplate` to\n       * create and link an instance of the template metadata associated with a\n       * particular stamping.\n       *\n       * @param {HTMLTemplateElement} template Template containing binding\n       *   bindings\n       * @param {boolean=} instanceBinding When false (default), performs\n       *   \"prototypical\" binding of the template and overwrites any previously\n       *   bound template for the class. When true (as passed from\n       *   `_stampTemplate`), the template info is instanced and linked into\n       *   the list of bound templates.\n       * @return {Object} Template metadata object; for `runtimeBinding`,\n       *   this is an instance of the prototypical template info\n       * @protected\n       */\n      _bindTemplate(template, instanceBinding) {\n        let templateInfo = this.constructor._parseTemplate(template);\n        let wasPreBound = this.__templateInfo == templateInfo;\n        // Optimization: since this is called twice for proto-bound templates,\n        // don't attempt to recreate accessors if this template was pre-bound\n        if (!wasPreBound) {\n          for (let prop in templateInfo.propertyEffects) {\n            this._createPropertyAccessor(prop);\n          }\n        }\n        if (instanceBinding) {\n          // For instance-time binding, create instance of template metadata\n          // and link into list of templates if necessary\n          templateInfo = Object.create(templateInfo);\n          templateInfo.wasPreBound = wasPreBound;\n          if (!wasPreBound && this.__templateInfo) {\n            templateInfo.nextTemplateInfo = this.__templateInfo;\n            this.__templateInfo.previousTemplateInfo = templateInfo;\n          }\n        }\n        return this.__templateInfo = templateInfo;\n      }\n\n      /**\n       * Adds a property effect to the given template metadata, which is run\n       * at the \"propagate\" stage of `_propertiesChanged` when the template\n       * has been bound to the element via `_bindTemplate`.\n       *\n       * The `effect` object should match the format in `_addPropertyEffect`.\n       *\n       * @param {Object} templateInfo Template metadata to add effect to\n       * @param {string} prop Property that should trigger the effect\n       * @param {Object=} effect Effect metadata object\n       * @protected\n       */\n      static _addTemplatePropertyEffect(templateInfo, prop, effect) {\n        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};\n        hostProps[prop] = true;\n        let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};\n        let propEffects = effects[prop] = effects[prop] || [];\n        propEffects.push(effect);\n      }\n\n      /**\n       * Stamps the provided template and performs instance-time setup for\n       * Polymer template features, including data bindings, declarative event\n       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment\n       * is returned containing the stamped DOM, ready for insertion into the\n       * DOM.\n       *\n       * This method may be called more than once; however note that due to\n       * `shadycss` polyfill limitations, only styles from templates prepared\n       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped\n       * to the shadow root and support CSS custom properties), and note that\n       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,\n       * any styles required by in runtime-stamped templates must be included\n       * in the main element template.\n       *\n       * @param {HTMLTemplateElement} template Template to stamp\n       * @return {DocumentFragment} Cloned template content\n       * @protected\n       */\n      _stampTemplate(template) {\n        let dom = super._stampTemplate(template);\n        let templateInfo = this._bindTemplate(template, true);\n        // Add template-instance-specific data to instanced templateInfo\n        templateInfo.nodeList = dom.nodeList;\n        // Capture child nodes to allow unstamping of non-prototypical templates\n        if (!templateInfo.wasPreBound) {\n          let nodes = templateInfo.childNodes = [];\n          for (let n=dom.firstChild; n; n=n.nextSibling) {\n            nodes.push(n);\n          }\n        }\n        dom.templateInfo = templateInfo;\n        // Setup compound storage, 2-way listeners, and dataHost for bindings\n        setupBindings(this, templateInfo);\n        // Flush properties into template nodes if already booted\n        if (this.__dataInitialized) {\n          runEffects(this, templateInfo.propertyEffects, this.__data, null,\n            false, templateInfo.nodeList);\n        }\n        return dom;\n      }\n\n      /**\n       * Removes and unbinds the nodes previously contained in the provided\n       * DocumentFragment returned from `_stampTemplate`.\n       *\n       * @param {DocumentFragment} dom DocumentFragment previously returned\n       *   from `_stampTemplate` associated with the nodes to be removed\n       * @protected\n       */\n      _removeBoundDom(dom) {\n        // Unlink template info\n        let templateInfo = dom.templateInfo;\n        if (templateInfo.previousTemplateInfo) {\n          templateInfo.previousTemplateInfo.nextTemplateInfo =\n            templateInfo.nextTemplateInfo;\n        }\n        if (templateInfo.nextTemplateInfo) {\n          templateInfo.nextTemplateInfo.previousTemplateInfo =\n            templateInfo.previousTemplateInfo;\n        }\n        // Remove stamped nodes\n        let nodes = templateInfo.childNodes;\n        for (let i=0; i<nodes.length; i++) {\n          let node = nodes[i];\n          node.parentNode.removeChild(node);\n        }\n      }\n\n      /**\n       * Overrides default `TemplateStamp` implementation to add support for\n       * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`\n       * array is added to `nodeInfo` and populated with binding metadata\n       * with information capturing the binding target, and a `parts` array\n       * with one or more metadata objects capturing the source(s) of the\n       * binding.\n       *\n       * @override\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template node\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       * @protected\n       */\n      static _parseTemplateNode(node, templateInfo, nodeInfo) {\n        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);\n        if (node.nodeType === Node.TEXT_NODE) {\n          let parts = this._parseBindings(node.textContent, templateInfo);\n          if (parts) {\n            // Initialize the textContent with any literal parts\n            // NOTE: default to a space here so the textNode remains; some browsers\n            // (IE) evacipate an empty textNode following cloneNode/importNode.\n            node.textContent = literalFromParts(parts) || ' ';\n            addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);\n            noted = true;\n          }\n        }\n        return noted;\n      }\n\n      /**\n       * Overrides default `TemplateStamp` implementation to add support for\n       * parsing bindings from attributes.  A `bindings`\n       * array is added to `nodeInfo` and populated with binding metadata\n       * with information capturing the binding target, and a `parts` array\n       * with one or more metadata objects capturing the source(s) of the\n       * binding.\n       *\n       * @override\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template node\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       * @protected\n       */\n      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {\n        let parts = this._parseBindings(value, templateInfo);\n        if (parts) {\n          // Attribute or property\n          let origName = name;\n          let kind = 'property';\n          if (name[name.length-1] == '$') {\n            name = name.slice(0, -1);\n            kind = 'attribute';\n          }\n          // Initialize attribute bindings with any literal parts\n          let literal = literalFromParts(parts);\n          if (literal && kind == 'attribute') {\n            node.setAttribute(name, literal);\n          }\n          // Clear attribute before removing, since IE won't allow removing\n          // `value` attribute if it previously had a value (can't\n          // unconditionally set '' before removing since attributes with `$`\n          // can't be set using setAttribute)\n          if (node.localName === 'input' && origName === 'value') {\n            node.setAttribute(origName, '');\n          }\n          // Remove annotation\n          node.removeAttribute(origName);\n          // Case hackery: attributes are lower-case, but bind targets\n          // (properties) are case sensitive. Gambit is to map dash-case to\n          // camel-case: `foo-bar` becomes `fooBar`.\n          // Attribute bindings are excepted.\n          if (kind === 'property') {\n            name = Polymer.CaseMap.dashToCamelCase(name);\n          }\n          addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);\n          return true;\n        } else {\n          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);\n        }\n      }\n\n      /**\n       * Overrides default `TemplateStamp` implementation to add support for\n       * binding the properties that a nested template depends on to the template\n       * as `_host_<property>`.\n       *\n       * @override\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template node\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       * @protected\n       */\n      static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {\n        let noted = super._parseTemplateNestedTemplate(node, templateInfo, nodeInfo);\n        // Merge host props into outer template and add bindings\n        let hostProps = nodeInfo.templateInfo.hostProps;\n        let mode = '{';\n        for (let source in hostProps) {\n          let parts = [{ mode, source, dependencies: [source] }];\n          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);\n        }\n        return noted;\n      }\n\n      /**\n       * Called to parse text in a template (either attribute values or\n       * textContent) into binding metadata.\n       *\n       * Any overrides of this method should return an array of binding part\n       * metadata  representing one or more bindings found in the provided text\n       * and any \"literal\" text in between.  Any non-literal parts will be passed\n       * to `_evaluateBinding` when any dependencies change.  The only required\n       * fields of each \"part\" in the returned array are as follows:\n       *\n       * - `dependencies` - Array containing trigger metadata for each property\n       *   that should trigger the binding to update\n       * - `literal` - String containing text if the part represents a literal;\n       *   in this case no `dependencies` are needed\n       *\n       * Additional metadata for use by `_evaluateBinding` may be provided in\n       * each part object as needed.\n       *\n       * The default implementation handles the following types of bindings\n       * (one or more may be intermixed with literal strings):\n       * - Property binding: `[[prop]]`\n       * - Path binding: `[[object.prop]]`\n       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`\n       * - Two-way property or path bindings (supports negation):\n       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`\n       * - Inline computed method (supports negation):\n       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`\n       *\n       * @param {string} text Text to parse from attribute or textContent\n       * @param {Object} templateInfo Current template metadata\n       * @return {Array<Object>} Array of binding part metadata\n       * @protected\n       */\n      static _parseBindings(text, templateInfo) {\n        let parts = [];\n        let lastIndex = 0;\n        let m;\n        // Example: \"literal1{{prop}}literal2[[!compute(foo,bar)]]final\"\n        // Regex matches:\n        //        Iteration 1:  Iteration 2:\n        // m[1]: '{{'          '[['\n        // m[2]: ''            '!'\n        // m[3]: 'prop'        'compute(foo,bar)'\n        while ((m = bindingRegex.exec(text)) !== null) {\n          // Add literal part\n          if (m.index > lastIndex) {\n            parts.push({literal: text.slice(lastIndex, m.index)});\n          }\n          // Add binding part\n          let mode = m[1][0];\n          let negate = Boolean(m[2]);\n          let source = m[3].trim();\n          let customEvent, notifyEvent, colon;\n          if (mode == '{' && (colon = source.indexOf('::')) > 0) {\n            notifyEvent = source.substring(colon + 2);\n            source = source.substring(0, colon);\n            customEvent = true;\n          }\n          let signature = parseMethod(source);\n          let dependencies = [];\n          if (signature) {\n            // Inline computed function\n            let {args, methodName} = signature;\n            for (let i=0; i<args.length; i++) {\n              let arg = args[i];\n              if (!arg.literal) {\n                dependencies.push(arg);\n              }\n            }\n            let dynamicFns = templateInfo.dynamicFns;\n            if (dynamicFns && dynamicFns[methodName] || signature.static) {\n              dependencies.push(methodName);\n            }\n          } else {\n            // Property or path\n            dependencies.push(source);\n          }\n          parts.push({\n            source, mode, negate, customEvent, signature, dependencies,\n            event: notifyEvent\n          });\n          lastIndex = bindingRegex.lastIndex;\n        }\n        // Add a final literal part\n        if (lastIndex && lastIndex < text.length) {\n          let literal = text.substring(lastIndex);\n          if (literal) {\n            parts.push({\n              literal: literal\n            });\n          }\n        }\n        if (parts.length) {\n          return parts;\n        }\n      }\n\n      /**\n       * Called to evaluate a previously parsed binding part based on a set of\n       * one or more changed dependencies.\n       *\n       * @param {HTMLElement} inst Element that should be used as scope for\n       *   binding dependencies\n       * @param {Object} part Binding part metadata\n       * @param {string} path Property/path that triggered this effect\n       * @param {Object} props Bag of current property changes\n       * @param {Object} oldProps Bag of previous values for changed properties\n       * @param {boolean} hasPaths True with `props` contains one or more paths\n       * @return {*} Value the binding part evaluated to\n       * @protected\n       */\n      static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {\n        let value;\n        if (part.signature) {\n          value = runMethodEffect(inst, path, props, oldProps, part.signature);\n        } else if (path != part.source) {\n          value = Polymer.Path.get(inst, part.source);\n        } else {\n          if (hasPaths && Polymer.Path.isPath(path)) {\n            value = Polymer.Path.get(inst, path);\n          } else {\n            value = inst.__data[path];\n          }\n        }\n        if (part.negate) {\n          value = !value;\n        }\n        return value;\n      }\n\n    }\n\n    return PropertyEffects;\n  });\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/mixins/property-effects.html\n// module id = 8\n// module chunks = 0","/*__wc__loader*/\nrequire('../utils/boot.html');\n\nrequire('../utils/mixin.html');\n\n\n(function() {\n\n  'use strict';\n\n  // 1.x backwards-compatible auto-wrapper for template type extensions\n  // This is a clear layering violation and gives favored-nation status to\n  // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep\n  // a.) to ease 1.x backwards-compatibility due to loss of `is`, and\n  // b.) to maintain if/repeat capability in parser-constrained elements\n  //     (e.g. table, select) in lieu of native CE type extensions without\n  //     massive new invention in this space (e.g. directive system)\n  const templateExtensions = {\n    'dom-if': true,\n    'dom-repeat': true\n  };\n  function wrapTemplateExtension(node) {\n    let is = node.getAttribute('is');\n    if (is && templateExtensions[is]) {\n      let t = node;\n      t.removeAttribute('is');\n      node = t.ownerDocument.createElement(is);\n      t.parentNode.replaceChild(node, t);\n      node.appendChild(t);\n      while(t.attributes.length) {\n        node.setAttribute(t.attributes[0].name, t.attributes[0].value);\n        t.removeAttribute(t.attributes[0].name);\n      }\n    }\n    return node;\n  }\n\n  function findTemplateNode(root, nodeInfo) {\n    // recursively ascend tree until we hit root\n    let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);\n    // unwind the stack, returning the indexed node at each level\n    if (parent) {\n      // note: marginally faster than indexing via childNodes\n      // (http://jsperf.com/childnodes-lookup)\n      for (let n=parent.firstChild, i=0; n; n=n.nextSibling) {\n        if (nodeInfo.parentIndex === i++) {\n          return n;\n        }\n      }\n    } else {\n      return root;\n    }\n  }\n\n  // construct `$` map (from id annotations)\n  function applyIdToMap(inst, map, node, nodeInfo) {\n    if (nodeInfo.id) {\n      map[nodeInfo.id] = node;\n    }\n  }\n\n  // install event listeners (from event annotations)\n  function applyEventListener(inst, node, nodeInfo) {\n    if (nodeInfo.events && nodeInfo.events.length) {\n      for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {\n        inst._addMethodEventListenerToNode(node, e.name, e.value, inst);\n      }\n    }\n  }\n\n  // push configuration references at configure time\n  function applyTemplateContent(inst, node, nodeInfo) {\n    if (nodeInfo.templateInfo) {\n      node._templateInfo = nodeInfo.templateInfo;\n    }\n  }\n\n  function createNodeEventHandler(context, eventName, methodName) {\n    // Instances can optionally have a _methodHost which allows redirecting where\n    // to find methods. Currently used by `templatize`.\n    context = context._methodHost || context;\n    let handler = function(e) {\n      if (context[methodName]) {\n        context[methodName](e, e.detail);\n      } else {\n        console.warn('listener method `' + methodName + '` not defined');\n      }\n    };\n    return handler;\n  }\n\n  /**\n   * Element mixin that provides basic template parsing and stamping, including\n   * the following template-related features for stamped templates:\n   *\n   * - Declarative event listeners (`on-eventname=\"listener\"`)\n   * - Map of node id's to stamped node instances (`this.$.id`)\n   * - Nested template content caching/removal and re-installation (performance\n   *   optimization)\n   *\n   * @polymerMixin\n   * @memberof Polymer\n   * @summary Element class mixin that provides basic template parsing and stamping\n   */\n  Polymer.TemplateStamp = Polymer.dedupingMixin(superClass => {\n\n    /**\n     * @polymerMixinClass\n     * @implements {Polymer_TemplateStamp}\n     */\n    class TemplateStamp extends superClass {\n\n      _initializeProperties() {\n        super._initializeProperties();\n        this.$ = null;\n      }\n\n      /**\n       * Scans a template to produce template metadata.\n       *\n       * Template-specific metadata are stored in the object returned, and node-\n       * specific metadata are stored in objects in its flattened `nodeInfoList`\n       * array.  Only nodes in the template that were parsed as nodes of\n       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object\n       * contains an `index` (`childNodes` index in parent) and optionally\n       * `parent`, which points to node info of its parent (including its index).\n       *\n       * The template metadata object returned from this method has the following\n       * structure (many fields optional):\n       *\n       *   {\n       *     // Flattened list of node metadata (for nodes that generated metadata)\n       *     nodeInfoList: [\n       *       {\n       *         // `id` attribute for any nodes with id's for generating `$` map\n       *         id: '<id>',\n       *         // `on-event=\"handler\"` metadata\n       *         events: [\n       *           {\n       *             name: '<name>'\n       *             value: '<handler name>'\n       *           }, ...\n       *         ],\n       *         // Notes when the template contained a `<slot>` for shady DOM\n       *         // optimization purposes\n       *         hasInsertionPoint: <boolean>,\n       *         // For nested <template> nodes, nested template metadata\n       *         templateInfo: <nested template metadata>,\n       *         // Metadata to allow efficient retrieval of instanced node\n       *         // corresponding to this metadata\n       *         parentInfo: <reference to parent nodeInfo>,\n       *         parentIndex: <integer index in parent's `childNodes` collection>\n       *         infoIndex: <integer index of this `nodeInfo` in `templateInfo.nodeInfoList`\n       *       },\n       *       ...\n       *     ],\n       *     // When true, the template had the `strip-whitespace` attribute\n       *     // or was nested in a template with that setting\n       *     stripWhitespace: <boolean>\n       *     // For nested templates, nested template content is moved into\n       *     // a document fragment stored here; this is an optimization to\n       *     // avoid the cost of nested template cloning\n       *     content: <DocumentFragment>\n       *   }\n       *\n       * This method kicks off a recursive treewalk as follows:\n       *\n       *    _parseTemplate <---------------------+\n       *      _parseTemplateContent              |\n       *        _parseTemplateNode  <------------|--+\n       *          _parseTemplateNestedTemplate --+  |\n       *          _parseTemplateChildNodes ---------+\n       *          _parseTemplateNodeAttributes\n       *            _parseTemplateNodeAttribute\n       *\n       * These methods may be overridden to add custom metadata about templates\n       * to either `templateInfo` or `nodeInfo`.\n       *\n       * Note that this method may be destructive to the template, in that\n       * e.g. event annotations may be removed after being noted in the\n       * template metadata.\n       *\n       * @param {HTMLTemplateElement} template Template to parse\n       * @param {Object=} outerTemplateInfo Template metadata from the outer\n       *   template, for parsing nested templates\n       * @return {Object} Parsed template metadata\n       */\n      static _parseTemplate(template, outerTemplateInfo) {\n        // since a template may be re-used, memo-ize metadata\n        if (!template._templateInfo) {\n          let templateInfo = template._templateInfo = {};\n          templateInfo.nodeInfoList = [];\n          templateInfo.stripWhiteSpace =\n            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||\n            template.hasAttribute('strip-whitespace');\n          this._parseTemplateContent(template, templateInfo, {parent: null});\n        }\n        return template._templateInfo;\n      }\n\n      static _parseTemplateContent(template, templateInfo, nodeInfo) {\n        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);\n      }\n\n      /**\n       * Parses template node and adds template and node metadata based on\n       * the current node, and its `childNodes` and `attributes`.\n       *\n       * This method may be overridden to add custom node or template specific\n       * metadata based on this node.\n       *\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template.\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       */\n      static _parseTemplateNode(node, templateInfo, nodeInfo) {\n        let noted;\n        if (node.localName == 'template' && !node.hasAttribute('preserve-content')) {\n          noted = this._parseTemplateNestedTemplate(node, templateInfo, nodeInfo) || noted;\n        } else if (node.localName === 'slot') {\n          // For ShadyDom optimization, indicating there is an insertion point\n          templateInfo.hasInsertionPoint = true;\n        }\n        if (node.firstChild) {\n          noted = this._parseTemplateChildNodes(node, templateInfo, nodeInfo) || noted;\n        }\n        if (node.hasAttributes && node.hasAttributes()) {\n          noted = this._parseTemplateNodeAttributes(node, templateInfo, nodeInfo) || noted;\n        }\n        return noted;\n      }\n\n      /**\n       * Parses template child nodes for the given root node.\n       *\n       * This method also wraps whitelisted legacy template extensions\n       * (`is=\"dom-if\"` and `is=\"dom-repeat\"`) with their equivalent element\n       * wrappers, collapses text nodes, and strips whitespace from the template\n       * if the `templateInfo.stripWhitespace` setting was provided.\n       *\n       * @param {Node} root Root node whose `childNodes` will be parsed\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template.\n       */\n      static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {\n        for (let node=root.firstChild, parentIndex=0, next; node; node=next) {\n          // Wrap templates\n          if (node.localName == 'template') {\n            node = wrapTemplateExtension(node);\n          }\n          // collapse adjacent textNodes: fixes an IE issue that can cause\n          // text nodes to be inexplicably split =(\n          // note that root.normalize() should work but does not so we do this\n          // manually.\n          next = node.nextSibling;\n          if (node.nodeType === Node.TEXT_NODE) {\n            let n = next;\n            while (n && (n.nodeType === Node.TEXT_NODE)) {\n              node.textContent += n.textContent;\n              next = n.nextSibling;\n              root.removeChild(n);\n              n = next;\n            }\n            // optionally strip whitespace\n            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {\n              root.removeChild(node);\n              continue;\n            }\n          }\n          let childInfo = { parentIndex, parentInfo: nodeInfo };\n          if (this._parseTemplateNode(node, templateInfo, childInfo)) {\n            childInfo.infoIndex = templateInfo.nodeInfoList.push(childInfo) - 1;\n          }\n          parentIndex++;\n        }\n      }\n\n      /**\n       * Parses template content for the given nested `<template>`.\n       *\n       * Nested template info is stored as `templateInfo` in the current node's\n       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.\n       * It will then be the responsibility of the host to set it back to the\n       * template and for users stamping nested templates to use the\n       * `_contentForTemplate` method to retrieve the content for this template\n       * (an optimization to avoid the cost of cloning nested template content).\n       *\n       * @param {HTMLTemplateElement} node Node to parse (a <template>)\n       * @param {Object} outerTemplateInfo Template metadata for current template\n       *   that includes the template `node`\n       * @param {Object} nodeInfo Node metadata for current template.\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       */\n      static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {\n        let templateInfo = this._parseTemplate(node, outerTemplateInfo);\n        let content = templateInfo.content =\n          node.content.ownerDocument.createDocumentFragment();\n        content.appendChild(node.content);\n        nodeInfo.templateInfo = templateInfo;\n        return true;\n      }\n\n      /**\n       * Parses template node attributes and adds node metadata to `nodeInfo`\n       * for nodes of interest.\n       *\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template.\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       */\n      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {\n        // Make copy of original attribute list, since the order may change\n        // as attributes are added and removed\n        let noted;\n        let attrs = Array.from(node.attributes);\n        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {\n          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;\n        }\n        return noted;\n      }\n\n      /**\n       * Parses a single template node attribute and adds node metadata to\n       * `nodeInfo` for attributes of interest.\n       *\n       * This implementation adds metadata for `on-event=\"handler\"` attributes\n       * and `id` attributes.\n       *\n       * @param {Node} node Node to parse\n       * @param {Object} templateInfo Template metadata for current template\n       * @param {Object} nodeInfo Node metadata for current template.\n       * @param {string} name Attribute name\n       * @param {*} value Attribute value\n       * @return {boolean} `true` if the visited node added node-specific\n       *   metadata to `nodeInfo`\n       */\n      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {\n        // events (on-*)\n        if (name.slice(0, 3) === 'on-') {\n          node.removeAttribute(name);\n          nodeInfo.events = nodeInfo.events || [];\n          nodeInfo.events.push({\n            name: name.slice(3),\n            value\n          });\n          return true;\n        }\n        // static id\n        else if (name === 'id') {\n          nodeInfo.id = value;\n          return true;\n        }\n      }\n\n      /**\n       * Returns the `content` document fragment for a given template.\n       *\n       * For nested templates, Polymer performs an optimization to cache nested\n       * template content to avoid the cost of cloning deeply nested templates.\n       * This method retrieves the cached content for a given template.\n       *\n       * @param {HTMLTemplateElement} template Template to retrieve `content` for\n       * @return {DocumentFragment} Content fragment\n       */\n      static _contentForTemplate(template) {\n        let templateInfo = template.__templateInfo;\n        return (templateInfo && templateInfo.content) || template.content;\n      }\n\n      /**\n       * Clones the provided template content and returns a document fragment\n       * containing the cloned dom.\n       *\n       * The template is parsed (once and memoized) using this library's\n       * template parsing features, and provides the following value-added\n       * features:\n       * * Adds declarative event listeners for `on-event=\"handler\"` attributes\n       * * Generates an \"id map\" for all nodes with id's under `$` on returned\n       *   document fragment\n       * * Passes template info including `content` back to templates as\n       *   `_templateInfo` (a performance optimization to avoid deep template\n       *   cloning)\n       *\n       * Note that the memoized template parsing process is destructive to the\n       * template: attributes for bindings and declarative event listeners are\n       * removed after being noted in notes, and any nested <template>.content\n       * is removed and stored in notes as well.\n       *\n       * @param {HTMLTemplateElement} template Template to stamp\n       * @return {DocumentFragment} Cloned template content\n       */\n      _stampTemplate(template) {\n        // Polyfill support: bootstrap the template if it has not already been\n        if (template && !template.content &&\n            window.HTMLTemplateElement && HTMLTemplateElement.decorate) {\n          HTMLTemplateElement.decorate(template);\n        }\n        let templateInfo = this.constructor._parseTemplate(template);\n        let nodeInfo = templateInfo.nodeInfoList;\n        let content = templateInfo.content || template.content;\n        let dom = document.importNode(content, true);\n        // NOTE: ShadyDom optimization indicating there is an insertion point\n        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;\n        let nodes = dom.nodeList = new Array(nodeInfo.length);\n        dom.$ = {};\n        for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {\n          let node = nodes[i] = findTemplateNode(dom, info);\n          applyIdToMap(this, dom.$, node, info);\n          applyTemplateContent(this, node, info);\n          applyEventListener(this, node, info);\n        }\n        return dom;\n      }\n\n      /**\n       * Adds an event listener by method name for the event provided.\n       *\n       * This method generates a handler function that looks up the method\n       * name at handling time.\n       *\n       * @param {Node} node Node to add listener on\n       * @param {string} eventName Name of event\n       * @param {string} methodName Name of method\n       * @param {*=} context Context the method will be called on (defaults\n       *   to `node`)\n       * @return {Function} Generated handler function\n       */\n      _addMethodEventListenerToNode(node, eventName, methodName, context) {\n        context = context || node;\n        let handler = createNodeEventHandler(context, eventName, methodName);\n        this._addEventListenerToNode(node, eventName, handler);\n        return handler;\n      }\n\n      /**\n       * Override point for adding custom or simulated event handling.\n       *\n       * @param {Node} node Node to add event listener to\n       * @param {string} eventName Name of event\n       * @param {Function} handler Listener function to add\n       */\n      _addEventListenerToNode(node, eventName, handler) {\n        node.addEventListener(eventName, handler);\n      }\n\n      /**\n       * Override point for adding custom or simulated event handling.\n       *\n       * @param {Node} node Node to remove event listener from\n       * @param {string} eventName Name of event\n       * @param {Function} handler Listener function to remove\n       */\n      _removeEventListenerFromNode(node, eventName, handler) {\n        node.removeEventListener(eventName, handler);\n      }\n\n    }\n\n    return TemplateStamp;\n\n  });\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/mixins/template-stamp.html\n// module id = 9\n// module chunks = 0","/*__wc__loader*/\nrequire('./boot.html');\n\n\n(function() {\n\n  'use strict';\n\n  /** @typedef {{run: function(function(), number=):number, cancel: function(number)}} */\n  let AsyncInterface; // eslint-disable-line no-unused-vars\n\n  // Microtask implemented using Mutation Observer\n  let microtaskCurrHandle = 0;\n  let microtaskLastHandle = 0;\n  let microtaskCallbacks = [];\n  let microtaskNodeContent = 0;\n  let microtaskNode = document.createTextNode('');\n  new window.MutationObserver(microtaskFlush).observe(microtaskNode, {characterData: true});\n\n  function microtaskFlush() {\n    const len = microtaskCallbacks.length;\n    for (let i = 0; i < len; i++) {\n      let cb = microtaskCallbacks[i];\n      if (cb) {\n        try {\n          cb();\n        } catch (e) {\n          setTimeout(() => { throw e });\n        }\n      }\n    }\n    microtaskCallbacks.splice(0, len);\n    microtaskLastHandle += len;\n  }\n\n  /**\n   * Module that provides a number of strategies for enqueuing asynchronous\n   * tasks.  Each sub-module provides a standard `run(fn)` interface that returns a\n   * handle, and a `cancel(handle)` interface for canceling async tasks before\n   * they run.\n   *\n   * @namespace\n   * @memberof Polymer\n   * @summary Module that provides a number of strategies for enqueuing asynchronous\n   * tasks.\n   */\n  Polymer.Async = {\n\n    /**\n     * Async interface wrapper around `setTimeout`.\n     *\n     * @namespace\n     * @memberof Polymer.Async\n     * @summary Async interface wrapper around `setTimeout`.\n     */\n    timeOut: {\n      /**\n       * Returns a sub-module with the async interface providing the provided\n       * delay.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {number} delay Time to wait before calling callbacks in ms\n       * @return {AsyncInterface} An async timeout interface\n       */\n      after(delay) {\n        return  {\n          run(fn) { return setTimeout(fn, delay) },\n          cancel: window.clearTimeout.bind(window)\n        }\n      },\n      /**\n       * Enqueues a function called in the next task.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {Function} fn Callback to run\n       * @return {number} Handle used for canceling task\n       */\n      run: window.setTimeout.bind(window),\n      /**\n       * Cancels a previously enqueued `timeOut` callback.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {number} handle Handle returned from `run` of callback to cancel\n       */\n      cancel: window.clearTimeout.bind(window)\n    },\n\n    /**\n     * Async interface wrapper around `requestAnimationFrame`.\n     *\n     * @namespace\n     * @memberof Polymer.Async\n     * @summary Async interface wrapper around `requestAnimationFrame`.\n     */\n    animationFrame: {\n      /**\n       * Enqueues a function called at `requestAnimationFrame` timing.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {Function} fn Callback to run\n       * @return {number} Handle used for canceling task\n       */\n      run: window.requestAnimationFrame.bind(window),\n      /**\n       * Cancels a previously enqueued `animationFrame` callback.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {number} handle Handle returned from `run` of callback to cancel\n       */\n      cancel: window.cancelAnimationFrame.bind(window)\n    },\n\n    /**\n     * Async interface wrapper around `requestIdleCallback`.  Falls back to\n     * `setTimeout` on browsers that do not support `requestIdleCallback`.\n     *\n     * @namespace\n     * @memberof Polymer.Async\n     * @summary Async interface wrapper around `requestIdleCallback`.\n     */\n    idlePeriod: {\n      /**\n       * Enqueues a function called at `requestIdleCallback` timing.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {function(IdleDeadline)} fn Callback to run\n       * @return {number} Handle used for canceling task\n       */\n      run(fn) {\n        return window.requestIdleCallback ?\n          window.requestIdleCallback(fn) :\n          window.setTimeout(fn, 16);\n      },\n      /**\n       * Cancels a previously enqueued `idlePeriod` callback.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {number} handle Handle returned from `run` of callback to cancel\n       */\n      cancel(handle) {\n        window.cancelIdleCallback ?\n          window.cancelIdleCallback(handle) :\n          window.clearTimeout(handle);\n      }\n    },\n\n    /**\n     * Async interface for enqueueing callbacks that run at microtask timing.\n     *\n     * Note that microtask timing is achieved via a single `MutationObserver`,\n     * and thus callbacks enqueued with this API will all run in a single\n     * batch, and not interleaved with other microtasks such as promises.\n     * Promises are avoided as an implementation choice for the time being\n     * due to Safari bugs that cause Promises to lack microtask guarantees.\n     *\n     * @namespace\n     * @memberof Polymer.Async\n     * @summary Async interface for enqueueing callbacks that run at microtask\n     *   timing.\n     */\n    microTask: {\n\n      /**\n       * Enqueues a function called at microtask timing.\n       *\n       * @memberof Polymer.Async.timeOut\n       * @param {Function} callback Callback to run\n       * @return {*} Handle used for canceling task\n       */\n      run(callback) {\n        microtaskNode.textContent = microtaskNodeContent++;\n        microtaskCallbacks.push(callback);\n        return microtaskCurrHandle++;\n      },\n\n      /**\n       * Cancels a previously enqueued `microTask` callback.\n       *\n       * @param {number} handle Handle returned from `run` of callback to cancel\n       */\n      cancel(handle) {\n        const idx = handle - microtaskLastHandle;\n        if (idx >= 0) {\n          if (!microtaskCallbacks[idx]) {\n            throw new Error('invalid async handle: ' + handle);\n          }\n          microtaskCallbacks[idx] = null;\n        }\n      }\n\n    }\n  };\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/async.html\n// module id = 10\n// module chunks = 0","/*__wc__loader*/\nrequire('./boot.html');\n\n\n(function() {\n  'use strict';\n\n  /**\n   * Module with utilities for manipulating structured data path strings.\n   *\n   * @namespace\n   * @memberof Polymer\n   * @summary Module with utilities for manipulating structured data path strings.\n   */\n  const Path = {\n\n    /**\n     * Returns true if the given string is a structured data path (has dots).\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.isPath('foo.bar.baz') // true\n     * Polymer.Path.isPath('foo')         // false\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string} path Path string\n     * @return {boolean} True if the string contained one or more dots\n     */\n    isPath: function(path) {\n      return path.indexOf('.') >= 0;\n    },\n\n    /**\n     * Returns the root property name for the given path.\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.root('foo.bar.baz') // 'foo'\n     * Polymer.Path.root('foo')         // 'foo'\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string} path Path string\n     * @return {string} Root property name\n     */\n    root: function(path) {\n      let dotIndex = path.indexOf('.');\n      if (dotIndex === -1) {\n        return path;\n      }\n      return path.slice(0, dotIndex);\n    },\n\n    /**\n     * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not\n     * Returns true if the given path is an ancestor of the base path.\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.isAncestor('foo.bar', 'foo')         // true\n     * Polymer.Path.isAncestor('foo.bar', 'foo.bar')     // false\n     * Polymer.Path.isAncestor('foo.bar', 'foo.bar.baz') // false\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string} base Path string to test against.\n     * @param {string} path Path string to test.\n     * @return {boolean} True if `path` is an ancestor of `base`.\n     */\n    isAncestor: function(base, path) {\n      //     base.startsWith(path + '.');\n      return base.indexOf(path + '.') === 0;\n    },\n\n    /**\n     * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.isDescendant('foo.bar', 'foo.bar.baz') // true\n     * Polymer.Path.isDescendant('foo.bar', 'foo.bar')     // false\n     * Polymer.Path.isDescendant('foo.bar', 'foo')         // false\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string} base Path string to test against.\n     * @param {string} path Path string to test.\n     * @return {boolean} True if `path` is a descendant of `base`.\n     */\n    isDescendant: function(base, path) {\n      //     path.startsWith(base + '.');\n      return path.indexOf(base + '.') === 0;\n    },\n\n    /**\n     * Replaces a previous base path with a new base path, preserving the\n     * remainder of the path.\n     *\n     * User must ensure `path` has a prefix of `base`.\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.translate('foo.bar', 'zot' 'foo.bar.baz') // 'zot.baz'\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string} base Current base string to remove\n     * @param {string} newBase New base string to replace with\n     * @param {string} path Path to translate\n     * @return {string} Translated string\n     */\n    translate: function(base, newBase, path) {\n      return newBase + path.slice(base.length);\n    },\n\n    matches: function(base, path) {\n      return (base === path) ||\n             this.isAncestor(base, path) ||\n             this.isDescendant(base, path);\n    },\n\n    /**\n     * Converts array-based paths to flattened path.  String-based paths\n     * are returned as-is.\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'\n     * Polymer.Path.normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string | !Array<string|number>} path Input path\n     * @return {string} Flattened path\n     */\n    normalize: function(path) {\n      if (Array.isArray(path)) {\n        let parts = [];\n        for (let i=0; i<path.length; i++) {\n          let args = path[i].toString().split('.');\n          for (let j=0; j<args.length; j++) {\n            parts.push(args[j]);\n          }\n        }\n        return parts.join('.');\n      } else {\n        return path;\n      }\n    },\n\n    /**\n     * Splits a path into an array of property names. Accepts either arrays\n     * of path parts or strings.\n     *\n     * Example:\n     *\n     * ```\n     * Polymer.Path.split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']\n     * Polymer.Path.split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']\n     * ```\n     *\n     * @memberof Polymer.Path\n     * @param {string | !Array<string|number>} path Input path\n     * @return {!Array<string>} Array of path parts\n     */\n    split: function(path) {\n      if (Array.isArray(path)) {\n        return this.normalize(path).split('.');\n      }\n      return path.toString().split('.');\n    },\n\n    /**\n     * Reads a value from a path.  If any sub-property in the path is `undefined`,\n     * this method returns `undefined` (will never throw.\n     *\n     * @memberof Polymer.Path\n     * @param {Object} root Object from which to dereference path from\n     * @param {string | !Array<string|number>} path Path to read\n     * @param {Object=} info If an object is provided to `info`, the normalized\n     *  (flattened) path will be set to `info.path`.\n     * @return {*} Value at path, or `undefined` if the path could not be\n     *  fully dereferenced.\n     */\n    get: function(root, path, info) {\n      let prop = root;\n      let parts = this.split(path);\n      // Loop over path parts[0..n-1] and dereference\n      for (let i=0; i<parts.length; i++) {\n        if (!prop) {\n          return;\n        }\n        let part = parts[i];\n        prop = prop[part];\n      }\n      if (info) {\n        info.path = parts.join('.');\n      }\n      return prop;\n    },\n\n    /**\n     * Sets a value to a path.  If any sub-property in the path is `undefined`,\n     * this method will no-op.\n     *\n     * @memberof Polymer.Path\n     * @param {Object} root Object from which to dereference path from\n     * @param {string | !Array<string|number>} path Path to set\n     * @param {*} value Value to set to path\n     * @return {string | undefined} The normalized version of the input path\n     */\n    set: function(root, path, value) {\n      let prop = root;\n      let parts = this.split(path);\n      let last = parts[parts.length-1];\n      if (parts.length > 1) {\n        // Loop over path parts[0..n-2] and dereference\n        for (let i=0; i<parts.length-1; i++) {\n          let part = parts[i];\n          prop = prop[part];\n          if (!prop) {\n            return;\n          }\n        }\n        // Set value to object at end of path\n        prop[last] = value;\n      } else {\n        // Simple property set\n        prop[path] = value;\n      }\n      return parts.join('.');\n    }\n\n  };\n\n  /**\n   * Returns true if the given string is a structured data path (has dots).\n   *\n   * This function is deprecated.  Use `Polymer.Path.isPath` instead.\n   *\n   * Example:\n   *\n   * ```\n   * Polymer.Path.isDeep('foo.bar.baz') // true\n   * Polymer.Path.isDeep('foo')         // false\n   * ```\n   *\n   * @deprecated\n   * @memberof Polymer.Path\n   * @param {string} path Path string\n   * @return {boolean} True if the string contained one or more dots\n   */\n  Path.isDeep = Path.isPath;\n\n  Polymer.Path = Path;\n\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/path.html\n// module id = 11\n// module chunks = 0","/*__wc__loader*/\nrequire('./resolve-url.html');\n\n\n(function() {\n  'use strict';\n\n  const MODULE_STYLE_LINK_SELECTOR = 'link[rel=import][type~=css]';\n  const INCLUDE_ATTR = 'include';\n\n  function importModule(moduleId) {\n    if (!Polymer.DomModule) {\n      return null;\n    }\n    return Polymer.DomModule.import(moduleId);\n  }\n\n  /**\n   * Module with utilities for collection CSS text from `<templates>`, external\n   * stylesheets, and `dom-module`s.\n   *\n   * @namespace\n   * @memberof Polymer\n   * @summary Module with utilities for collection CSS text from various sources.\n   */\n  const StyleGather = {\n\n    /**\n     * Returns CSS text of styles in a space-separated list of `dom-module`s.\n     *\n     * @memberof Polymer.StyleGather\n     * @param {string} moduleIds List of dom-module id's within which to\n     * search for css.\n     * @return {string} Concatenated CSS content from specified `dom-module`s\n     */\n    cssFromModules(moduleIds) {\n      let modules = moduleIds.trim().split(' ');\n      let cssText = '';\n      for (let i=0; i < modules.length; i++) {\n        cssText += this.cssFromModule(modules[i]);\n      }\n      return cssText;\n    },\n\n    /**\n     * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`\n     * can come either from `<style>`s within the first `<template>`, or else\n     * from one or more `<link rel=\"import\" type=\"css\">` links outside the\n     * template.\n     *\n     * Any `<styles>` processed are removed from their original location.\n     *\n     * @memberof Polymer.StyleGather\n     * @param {string} moduleId dom-module id to gather styles from\n     * @return {string} Concatenated CSS content from specified `dom-module`\n     */\n    cssFromModule(moduleId) {\n      let m = importModule(moduleId);\n      if (m && m._cssText === undefined) {\n        let cssText = '';\n        // include css from the first template in the module\n        let t = m.querySelector('template');\n        if (t) {\n          cssText += this.cssFromTemplate(t, m.assetpath);\n        }\n        // module imports: <link rel=\"import\" type=\"css\">\n        cssText += this.cssFromModuleImports(moduleId);\n        m._cssText = cssText || null;\n      }\n      if (!m) {\n        console.warn('Could not find style data in module named', moduleId);\n      }\n      return m && m._cssText || '';\n    },\n\n    /**\n     * Returns CSS text of `<styles>` within a given template.\n     *\n     * Any `<styles>` processed are removed from their original location.\n     *\n     * @memberof Polymer.StyleGather\n     * @param {HTMLTemplateElement} template Template to gather styles from\n     * @param {string} baseURI Base URI to resolve the URL against\n     * @return {string} Concatenated CSS content from specified template\n     */\n    cssFromTemplate(template, baseURI) {\n      let cssText = '';\n      // if element is a template, get content from its .content\n      let e$ = template.content.querySelectorAll('style');\n      for (let i=0; i < e$.length; i++) {\n        let e = e$[i];\n        // support style sharing by allowing styles to \"include\"\n        // other dom-modules that contain styling\n        let include = e.getAttribute(INCLUDE_ATTR);\n        if (include) {\n          cssText += this.cssFromModules(include);\n        }\n        e.parentNode.removeChild(e);\n        cssText += baseURI ?\n          Polymer.ResolveUrl.resolveCss(e.textContent, baseURI) : e.textContent;\n      }\n      return cssText;\n    },\n\n    /**\n     * Returns CSS text from stylsheets loaded via `<link rel=\"import\" type=\"css\">`\n     * links within the specified `dom-module`.\n     *\n     * @memberof Polymer.StyleGather\n     * @param {string} moduleId Id of `dom-module` to gather CSS from\n     * @return {string} Concatenated CSS content from links in specified `dom-module`\n     */\n    cssFromModuleImports(moduleId) {\n      let cssText = '';\n      let m = importModule(moduleId);\n      if (!m) {\n        return cssText;\n      }\n      let p$ = m.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);\n      for (let i=0; i < p$.length; i++) {\n        let p = p$[i];\n        if (p.import) {\n          let importDoc = p.import;\n          // NOTE: polyfill affordance.\n          // under the HTMLImports polyfill, there will be no 'body',\n          // but the import pseudo-doc can be used directly.\n          let container = importDoc.body ? importDoc.body : importDoc;\n          cssText +=\n            Polymer.ResolveUrl.resolveCss(container.textContent,\n              importDoc.baseURI);\n        }\n      }\n      return cssText;\n    }\n  };\n\n  Polymer.StyleGather = StyleGather;\n})();\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@polymer/polymer/lib/utils/style-gather.html\n// module id = 12\n// module chunks = 0"],"sourceRoot":""}
\ No newline at end of file
diff --git a/webpack.config.js b/webpack.config.js
deleted file mode 100644
index f2af12d..0000000
--- a/webpack.config.js
+++ /dev/null
@@ -1,24 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-module.exports = {
-  entry: [
-    './node_modules/@polymer/polymer/polymer-element.html'
-    // path.join(__dirname, './../@polymer/polymer/polymer-element.html')
-  ],
-  output: {
-    path: path.join(__dirname, '.'),
-    filename: 'polymer-element.js',
-  },
-  devtool: 'source-map',
-  module: {
-    rules: [{
-      test: /\.html$/,
-      loaders: ['wc-loader']
-    }]
-  },
-  resolve: {
-    mainFields: ['browserify', 'browser', 'module', 'main']
-  }
-}
diff --git a/yarn.lock b/yarn.lock
index 279b1d2..4a37d49 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,2014 +2,6 @@
 # yarn lockfile v1
 
 
-<<<<<<< HEAD
-"@polymer/polymer@https://github.com/Polymer/polymer":
-  version "2.0.0-rc.7"
-  resolved "https://github.com/Polymer/polymer#4897b678c6b88a69a74fe6c9d3eada244b7da074"
-
-"@types/clone@^0.1.29":
-  version "0.1.30"
-  resolved "https://registry.yarnpkg.com/@types/clone/-/clone-0.1.30.tgz#e7365648c1b42136a59c7d5040637b3b5c83b614"
-
-"@types/node@6.0.*", "@types/node@^6.0.46":
-  version "6.0.70"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-6.0.70.tgz#f6e04b859205ee3611849921f09819701dbfa5e8"
-
-"@types/node@^4.0.30":
-  version "4.2.6"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-4.2.6.tgz#300809a83a82f5d8c2acb9ce8acaba454fbfd079"
-
-"@types/parse5@^0.0.31":
-  version "0.0.31"
-  resolved "https://registry.yarnpkg.com/@types/parse5/-/parse5-0.0.31.tgz#e827a493a443b156e1b582a2e4c3bdc0040f2ee7"
-  dependencies:
-    "@types/node" "6.0.*"
-
-"@webcomponents/shadycss@https://github.com/webcomponents/shadycss":
-  version "1.0.0-rc.5"
-  resolved "https://github.com/webcomponents/shadycss#4651d7300a552f6b872c18d8f9a4d70901004109"
-
-abbrev@1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.0.tgz#d0554c2256636e2f56e7c2e5ad183f859428d81f"
-
-acorn-dynamic-import@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-2.0.2.tgz#c752bd210bef679501b6c6cb7fc84f8f47158cc4"
-  dependencies:
-    acorn "^4.0.3"
-
-acorn@^4.0.3:
-  version "4.0.11"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.11.tgz#edcda3bd937e7556410d42ed5860f67399c794c0"
-
-acorn@^5.0.0:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.0.3.tgz#c460df08491463f028ccb82eab3730bf01087b3d"
-
-ajv-keywords@^1.1.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-1.5.1.tgz#314dd0a4b3368fad3dfcdc54ede6171b886daf3c"
-
-ajv@^4.7.0, ajv@^4.9.1:
-  version "4.11.7"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-4.11.7.tgz#8655a5d86d0824985cc471a1d913fb6729a0ec48"
-  dependencies:
-    co "^4.6.0"
-    json-stable-stringify "^1.0.1"
-
-align-text@^0.1.1, align-text@^0.1.3:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/align-text/-/align-text-0.1.4.tgz#0cd90a561093f35d0a99256c22b7069433fad117"
-  dependencies:
-    kind-of "^3.0.2"
-    longest "^1.0.1"
-    repeat-string "^1.5.2"
-
-amdefine@>=0.0.4:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
-
-ansi-cyan@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-cyan/-/ansi-cyan-0.1.1.tgz#538ae528af8982f28ae30d86f2f17456d2609873"
-  dependencies:
-    ansi-wrap "0.1.0"
-
-ansi-red@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-red/-/ansi-red-0.1.1.tgz#8c638f9d1080800a353c9c28c8a81ca4705d946c"
-  dependencies:
-    ansi-wrap "0.1.0"
-
-ansi-regex@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
-
-ansi-wrap@0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-wrap/-/ansi-wrap-0.1.0.tgz#a82250ddb0015e9a27ca82e82ea603bbfa45efaf"
-
-anymatch@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-1.3.0.tgz#a3e52fa39168c825ff57b0248126ce5a8ff95507"
-  dependencies:
-    arrify "^1.0.0"
-    micromatch "^2.1.5"
-
-aproba@^1.0.3:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.1.1.tgz#95d3600f07710aa0e9298c726ad5ecf2eacbabab"
-
-are-we-there-yet@~1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz#bb5dca382bb94f05e15194373d16fd3ba1ca110d"
-  dependencies:
-    delegates "^1.0.0"
-    readable-stream "^2.0.6"
-
-arr-diff@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-1.1.0.tgz#687c32758163588fef7de7b36fabe495eb1a399a"
-  dependencies:
-    arr-flatten "^1.0.1"
-    array-slice "^0.2.3"
-
-arr-diff@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
-  dependencies:
-    arr-flatten "^1.0.1"
-
-arr-flatten@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.0.3.tgz#a274ed85ac08849b6bd7847c4580745dc51adfb1"
-
-arr-union@^2.0.1:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-2.1.0.tgz#20f9eab5ec70f5c7d215b1077b1c39161d292c7d"
-
-array-slice@^0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-0.2.3.tgz#dd3cfb80ed7973a75117cdac69b0b99ec86186f5"
-
-array-unique@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
-
-arrify@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
-
-asn1.js@^4.0.0:
-  version "4.9.1"
-  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-4.9.1.tgz#48ba240b45a9280e94748990ba597d216617fd40"
-  dependencies:
-    bn.js "^4.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
-asn1@~0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.3.tgz#dac8787713c9966849fc8180777ebe9c1ddf3b86"
-
-assert-plus@1.0.0, assert-plus@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
-
-assert-plus@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-0.2.0.tgz#d74e1b87e7affc0db8aadb7021f3fe48101ab234"
-
-assert@^1.1.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/assert/-/assert-1.4.1.tgz#99912d591836b5a6f5b345c0f07eefc08fc65d91"
-  dependencies:
-    util "0.10.3"
-
-async-each@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.1.tgz#19d386a1d9edc6e7c1c85d388aedbcc56d33602d"
-
-async@^2.1.2:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.3.0.tgz#1013d1051047dd320fe24e494d5c66ecaf6147d9"
-  dependencies:
-    lodash "^4.14.0"
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
-
-aws-sign2@~0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.6.0.tgz#14342dd38dbcc94d0e5b87d763cd63612c0e794f"
-
-aws4@^1.2.1:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.6.0.tgz#83ef5ca860b2b32e4a0deedee8c771b9db57471e"
-
-balanced-match@^0.4.1:
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-0.4.2.tgz#cb3f3e3c732dc0f01ee70b403f302e61d7709838"
-
-base64-js@^1.0.2:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.2.0.tgz#a39992d723584811982be5e290bb6a53d86700f1"
-
-bcrypt-pbkdf@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz#63bc5dcb61331b92bc05fd528953c33462a06f8d"
-  dependencies:
-    tweetnacl "^0.14.3"
-
-big.js@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/big.js/-/big.js-3.1.3.tgz#4cada2193652eb3ca9ec8e55c9015669c9806978"
-
-binary-extensions@^1.0.0:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.8.0.tgz#48ec8d16df4377eae5fa5884682480af4d95c774"
-
-block-stream@*:
-  version "0.0.9"
-  resolved "https://registry.yarnpkg.com/block-stream/-/block-stream-0.0.9.tgz#13ebfe778a03205cfe03751481ebb4b3300c126a"
-  dependencies:
-    inherits "~2.0.0"
-
-bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.1.1, bn.js@^4.4.0:
-  version "4.11.6"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.6.tgz#53344adb14617a13f6e8dd2ce28905d1c0ba3215"
-
-boom@2.x.x:
-  version "2.10.1"
-  resolved "https://registry.yarnpkg.com/boom/-/boom-2.10.1.tgz#39c8918ceff5799f83f9492a848f625add0c766f"
-  dependencies:
-    hoek "2.x.x"
-
-brace-expansion@^1.0.0:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.7.tgz#3effc3c50e000531fb720eaff80f0ae8ef23cf59"
-  dependencies:
-    balanced-match "^0.4.1"
-    concat-map "0.0.1"
-
-braces@^1.8.2:
-  version "1.8.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7"
-  dependencies:
-    expand-range "^1.8.1"
-    preserve "^0.2.0"
-    repeat-element "^1.1.2"
-
-brorand@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
-
-browserify-aes@^1.0.0, browserify-aes@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.0.6.tgz#5e7725dbdef1fd5930d4ebab48567ce451c48a0a"
-  dependencies:
-    buffer-xor "^1.0.2"
-    cipher-base "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.0"
-    inherits "^2.0.1"
-
-browserify-cipher@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.0.tgz#9988244874bf5ed4e28da95666dcd66ac8fc363a"
-  dependencies:
-    browserify-aes "^1.0.4"
-    browserify-des "^1.0.0"
-    evp_bytestokey "^1.0.0"
-
-browserify-des@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.0.tgz#daa277717470922ed2fe18594118a175439721dd"
-  dependencies:
-    cipher-base "^1.0.1"
-    des.js "^1.0.0"
-    inherits "^2.0.1"
-
-browserify-rsa@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.0.1.tgz#21e0abfaf6f2029cf2fafb133567a701d4135524"
-  dependencies:
-    bn.js "^4.1.0"
-    randombytes "^2.0.1"
-
-browserify-sign@^4.0.0:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.0.4.tgz#aa4eb68e5d7b658baa6bf6a57e630cbd7a93d298"
-  dependencies:
-    bn.js "^4.1.1"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.2"
-    elliptic "^6.0.0"
-    inherits "^2.0.1"
-    parse-asn1 "^5.0.0"
-
-browserify-zlib@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.1.4.tgz#bb35f8a519f600e0fa6b8485241c979d0141fb2d"
-  dependencies:
-    pako "~0.2.0"
-
-buffer-shims@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/buffer-shims/-/buffer-shims-1.0.0.tgz#9978ce317388c649ad8793028c3477ef044a8b51"
-
-buffer-xor@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
-
-buffer@^4.3.0:
-  version "4.9.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.1.tgz#6d1bb601b07a4efced97094132093027c95bc298"
-  dependencies:
-    base64-js "^1.0.2"
-    ieee754 "^1.1.4"
-    isarray "^1.0.0"
-
-builtin-modules@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f"
-
-builtin-status-codes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
-
-camel-case@3.0.x:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-3.0.0.tgz#ca3c3688a4e9cf3a4cda777dc4dcbc713249cf73"
-  dependencies:
-    no-case "^2.2.0"
-    upper-case "^1.1.1"
-
-camelcase@^1.0.2:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39"
-
-camelcase@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a"
-
-caseless@~0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
-
-center-align@^0.1.1:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/center-align/-/center-align-0.1.3.tgz#aa0d32629b6ee972200411cbd4461c907bc2b7ad"
-  dependencies:
-    align-text "^0.1.3"
-    lazy-cache "^1.0.3"
-
-chokidar@^1.4.3:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-1.6.1.tgz#2f4447ab5e96e50fb3d789fd90d4c72e0e4c70c2"
-  dependencies:
-    anymatch "^1.3.0"
-    async-each "^1.0.0"
-    glob-parent "^2.0.0"
-    inherits "^2.0.1"
-    is-binary-path "^1.0.0"
-    is-glob "^2.0.0"
-    path-is-absolute "^1.0.0"
-    readdirp "^2.0.0"
-  optionalDependencies:
-    fsevents "^1.0.0"
-
-cipher-base@^1.0.0, cipher-base@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.3.tgz#eeabf194419ce900da3018c207d212f2a6df0a07"
-  dependencies:
-    inherits "^2.0.1"
-
-clean-css@4.0.x:
-  version "4.0.12"
-  resolved "https://registry.yarnpkg.com/clean-css/-/clean-css-4.0.12.tgz#a02e61707f1840bd3338f54dbc9acbda4e772fa3"
-  dependencies:
-    source-map "0.5.x"
-
-cliui@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1"
-  dependencies:
-    center-align "^0.1.1"
-    right-align "^0.1.1"
-    wordwrap "0.0.2"
-
-cliui@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
-  dependencies:
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wrap-ansi "^2.0.0"
-
-clone@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.2.tgz#260b7a99ebb1edfe247538175f783243cb19d149"
-
-co@^4.6.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
-
-code-point-at@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
-
-combined-stream@^1.0.5, combined-stream@~1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.5.tgz#938370a57b4a51dea2c77c15d5c5fdf895164009"
-  dependencies:
-    delayed-stream "~1.0.0"
-
-commander@2.9.x:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.9.0.tgz#9c99094176e12240cb22d6c5146098400fe0f7d4"
-  dependencies:
-    graceful-readlink ">= 1.0.0"
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
-
-console-browserify@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.1.0.tgz#f0241c45730a9fc6323b206dbf38edc741d0bb10"
-  dependencies:
-    date-now "^0.1.4"
-
-console-control-strings@^1.0.0, console-control-strings@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
-
-constants-browserify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
-
-core-util-is@~1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
-
-create-ecdh@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.0.tgz#888c723596cdf7612f6498233eebd7a35301737d"
-  dependencies:
-    bn.js "^4.1.0"
-    elliptic "^6.0.0"
-
-create-hash@^1.1.0, create-hash@^1.1.1:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.1.2.tgz#51210062d7bb7479f6c65bb41a92208b1d61abad"
-  dependencies:
-    cipher-base "^1.0.1"
-    inherits "^2.0.1"
-    ripemd160 "^1.0.0"
-    sha.js "^2.3.6"
-
-create-hmac@^1.1.0, create-hmac@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.4.tgz#d3fb4ba253eb8b3f56e39ea2fbcb8af747bd3170"
-  dependencies:
-    create-hash "^1.1.0"
-    inherits "^2.0.1"
-
-cryptiles@2.x.x:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/cryptiles/-/cryptiles-2.0.5.tgz#3bdfecdc608147c1c67202fa291e7dca59eaa3b8"
-  dependencies:
-    boom "2.x.x"
-
-crypto-browserify@^3.11.0:
-  version "3.11.0"
-  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.11.0.tgz#3652a0906ab9b2a7e0c3ce66a408e957a2485522"
-  dependencies:
-    browserify-cipher "^1.0.0"
-    browserify-sign "^4.0.0"
-    create-ecdh "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.0"
-    diffie-hellman "^5.0.0"
-    inherits "^2.0.1"
-    pbkdf2 "^3.0.3"
-    public-encrypt "^4.0.0"
-    randombytes "^2.0.0"
-
-dashdash@^1.12.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
-  dependencies:
-    assert-plus "^1.0.0"
-
-date-now@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/date-now/-/date-now-0.1.4.tgz#eaf439fd4d4848ad74e5cc7dbef200672b9e345b"
-
-debug@^2.2.0:
-  version "2.6.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.4.tgz#7586a9b3c39741c0282ae33445c4e8ac74734fe0"
-  dependencies:
-    ms "0.7.3"
-
-decamelize@^1.0.0, decamelize@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
-
-deep-extend@~0.4.0:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.4.1.tgz#efe4113d08085f4e6f9687759810f807469e2253"
-
-deep-is@~0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
-
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
-
-delegates@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
-
-des.js@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.0.tgz#c074d2e2aa6a8a9a07dbd61f9a15c2cd83ec8ecc"
-  dependencies:
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
-diffie-hellman@^5.0.0:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.2.tgz#b5835739270cfe26acf632099fded2a07f209e5e"
-  dependencies:
-    bn.js "^4.1.0"
-    miller-rabin "^4.0.0"
-    randombytes "^2.0.0"
-
-dom5@^1.0.1:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/dom5/-/dom5-1.3.6.tgz#a7088a9fc5f3b08dc9f6eda4c7abaeb241945e0d"
-  dependencies:
-    "@types/clone" "^0.1.29"
-    "@types/node" "^4.0.30"
-    "@types/parse5" "^0.0.31"
-    clone "^1.0.2"
-    parse5 "^1.4.1"
-
-domain-browser@^1.1.1:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.1.7.tgz#867aa4b093faa05f1de08c06f4d7b21fdf8698bc"
-
-ecc-jsbn@~0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz#0fc73a9ed5f0d53c38193398523ef7e543777505"
-  dependencies:
-    jsbn "~0.1.0"
-
-elliptic@^6.0.0:
-  version "6.4.0"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.4.0.tgz#cac9af8762c85836187003c8dfe193e5e2eae5df"
-  dependencies:
-    bn.js "^4.4.0"
-    brorand "^1.0.1"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.0"
-
-emojis-list@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
-
-enhanced-resolve@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-3.1.0.tgz#9f4b626f577245edcf4b2ad83d86e17f4f421dec"
-  dependencies:
-    graceful-fs "^4.1.2"
-    memory-fs "^0.4.0"
-    object-assign "^4.0.1"
-    tapable "^0.2.5"
-
-errno@^0.1.3:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.4.tgz#b896e23a9e5e8ba33871fc996abd3635fc9a1c7d"
-  dependencies:
-    prr "~0.0.0"
-
-error-ex@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.1.tgz#f855a86ce61adc4e8621c3cda21e7a7612c3a8dc"
-  dependencies:
-    is-arrayish "^0.2.1"
-
-escodegen@^1.6.1:
-  version "1.8.1"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.8.1.tgz#5a5b53af4693110bebb0867aa3430dd3b70a1018"
-  dependencies:
-    esprima "^2.7.1"
-    estraverse "^1.9.1"
-    esutils "^2.0.2"
-    optionator "^0.8.1"
-  optionalDependencies:
-    source-map "~0.2.0"
-
-espree@^2.0.1:
-  version "2.2.5"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-2.2.5.tgz#df691b9310889402aeb29cc066708c56690b854b"
-
-esprima@^2.7.1:
-  version "2.7.3"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-2.7.3.tgz#96e3b70d5779f6ad49cd032673d1c312767ba581"
-
-estraverse@^1.9.1:
-  version "1.9.3"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.9.3.tgz#af67f2dc922582415950926091a4005d29c9bb44"
-
-esutils@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
-
-events@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/events/-/events-1.1.1.tgz#9ebdb7635ad099c70dcc4c2a1f5004288e8bd924"
-
-evp_bytestokey@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.0.tgz#497b66ad9fef65cd7c08a6180824ba1476b66e53"
-  dependencies:
-    create-hash "^1.1.1"
-
-expand-brackets@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b"
-  dependencies:
-    is-posix-bracket "^0.1.0"
-
-expand-range@^1.8.1:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337"
-  dependencies:
-    fill-range "^2.1.0"
-
-extend-shallow@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-1.1.4.tgz#19d6bf94dfc09d76ba711f39b872d21ff4dd9071"
-  dependencies:
-    kind-of "^1.1.0"
-
-extend@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.0.tgz#5a474353b9f3353ddd8176dfd37b91c83a46f1d4"
-
-extglob@^0.3.1:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
-  dependencies:
-    is-extglob "^1.0.0"
-
-extsprintf@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.0.2.tgz#e1080e0658e300b06294990cc70e1502235fd550"
-
-fast-levenshtein@~2.0.4:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-
-filename-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.0.tgz#996e3e80479b98b9897f15a8a58b3d084e926775"
-
-fill-range@^2.1.0:
-  version "2.2.3"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.3.tgz#50b77dfd7e469bc7492470963699fe7a8485a723"
-  dependencies:
-    is-number "^2.1.0"
-    isobject "^2.0.0"
-    randomatic "^1.1.3"
-    repeat-element "^1.1.2"
-    repeat-string "^1.5.2"
-
-find-up@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
-  dependencies:
-    path-exists "^2.0.0"
-    pinkie-promise "^2.0.0"
-
-for-in@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
-
-for-own@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce"
-  dependencies:
-    for-in "^1.0.1"
-
-forever-agent@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
-
-form-data@~2.1.1:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.1.4.tgz#33c183acf193276ecaa98143a69e94bfee1750d1"
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.5"
-    mime-types "^2.1.12"
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
-
-fsevents@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.1.1.tgz#f19fd28f43eeaf761680e519a203c4d0b3d31aff"
-  dependencies:
-    nan "^2.3.0"
-    node-pre-gyp "^0.6.29"
-
-fstream-ignore@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/fstream-ignore/-/fstream-ignore-1.0.5.tgz#9c31dae34767018fe1d249b24dada67d092da105"
-  dependencies:
-    fstream "^1.0.0"
-    inherits "2"
-    minimatch "^3.0.0"
-
-fstream@^1.0.0, fstream@^1.0.10, fstream@^1.0.2:
-  version "1.0.11"
-  resolved "https://registry.yarnpkg.com/fstream/-/fstream-1.0.11.tgz#5c1fb1f117477114f0632a0eb4b71b3cb0fd3171"
-  dependencies:
-    graceful-fs "^4.1.2"
-    inherits "~2.0.0"
-    mkdirp ">=0.5 0"
-    rimraf "2"
-
-gauge@~2.7.1:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
-  dependencies:
-    aproba "^1.0.3"
-    console-control-strings "^1.0.0"
-    has-unicode "^2.0.0"
-    object-assign "^4.1.0"
-    signal-exit "^3.0.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wide-align "^1.1.0"
-
-get-caller-file@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.2.tgz#f702e63127e7e231c160a80c1554acb70d5047e5"
-
-getpass@^0.1.1:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
-  dependencies:
-    assert-plus "^1.0.0"
-
-glob-base@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4"
-  dependencies:
-    glob-parent "^2.0.0"
-    is-glob "^2.0.0"
-
-glob-parent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28"
-  dependencies:
-    is-glob "^2.0.0"
-
-glob@^7.0.5:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8"
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.2"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-graceful-fs@^4.1.2:
-  version "4.1.11"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
-
-"graceful-readlink@>= 1.0.0":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
-
-har-schema@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-1.0.5.tgz#d263135f43307c02c602afc8fe95970c0151369e"
-
-har-validator@~4.2.1:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-4.2.1.tgz#33481d0f1bbff600dd203d75812a6a5fba002e2a"
-  dependencies:
-    ajv "^4.9.1"
-    har-schema "^1.0.5"
-
-has-flag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-1.0.0.tgz#9d9e793165ce017a00f00418c43f942a7b1d11fa"
-
-has-unicode@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
-
-hash.js@^1.0.0, hash.js@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.0.3.tgz#1332ff00156c0a0ffdd8236013d07b77a0451573"
-  dependencies:
-    inherits "^2.0.1"
-
-hawk@~3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/hawk/-/hawk-3.1.3.tgz#078444bd7c1640b0fe540d2c9b73d59678e8e1c4"
-  dependencies:
-    boom "2.x.x"
-    cryptiles "2.x.x"
-    hoek "2.x.x"
-    sntp "1.x.x"
-
-he@1.1.x:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.1.1.tgz#93410fd21b009735151f8868c2f271f3427e23fd"
-
-hmac-drbg@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
-  dependencies:
-    hash.js "^1.0.3"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.1"
-
-hoek@2.x.x:
-  version "2.16.3"
-  resolved "https://registry.yarnpkg.com/hoek/-/hoek-2.16.3.tgz#20bb7403d3cea398e91dc4710a8ff1b8274a25ed"
-
-hosted-git-info@^2.1.4:
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.4.2.tgz#0076b9f46a270506ddbaaea56496897460612a67"
-
-html-minifier@^3.4.1:
-  version "3.4.3"
-  resolved "https://registry.yarnpkg.com/html-minifier/-/html-minifier-3.4.3.tgz#eb3a7297c804611f470454eeebe0aacc427e424a"
-  dependencies:
-    camel-case "3.0.x"
-    clean-css "4.0.x"
-    commander "2.9.x"
-    he "1.1.x"
-    ncname "1.0.x"
-    param-case "2.1.x"
-    relateurl "0.2.x"
-    uglify-js "~2.8.22"
-
-http-signature@~1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.1.1.tgz#df72e267066cd0ac67fb76adf8e134a8fbcf91bf"
-  dependencies:
-    assert-plus "^0.2.0"
-    jsprim "^1.2.2"
-    sshpk "^1.7.0"
-
-https-browserify@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-0.0.1.tgz#3f91365cabe60b77ed0ebba24b454e3e09d95a82"
-
-ieee754@^1.1.4:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.1.8.tgz#be33d40ac10ef1926701f6f08a2d86fbfd1ad3e4"
-
-indexof@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/indexof/-/indexof-0.0.1.tgz#82dc336d232b9062179d05ab3293a66059fd435d"
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2, inherits@^2.0.1, inherits@~2.0.0, inherits@~2.0.1:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
-
-inherits@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.1.tgz#b17d08d326b4423e568eff719f91b0b1cbdf69f1"
-
-ini@~1.3.0:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.4.tgz#0537cb79daf59b59a1a517dff706c86ec039162e"
-
-interpret@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.0.3.tgz#cbc35c62eeee73f19ab7b10a801511401afc0f90"
-
-invert-kv@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
-
-is-arrayish@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
-
-is-binary-path@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
-  dependencies:
-    binary-extensions "^1.0.0"
-
-is-buffer@^1.1.5:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.5.tgz#1f3b26ef613b214b88cbca23cc6c01d87961eecc"
-
-is-builtin-module@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-1.0.0.tgz#540572d34f7ac3119f8f76c30cbc1b1e037affbe"
-  dependencies:
-    builtin-modules "^1.0.0"
-
-is-dotfile@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.2.tgz#2c132383f39199f8edc268ca01b9b007d205cc4d"
-
-is-equal-shallow@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534"
-  dependencies:
-    is-primitive "^2.0.0"
-
-is-extendable@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
-
-is-extglob@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
-
-is-fullwidth-code-point@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
-  dependencies:
-    number-is-nan "^1.0.0"
-
-is-glob@^2.0.0, is-glob@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
-  dependencies:
-    is-extglob "^1.0.0"
-
-is-number@^2.0.2, is-number@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f"
-  dependencies:
-    kind-of "^3.0.2"
-
-is-posix-bracket@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
-
-is-primitive@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
-
-is-typedarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
-
-is-utf8@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
-
-isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
-
-isobject@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
-  dependencies:
-    isarray "1.0.0"
-
-isstream@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
-
-jodid25519@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/jodid25519/-/jodid25519-1.0.2.tgz#06d4912255093419477d425633606e0e90782967"
-  dependencies:
-    jsbn "~0.1.0"
-
-jsbn@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
-
-json-loader@^0.5.4:
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/json-loader/-/json-loader-0.5.4.tgz#8baa1365a632f58a3c46d20175fc6002c96e37de"
-
-json-schema@0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
-
-json-stable-stringify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz#9a759d39c5f2ff503fd5300646ed445f88c4f9af"
-  dependencies:
-    jsonify "~0.0.0"
-
-json-stringify-safe@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
-
-json5@^0.5.0, json5@^0.5.1:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-0.5.1.tgz#1eade7acc012034ad84e2396767ead9fa5495821"
-
-jsonify@~0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73"
-
-jsprim@^1.2.2:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.0.tgz#a3b87e40298d8c380552d8cc7628a0bb95a22918"
-  dependencies:
-    assert-plus "1.0.0"
-    extsprintf "1.0.2"
-    json-schema "0.2.3"
-    verror "1.3.6"
-
-kind-of@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-1.1.0.tgz#140a3d2d41a36d2efcfa9377b62c24f8495a5c44"
-
-kind-of@^3.0.2:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.0.tgz#b58abe4d5c044ad33726a8c1525b48cf891bff07"
-  dependencies:
-    is-buffer "^1.1.5"
-
-lazy-cache@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e"
-
-lcid@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835"
-  dependencies:
-    invert-kv "^1.0.0"
-
-levn@~0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
-  dependencies:
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-
-load-json-file@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^2.2.0"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-    strip-bom "^2.0.0"
-
-loader-runner@^2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-2.3.0.tgz#f482aea82d543e07921700d5a46ef26fdac6b8a2"
-
-loader-utils@^0.2.16:
-  version "0.2.17"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-0.2.17.tgz#f86e6374d43205a6e6c60e9196f17c0299bfb348"
-  dependencies:
-    big.js "^3.1.3"
-    emojis-list "^2.0.0"
-    json5 "^0.5.0"
-    object-assign "^4.0.1"
-
-lodash@^4.14.0, lodash@^4.17.4:
-  version "4.17.4"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae"
-
-longest@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097"
-
-lower-case@^1.1.1:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-1.1.4.tgz#9a2cabd1b9e8e0ae993a4bf7d5875c39c42e8eac"
-
-memory-fs@^0.4.0, memory-fs@~0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.4.1.tgz#3a9a20b8462523e447cfbc7e8bb80ed667bfc552"
-  dependencies:
-    errno "^0.1.3"
-    readable-stream "^2.0.1"
-
-micromatch@^2.1.5:
-  version "2.3.11"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
-  dependencies:
-    arr-diff "^2.0.0"
-    array-unique "^0.2.1"
-    braces "^1.8.2"
-    expand-brackets "^0.1.4"
-    extglob "^0.3.1"
-    filename-regex "^2.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.1"
-    kind-of "^3.0.2"
-    normalize-path "^2.0.1"
-    object.omit "^2.0.0"
-    parse-glob "^3.0.4"
-    regex-cache "^0.4.2"
-
-miller-rabin@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.0.tgz#4a62fb1d42933c05583982f4c716f6fb9e6c6d3d"
-  dependencies:
-    bn.js "^4.0.0"
-    brorand "^1.0.1"
-
-mime-db@~1.27.0:
-  version "1.27.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.27.0.tgz#820f572296bbd20ec25ed55e5b5de869e5436eb1"
-
-mime-types@^2.1.12, mime-types@~2.1.7:
-  version "2.1.15"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.15.tgz#a4ebf5064094569237b8cf70046776d09fc92aed"
-  dependencies:
-    mime-db "~1.27.0"
-
-minimalistic-assert@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.0.tgz#702be2dda6b37f4836bcb3f5db56641b64a1d3d3"
-
-minimalistic-crypto-utils@^1.0.0, minimalistic-crypto-utils@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
-
-minimatch@^3.0.0, minimatch@^3.0.2:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774"
-  dependencies:
-    brace-expansion "^1.0.0"
-
-minimist@0.0.8:
-  version "0.0.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
-
-minimist@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
-
-"mkdirp@>=0.5 0", mkdirp@^0.5.1, mkdirp@~0.5.0:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
-  dependencies:
-    minimist "0.0.8"
-
-ms@0.7.3:
-  version "0.7.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-0.7.3.tgz#708155a5e44e33f5fd0fc53e81d0d40a91be1fff"
-
-nan@^2.3.0:
-  version "2.6.2"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.6.2.tgz#e4ff34e6c95fdfb5aecc08de6596f43605a7db45"
-
-ncname@1.0.x:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/ncname/-/ncname-1.0.0.tgz#5b57ad18b1ca092864ef62b0b1ed8194f383b71c"
-  dependencies:
-    xml-char-classes "^1.0.0"
-
-no-case@^2.2.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/no-case/-/no-case-2.3.1.tgz#7aeba1c73a52184265554b7dc03baf720df80081"
-  dependencies:
-    lower-case "^1.1.1"
-
-node-libs-browser@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/node-libs-browser/-/node-libs-browser-2.0.0.tgz#a3a59ec97024985b46e958379646f96c4b616646"
-  dependencies:
-    assert "^1.1.1"
-    browserify-zlib "^0.1.4"
-    buffer "^4.3.0"
-    console-browserify "^1.1.0"
-    constants-browserify "^1.0.0"
-    crypto-browserify "^3.11.0"
-    domain-browser "^1.1.1"
-    events "^1.0.0"
-    https-browserify "0.0.1"
-    os-browserify "^0.2.0"
-    path-browserify "0.0.0"
-    process "^0.11.0"
-    punycode "^1.2.4"
-    querystring-es3 "^0.2.0"
-    readable-stream "^2.0.5"
-    stream-browserify "^2.0.1"
-    stream-http "^2.3.1"
-    string_decoder "^0.10.25"
-    timers-browserify "^2.0.2"
-    tty-browserify "0.0.0"
-    url "^0.11.0"
-    util "^0.10.3"
-    vm-browserify "0.0.4"
-
-node-pre-gyp@^0.6.29:
-  version "0.6.34"
-  resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.6.34.tgz#94ad1c798a11d7fc67381b50d47f8cc18d9799f7"
-  dependencies:
-    mkdirp "^0.5.1"
-    nopt "^4.0.1"
-    npmlog "^4.0.2"
-    rc "^1.1.7"
-    request "^2.81.0"
-    rimraf "^2.6.1"
-    semver "^5.3.0"
-    tar "^2.2.1"
-    tar-pack "^3.4.0"
-
-nopt@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.1.tgz#d0d4685afd5415193c8c7505602d0d17cd64474d"
-  dependencies:
-    abbrev "1"
-    osenv "^0.1.4"
-
-normalize-package-data@^2.3.2:
-  version "2.3.8"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.3.8.tgz#d819eda2a9dedbd1ffa563ea4071d936782295bb"
-  dependencies:
-    hosted-git-info "^2.1.4"
-    is-builtin-module "^1.0.0"
-    semver "2 || 3 || 4 || 5"
-    validate-npm-package-license "^3.0.1"
-
-normalize-path@^2.0.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
-  dependencies:
-    remove-trailing-separator "^1.0.1"
-
-npmlog@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.0.2.tgz#d03950e0e78ce1527ba26d2a7592e9348ac3e75f"
-  dependencies:
-    are-we-there-yet "~1.1.2"
-    console-control-strings "~1.1.0"
-    gauge "~2.7.1"
-    set-blocking "~2.0.0"
-
-number-is-nan@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
-
-oauth-sign@~0.8.1:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.8.2.tgz#46a6ab7f0aead8deae9ec0565780b7d4efeb9d43"
-
-object-assign@^4.0.1, object-assign@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
-
-object.omit@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
-  dependencies:
-    for-own "^0.1.4"
-    is-extendable "^0.1.1"
-
-once@^1.3.0, once@^1.3.3:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
-  dependencies:
-    wrappy "1"
-
-optionator@^0.8.1:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
-  dependencies:
-    deep-is "~0.1.3"
-    fast-levenshtein "~2.0.4"
-    levn "~0.3.0"
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-    wordwrap "~1.0.0"
-
-os-browserify@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.2.1.tgz#63fc4ccee5d2d7763d26bbf8601078e6c2e0044f"
-
-os-homedir@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
-
-os-locale@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-1.4.0.tgz#20f9f17ae29ed345e8bde583b13d2009803c14d9"
-  dependencies:
-    lcid "^1.0.0"
-
-os-tmpdir@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
-
-osenv@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.4.tgz#42fe6d5953df06c8064be6f176c3d05aaaa34644"
-  dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
-
-pako@~0.2.0:
-  version "0.2.9"
-  resolved "https://registry.yarnpkg.com/pako/-/pako-0.2.9.tgz#f3f7522f4ef782348da8161bad9ecfd51bf83a75"
-
-param-case@2.1.x:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/param-case/-/param-case-2.1.1.tgz#df94fd8cf6531ecf75e6bef9a0858fbc72be2247"
-  dependencies:
-    no-case "^2.2.0"
-
-parse-asn1@^5.0.0:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.0.tgz#37c4f9b7ed3ab65c74817b5f2480937fbf97c712"
-  dependencies:
-    asn1.js "^4.0.0"
-    browserify-aes "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.0"
-    pbkdf2 "^3.0.3"
-
-parse-glob@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
-  dependencies:
-    glob-base "^0.3.0"
-    is-dotfile "^1.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.0"
-
-parse-json@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
-  dependencies:
-    error-ex "^1.2.0"
-
-parse5@^1.4.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-1.5.1.tgz#9b7f3b0de32be78dc2401b17573ccaf0f6f59d94"
-
-parse5@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-3.0.2.tgz#05eff57f0ef4577fb144a79f8b9a967a6cc44510"
-  dependencies:
-    "@types/node" "^6.0.46"
-
-path-browserify@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.0.tgz#a0b870729aae214005b7d5032ec2cbbb0fb4451a"
-
-path-exists@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
-  dependencies:
-    pinkie-promise "^2.0.0"
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
-
-path-type@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
-  dependencies:
-    graceful-fs "^4.1.2"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-
-pbkdf2@^3.0.3:
-  version "3.0.9"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.0.9.tgz#f2c4b25a600058b3c3773c086c37dbbee1ffe693"
-  dependencies:
-    create-hmac "^1.1.2"
-
-performance-now@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-0.2.0.tgz#33ef30c5c77d4ea21c5a53869d91b56d8f2555e5"
-
-pify@^2.0.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
-
-pinkie-promise@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
-  dependencies:
-    pinkie "^2.0.0"
-
-pinkie@^2.0.0:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
-
-plugin-error@^0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/plugin-error/-/plugin-error-0.1.2.tgz#3b9bb3335ccf00f425e07437e19276967da47ace"
-  dependencies:
-    ansi-cyan "^0.1.1"
-    ansi-red "^0.1.1"
-    arr-diff "^1.0.1"
-    arr-union "^2.0.1"
-    extend-shallow "^1.1.2"
-
-polyclean@^1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/polyclean/-/polyclean-1.3.1.tgz#74c2e2ccfad8b38d54cef88b17b0312ccde23e16"
-  dependencies:
-    dom5 "^1.0.1"
-    escodegen "^1.6.1"
-    espree "^2.0.1"
-    plugin-error "^0.1.1"
-    through2 "^2.0.0"
-    uglify-js "^2.4.19"
-
-prelude-ls@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
-
-preserve@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
-
-process-nextick-args@~1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3"
-
-process@^0.11.0:
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
-
-prr@~0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-0.0.0.tgz#1a84b85908325501411853d0081ee3fa86e2926a"
-
-public-encrypt@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.0.tgz#39f699f3a46560dd5ebacbca693caf7c65c18cc6"
-  dependencies:
-    bn.js "^4.1.0"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    parse-asn1 "^5.0.0"
-    randombytes "^2.0.1"
-
-punycode@1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
-
-punycode@^1.2.4, punycode@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
-
-qs@~6.4.0:
-  version "6.4.0"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.4.0.tgz#13e26d28ad6b0ffaa91312cd3bf708ed351e7233"
-
-querystring-es3@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
-
-querystring@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
-
-randomatic@^1.1.3:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-1.1.6.tgz#110dcabff397e9dcff7c0789ccc0a49adf1ec5bb"
-  dependencies:
-    is-number "^2.0.2"
-    kind-of "^3.0.2"
-
-randombytes@^2.0.0, randombytes@^2.0.1:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.0.3.tgz#674c99760901c3c4112771a31e521dc349cc09ec"
-
-rc@^1.1.7:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.1.tgz#2e03e8e42ee450b8cb3dce65be1bf8974e1dfd95"
-  dependencies:
-    deep-extend "~0.4.0"
-    ini "~1.3.0"
-    minimist "^1.2.0"
-    strip-json-comments "~2.0.1"
-
-read-pkg-up@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
-  dependencies:
-    find-up "^1.0.0"
-    read-pkg "^1.0.0"
-
-read-pkg@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
-  dependencies:
-    load-json-file "^1.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^1.0.0"
-
-readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.5, readable-stream@^2.0.6, readable-stream@^2.1.4, readable-stream@^2.1.5, readable-stream@^2.2.6:
-  version "2.2.9"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.2.9.tgz#cf78ec6f4a6d1eb43d26488cac97f042e74b7fc8"
-  dependencies:
-    buffer-shims "~1.0.0"
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "~1.0.0"
-    process-nextick-args "~1.0.6"
-    string_decoder "~1.0.0"
-    util-deprecate "~1.0.1"
-
-readdirp@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.1.0.tgz#4ed0ad060df3073300c48440373f72d1cc642d78"
-  dependencies:
-    graceful-fs "^4.1.2"
-    minimatch "^3.0.2"
-    readable-stream "^2.0.2"
-    set-immediate-shim "^1.0.1"
-
-regex-cache@^0.4.2:
-  version "0.4.3"
-  resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.3.tgz#9b1a6c35d4d0dfcef5711ae651e8e9d3d7114145"
-  dependencies:
-    is-equal-shallow "^0.1.3"
-    is-primitive "^2.0.0"
-
-relateurl@0.2.x:
-  version "0.2.7"
-  resolved "https://registry.yarnpkg.com/relateurl/-/relateurl-0.2.7.tgz#54dbf377e51440aca90a4cd274600d3ff2d888a9"
-
-remove-trailing-separator@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.0.1.tgz#615ebb96af559552d4bf4057c8436d486ab63cc4"
-
-repeat-element@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.2.tgz#ef089a178d1483baae4d93eb98b4f9e4e11d990a"
-
-repeat-string@^1.5.2:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
-
-request@^2.81.0:
-  version "2.81.0"
-  resolved "https://registry.yarnpkg.com/request/-/request-2.81.0.tgz#c6928946a0e06c5f8d6f8a9333469ffda46298a0"
-  dependencies:
-    aws-sign2 "~0.6.0"
-    aws4 "^1.2.1"
-    caseless "~0.12.0"
-    combined-stream "~1.0.5"
-    extend "~3.0.0"
-    forever-agent "~0.6.1"
-    form-data "~2.1.1"
-    har-validator "~4.2.1"
-    hawk "~3.1.3"
-    http-signature "~1.1.0"
-    is-typedarray "~1.0.0"
-    isstream "~0.1.2"
-    json-stringify-safe "~5.0.1"
-    mime-types "~2.1.7"
-    oauth-sign "~0.8.1"
-    performance-now "^0.2.0"
-    qs "~6.4.0"
-    safe-buffer "^5.0.1"
-    stringstream "~0.0.4"
-    tough-cookie "~2.3.0"
-    tunnel-agent "^0.6.0"
-    uuid "^3.0.0"
-
-require-directory@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
-
-require-main-filename@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
-
-right-align@^0.1.1:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef"
-  dependencies:
-    align-text "^0.1.1"
-
-rimraf@2, rimraf@^2.5.1, rimraf@^2.6.1:
-  version "2.6.1"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d"
-  dependencies:
-    glob "^7.0.5"
-
-ripemd160@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-1.0.1.tgz#93a4bbd4942bc574b69a8fa57c71de10ecca7d6e"
-
-safe-buffer@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.0.1.tgz#d263ca54696cd8a306b5ca6551e92de57918fbe7"
-
-"semver@2 || 3 || 4 || 5", semver@^5.3.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f"
-
-set-blocking@^2.0.0, set-blocking@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
-
-set-immediate-shim@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
-
-setimmediate@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-
-sha.js@^2.3.6:
-  version "2.4.8"
-  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.8.tgz#37068c2c476b6baf402d14a49c67f597921f634f"
-  dependencies:
-    inherits "^2.0.1"
-
-signal-exit@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
-
-sntp@1.x.x:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/sntp/-/sntp-1.0.9.tgz#6541184cc90aeea6c6e7b35e2659082443c66198"
-  dependencies:
-    hoek "2.x.x"
-
-source-list-map@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-1.1.1.tgz#1a33ac210ca144d1e561f906ebccab5669ff4cb4"
-
-source-map@0.5.x, source-map@^0.5.3, source-map@~0.5.1, source-map@~0.5.3:
-  version "0.5.6"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.6.tgz#75ce38f52bf0733c5a7f0c118d81334a2bb5f412"
-
-source-map@~0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.2.0.tgz#dab73fbcfc2ba819b4de03bd6f6eaa48164b3f9d"
-  dependencies:
-    amdefine ">=0.0.4"
-
-spdx-correct@~1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-1.0.2.tgz#4b3073d933ff51f3912f03ac5519498a4150db40"
-  dependencies:
-    spdx-license-ids "^1.0.2"
-
-spdx-expression-parse@~1.0.0:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz#9bdf2f20e1f40ed447fbe273266191fced51626c"
-
-spdx-license-ids@^1.0.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz#c9df7a3424594ade6bd11900d596696dc06bac57"
-
-sshpk@^1.7.0:
-  version "1.13.0"
-  resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.13.0.tgz#ff2a3e4fd04497555fed97b39a0fd82fafb3a33c"
-  dependencies:
-    asn1 "~0.2.3"
-    assert-plus "^1.0.0"
-    dashdash "^1.12.0"
-    getpass "^0.1.1"
-  optionalDependencies:
-    bcrypt-pbkdf "^1.0.0"
-    ecc-jsbn "~0.1.1"
-    jodid25519 "^1.0.0"
-    jsbn "~0.1.0"
-    tweetnacl "~0.14.0"
-
-stream-browserify@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-2.0.1.tgz#66266ee5f9bdb9940a4e4514cafb43bb71e5c9db"
-  dependencies:
-    inherits "~2.0.1"
-    readable-stream "^2.0.2"
-
-stream-http@^2.3.1:
-  version "2.7.0"
-  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.7.0.tgz#cec1f4e3b494bc4a81b451808970f8b20b4ed5f6"
-  dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.2.6"
-    to-arraybuffer "^1.0.0"
-    xtend "^4.0.0"
-
-string-width@^1.0.1, string-width@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
-  dependencies:
-    code-point-at "^1.0.0"
-    is-fullwidth-code-point "^1.0.0"
-    strip-ansi "^3.0.0"
-
-string_decoder@^0.10.25:
-  version "0.10.31"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
-
-string_decoder@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.0.0.tgz#f06f41157b664d86069f84bdbdc9b0d8ab281667"
-  dependencies:
-    buffer-shims "~1.0.0"
-
-stringstream@~0.0.4:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/stringstream/-/stringstream-0.0.5.tgz#4e484cd4de5a0bbbee18e46307710a8a81621878"
-
-strip-ansi@^3.0.0, strip-ansi@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
-  dependencies:
-    ansi-regex "^2.0.0"
-
-strip-bom@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
-  dependencies:
-    is-utf8 "^0.2.0"
-
-strip-json-comments@~2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
-
-supports-color@^3.1.0:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.2.3.tgz#65ac0504b3954171d8a64946b2ae3cbb8a5f54f6"
-  dependencies:
-    has-flag "^1.0.0"
-
-tapable@^0.2.5, tapable@~0.2.5:
-  version "0.2.6"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-0.2.6.tgz#206be8e188860b514425375e6f1ae89bfb01fd8d"
-
-tar-pack@^3.4.0:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/tar-pack/-/tar-pack-3.4.0.tgz#23be2d7f671a8339376cbdb0b8fe3fdebf317984"
-  dependencies:
-    debug "^2.2.0"
-    fstream "^1.0.10"
-    fstream-ignore "^1.0.5"
-    once "^1.3.3"
-    readable-stream "^2.1.4"
-    rimraf "^2.5.1"
-    tar "^2.2.1"
-    uid-number "^0.0.6"
-
-tar@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-2.2.1.tgz#8e4d2a256c0e2185c6b18ad694aec968b83cb1d1"
-  dependencies:
-    block-stream "*"
-    fstream "^1.0.2"
-    inherits "2"
-
-through2@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.3.tgz#0004569b37c7c74ba39c43f3ced78d1ad94140be"
-  dependencies:
-    readable-stream "^2.1.5"
-    xtend "~4.0.1"
-
-timers-browserify@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.2.tgz#ab4883cf597dcd50af211349a00fbca56ac86b86"
-  dependencies:
-    setimmediate "^1.0.4"
-
-to-arraybuffer@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz#7d229b1fcc637e466ca081180836a7aabff83f43"
-
-tough-cookie@~2.3.0:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.3.2.tgz#f081f76e4c85720e6c37a5faced737150d84072a"
-  dependencies:
-    punycode "^1.4.1"
-
-tty-browserify@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
-
-tunnel-agent@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
-  dependencies:
-    safe-buffer "^5.0.1"
-
-tweetnacl@^0.14.3, tweetnacl@~0.14.0:
-  version "0.14.5"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
-
-type-check@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
-  dependencies:
-    prelude-ls "~1.1.2"
-
-uglify-js@^2.4.19, uglify-js@^2.8.5, uglify-js@~2.8.22:
-  version "2.8.22"
-  resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-2.8.22.tgz#d54934778a8da14903fa29a326fb24c0ab51a1a0"
-  dependencies:
-    source-map "~0.5.1"
-    yargs "~3.10.0"
-  optionalDependencies:
-    uglify-to-browserify "~1.0.0"
-
-uglify-to-browserify@~1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7"
-
-uid-number@^0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/uid-number/-/uid-number-0.0.6.tgz#0ea10e8035e8eb5b8e4449f06da1c730663baa81"
-
-upper-case@^1.1.1:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/upper-case/-/upper-case-1.1.3.tgz#f6b4501c2ec4cdd26ba78be7222961de77621598"
-
-url@^0.11.0:
-  version "0.11.0"
-  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
-  dependencies:
-    punycode "1.3.2"
-    querystring "0.2.0"
-
-util-deprecate@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
-
-util@0.10.3, util@^0.10.3:
-  version "0.10.3"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.10.3.tgz#7afb1afe50805246489e3db7fe0ed379336ac0f9"
-  dependencies:
-    inherits "2.0.1"
-
-uuid@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.0.1.tgz#6544bba2dfda8c1cf17e629a3a305e2bb1fee6c1"
-
-validate-npm-package-license@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz#2804babe712ad3379459acfbe24746ab2c303fbc"
-  dependencies:
-    spdx-correct "~1.0.0"
-    spdx-expression-parse "~1.0.0"
-
-verror@1.3.6:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/verror/-/verror-1.3.6.tgz#cff5df12946d297d2baaefaa2689e25be01c005c"
-  dependencies:
-    extsprintf "1.0.2"
-
-vm-browserify@0.0.4:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-0.0.4.tgz#5d7ea45bbef9e4a6ff65f95438e0a87c357d5a73"
-  dependencies:
-    indexof "0.0.1"
-
-watchpack@^1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-1.3.1.tgz#7d8693907b28ce6013e7f3610aa2a1acf07dad87"
-  dependencies:
-    async "^2.1.2"
-    chokidar "^1.4.3"
-    graceful-fs "^4.1.2"
-
-wc-loader@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/wc-loader/-/wc-loader-1.1.3.tgz#36eb6f7ca3e7bc92c36eac78b9893cc9a4ece4d9"
-  dependencies:
-    html-minifier "^3.4.1"
-    loader-utils "^0.2.16"
-    lodash "^4.17.4"
-    object-assign "^4.1.0"
-    parse5 "^3.0.1"
-    polyclean "^1.3.1"
-
-webpack-sources@^0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-0.2.3.tgz#17c62bfaf13c707f9d02c479e0dcdde8380697fb"
-  dependencies:
-    source-list-map "^1.1.1"
-    source-map "~0.5.3"
-
-webpack@^2.4.1:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-2.4.1.tgz#15a91dbe34966d8a4b99c7d656efd92a2e5a6f6a"
-  dependencies:
-    acorn "^5.0.0"
-    acorn-dynamic-import "^2.0.0"
-    ajv "^4.7.0"
-    ajv-keywords "^1.1.1"
-    async "^2.1.2"
-    enhanced-resolve "^3.0.0"
-    interpret "^1.0.0"
-    json-loader "^0.5.4"
-    json5 "^0.5.1"
-    loader-runner "^2.3.0"
-    loader-utils "^0.2.16"
-    memory-fs "~0.4.1"
-    mkdirp "~0.5.0"
-    node-libs-browser "^2.0.0"
-    source-map "^0.5.3"
-    supports-color "^3.1.0"
-    tapable "~0.2.5"
-    uglify-js "^2.8.5"
-    watchpack "^1.3.1"
-    webpack-sources "^0.2.3"
-    yargs "^6.0.0"
-
-which-module@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/which-module/-/which-module-1.0.0.tgz#bba63ca861948994ff307736089e3b96026c2a4f"
-
-wide-align@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.0.tgz#40edde802a71fea1f070da3e62dcda2e7add96ad"
-  dependencies:
-    string-width "^1.0.1"
-
-window-size@0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d"
-
-wordwrap@0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f"
-
-wordwrap@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
-
-wrap-ansi@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
-  dependencies:
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
-
-xml-char-classes@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/xml-char-classes/-/xml-char-classes-1.0.0.tgz#64657848a20ffc5df583a42ad8a277b4512bbc4d"
-
-xtend@^4.0.0, xtend@~4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af"
-
-y18n@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.1.tgz#6d15fba884c08679c0d77e88e7759e811e07fa41"
-
-yargs-parser@^4.2.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-4.2.1.tgz#29cceac0dc4f03c6c87b4a9f217dd18c9f74871c"
-  dependencies:
-    camelcase "^3.0.0"
-
-yargs@^6.0.0:
-  version "6.6.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-6.6.0.tgz#782ec21ef403345f830a808ca3d513af56065208"
-  dependencies:
-    camelcase "^3.0.0"
-    cliui "^3.2.0"
-    decamelize "^1.1.1"
-    get-caller-file "^1.0.1"
-    os-locale "^1.4.0"
-    read-pkg-up "^1.0.1"
-    require-directory "^2.1.1"
-    require-main-filename "^1.0.1"
-    set-blocking "^2.0.0"
-    string-width "^1.0.2"
-    which-module "^1.0.0"
-    y18n "^3.2.1"
-    yargs-parser "^4.2.0"
-
-yargs@~3.10.0:
-  version "3.10.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.10.0.tgz#f7ee7bd857dd7c1d2d38c0e74efbd681d1431fd1"
-  dependencies:
-    camelcase "^1.0.2"
-    cliui "^2.1.0"
-    decamelize "^1.0.0"
-    window-size "0.1.0"
-=======
 "@polymer/polymer@https://github.com/Polymer/polymer#7d460dd3fafa461eaef0a4ce647e4e244a87e65e":
   version "1.8.1"
   resolved "https://github.com/Polymer/polymer#7d460dd3fafa461eaef0a4ce647e4e244a87e65e"
->>>>>>> polymer-1