Vulcanize MD History to improve page-load performance

chrome/browser/resources/md_history/app.crisper.js

+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+function assert(condition, opt_message) {
+  if (!condition) {
+    var message = 'Assertion failed';
+    if (opt_message) message = message + ': ' + opt_message;
+    var error = new Error(message);
+    var global = function() {
+      return this;
+    }();
+    if (global.traceAssertionsForTesting) console.warn(error.stack);
+    throw error;
+  }
+  return condition;
+}
+
+function assertNotReached(opt_message) {
+  assert(false, opt_message || 'Unreachable code hit');
+}
+
+function assertInstanceof(value, type, opt_message) {
+  if (!(value instanceof type)) {
+    assertNotReached(opt_message || 'Value ' + value + ' is not a[n] ' + (type.name || typeof type));
+  }
+  return value;
+}
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+function PromiseResolver() {
+  this.resolve_;
+  this.reject_;
+  this.promise_ = new Promise(function(resolve, reject) {
+    this.resolve_ = resolve;
+    this.reject_ = reject;
+  }.bind(this));
+}
+
+PromiseResolver.prototype = {
+  get promise() {
+    return this.promise_;
+  },
+  set promise(p) {
+    assertNotReached();
+  },
+  get resolve() {
+    return this.resolve_;
+  },
+  set resolve(r) {
+    assertNotReached();
+  },
+  get reject() {
+    return this.reject_;
+  },
+  set reject(s) {
+    assertNotReached();
+  }
+};
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var global = this;
+
+var WebUIListener;
+
+var cr = cr || function() {
+  'use strict';
+  function exportPath(name, opt_object, opt_objectToExportTo) {
+    var parts = name.split('.');
+    var cur = opt_objectToExportTo || global;
+    for (var part; parts.length && (part = parts.shift()); ) {
+      if (!parts.length && opt_object !== undefined) {
+        cur[part] = opt_object;
+      } else if (part in cur) {
+        cur = cur[part];
+      } else {
+        cur = cur[part] = {};
+      }
+    }
+    return cur;
+  }
+  function dispatchPropertyChange(target, propertyName, newValue, oldValue) {
+    var e = new Event(propertyName + 'Change');
+    e.propertyName = propertyName;
+    e.newValue = newValue;
+    e.oldValue = oldValue;
+    target.dispatchEvent(e);
+  }
+  function getAttributeName(jsName) {
+    return jsName.replace(/([A-Z])/g, '-$1').toLowerCase();
+  }
+  var PropertyKind = {
+    JS: 'js',
+    ATTR: 'attr',
+    BOOL_ATTR: 'boolAttr'
+  };
+  function getGetter(name, kind) {
+    switch (kind) {
+     case PropertyKind.JS:
+      var privateName = name + '_';
+      return function() {
+        return this[privateName];
+      };
+
+     case PropertyKind.ATTR:
+      var attributeName = getAttributeName(name);
+      return function() {
+        return this.getAttribute(attributeName);
+      };
+
+     case PropertyKind.BOOL_ATTR:
+      var attributeName = getAttributeName(name);
+      return function() {
+        return this.hasAttribute(attributeName);
+      };
+    }
+    throw 'not reached';
+  }
+  function getSetter(name, kind, opt_setHook) {
+    switch (kind) {
+     case PropertyKind.JS:
+      var privateName = name + '_';
+      return function(value) {
+        var oldValue = this[name];
+        if (value !== oldValue) {
+          this[privateName] = value;
+          if (opt_setHook) opt_setHook.call(this, value, oldValue);
+          dispatchPropertyChange(this, name, value, oldValue);
+        }
+      };
+
+     case PropertyKind.ATTR:
+      var attributeName = getAttributeName(name);
+      return function(value) {
+        var oldValue = this[name];
+        if (value !== oldValue) {
+          if (value == undefined) this.removeAttribute(attributeName); else this.setAttribute(attributeName, value);
+          if (opt_setHook) opt_setHook.call(this, value, oldValue);
+          dispatchPropertyChange(this, name, value, oldValue);
+        }
+      };
+
+     case PropertyKind.BOOL_ATTR:
+      var attributeName = getAttributeName(name);
+      return function(value) {
+        var oldValue = this[name];
+        if (value !== oldValue) {
+          if (value) this.setAttribute(attributeName, name); else this.removeAttribute(attributeName);
+          if (opt_setHook) opt_setHook.call(this, value, oldValue);
+          dispatchPropertyChange(this, name, value, oldValue);
+        }
+      };
+    }
+    throw 'not reached';
+  }
+  function defineProperty(obj, name, opt_kind, opt_setHook) {
+    if (typeof obj == 'function') obj = obj.prototype;
+    var kind = opt_kind || PropertyKind.JS;
+    if (!obj.__lookupGetter__(name)) obj.__defineGetter__(name, getGetter(name, kind));
+    if (!obj.__lookupSetter__(name)) obj.__defineSetter__(name, getSetter(name, kind, opt_setHook));
+  }
+  var uidCounter = 1;
+  function createUid() {
+    return uidCounter++;
+  }
+  function getUid(item) {
+    if (item.hasOwnProperty('uid')) return item.uid;
+    return item.uid = createUid();
+  }
+  function dispatchSimpleEvent(target, type, opt_bubbles, opt_cancelable) {
+    var e = new Event(type, {
+      bubbles: opt_bubbles,
+      cancelable: opt_cancelable === undefined || opt_cancelable
+    });
+    return target.dispatchEvent(e);
+  }
+  function define(name, fun) {
+    var obj = exportPath(name);
+    var exports = fun();
+    for (var propertyName in exports) {
+      var propertyDescriptor = Object.getOwnPropertyDescriptor(exports, propertyName);
+      if (propertyDescriptor) Object.defineProperty(obj, propertyName, propertyDescriptor);
+    }
+  }
+  function addSingletonGetter(ctor) {
+    ctor.getInstance = function() {
+      return ctor.instance_ || (ctor.instance_ = new ctor());
+    };
+  }
+  function makePublic(ctor, methods, opt_target) {
+    methods.forEach(function(method) {
+      ctor[method] = function() {
+        var target = opt_target ? document.getElementById(opt_target) : ctor.getInstance();
+        return target[method + '_'].apply(target, arguments);
+      };
+    });
+  }
+  var chromeSendResolverMap = {};
+  function webUIResponse(id, isSuccess, response) {
+    var resolver = chromeSendResolverMap[id];
+    delete chromeSendResolverMap[id];
+    if (isSuccess) resolver.resolve(response); else resolver.reject(response);
+  }
+  function sendWithPromise(methodName, var_args) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    var promiseResolver = new PromiseResolver();
+    var id = methodName + '_' + createUid();
+    chromeSendResolverMap[id] = promiseResolver;
+    chrome.send(methodName, [ id ].concat(args));
+    return promiseResolver.promise;
+  }
+  var webUIListenerMap = {};
+  function webUIListenerCallback(event, var_args) {
+    var eventListenersMap = webUIListenerMap[event];
+    if (!eventListenersMap) {
+      return;
+    }
+    var args = Array.prototype.slice.call(arguments, 1);
+    for (var listenerId in eventListenersMap) {
+      eventListenersMap[listenerId].apply(null, args);
+    }
+  }
+  function addWebUIListener(eventName, callback) {
+    webUIListenerMap[eventName] = webUIListenerMap[eventName] || {};
+    var uid = createUid();
+    webUIListenerMap[eventName][uid] = callback;
+    return {
+      eventName: eventName,
+      uid: uid
+    };
+  }
+  function removeWebUIListener(listener) {
+    var listenerExists = webUIListenerMap[listener.eventName] && webUIListenerMap[listener.eventName][listener.uid];
+    if (listenerExists) {
+      delete webUIListenerMap[listener.eventName][listener.uid];
+      return true;
+    }
+    return false;
+  }
+  return {
+    addSingletonGetter: addSingletonGetter,
+    createUid: createUid,
+    define: define,
+    defineProperty: defineProperty,
+    dispatchPropertyChange: dispatchPropertyChange,
+    dispatchSimpleEvent: dispatchSimpleEvent,
+    exportPath: exportPath,
+    getUid: getUid,
+    makePublic: makePublic,
+    PropertyKind: PropertyKind,
+    addWebUIListener: addWebUIListener,
+    removeWebUIListener: removeWebUIListener,
+    sendWithPromise: sendWithPromise,
+    webUIListenerCallback: webUIListenerCallback,
+    webUIResponse: webUIResponse,
+    get doc() {
+      return document;
+    },
+    get isMac() {
+      return /Mac/.test(navigator.platform);
+    },
+    get isWindows() {
+      return /Win/.test(navigator.platform);
+    },
+    get isChromeOS() {
+      return /CrOS/.test(navigator.userAgent);
+    },
+    get isLinux() {
+      return /Linux/.test(navigator.userAgent);
+    },
+    get isAndroid() {
+      return /Android/.test(navigator.userAgent);
+    },
+    get isIOS() {
+      return /iPad|iPhone|iPod/.test(navigator.platform);
+    }
+  };
+}();
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+cr.define('cr.ui', function() {
+  function decorate(source, constr) {
+    var elements;
+    if (typeof source == 'string') elements = cr.doc.querySelectorAll(source); else elements = [ source ];
+    for (var i = 0, el; el = elements[i]; i++) {
+      if (!(el instanceof constr)) constr.decorate(el);
+    }
+  }
+  function createElementHelper(tagName, opt_bag) {
+    var doc;
+    if (opt_bag && opt_bag.ownerDocument) doc = opt_bag.ownerDocument; else doc = cr.doc;
+    return doc.createElement(tagName);
+  }
+  function define(tagNameOrFunction) {
+    var createFunction, tagName;
+    if (typeof tagNameOrFunction == 'function') {
+      createFunction = tagNameOrFunction;
+      tagName = '';
+    } else {
+      createFunction = createElementHelper;
+      tagName = tagNameOrFunction;
+    }
+    function f(opt_propertyBag) {
+      var el = createFunction(tagName, opt_propertyBag);
+      f.decorate(el);
+      for (var propertyName in opt_propertyBag) {
+        el[propertyName] = opt_propertyBag[propertyName];
+      }
+      return el;
+    }
+    f.decorate = function(el) {
+      el.__proto__ = f.prototype;
+      el.decorate();
+    };
+    return f;
+  }
+  function limitInputWidth(el, parentEl, min, opt_scale) {
+    el.style.width = '10px';
+    var doc = el.ownerDocument;
+    var win = doc.defaultView;
+    var computedStyle = win.getComputedStyle(el);
+    var parentComputedStyle = win.getComputedStyle(parentEl);
+    var rtl = computedStyle.direction == 'rtl';
+    var inputRect = el.getBoundingClientRect();
+    var parentRect = parentEl.getBoundingClientRect();
+    var startPos = rtl ? parentRect.right - inputRect.right : inputRect.left - parentRect.left;
+    var inner = parseInt(computedStyle.borderLeftWidth, 10) + parseInt(computedStyle.paddingLeft, 10) + parseInt(computedStyle.paddingRight, 10) + parseInt(computedStyle.borderRightWidth, 10);
+    var parentPadding = rtl ? parseInt(parentComputedStyle.paddingLeft, 10) : parseInt(parentComputedStyle.paddingRight, 10);
+    var max = parentEl.clientWidth - startPos - inner - parentPadding;
+    if (opt_scale) max *= opt_scale;
+    function limit() {
+      if (el.scrollWidth > max) {
+        el.style.width = max + 'px';
+      } else {
+        el.style.width = 0;
+        var sw = el.scrollWidth;
+        if (sw < min) {
+          el.style.width = min + 'px';
+        } else {
+          el.style.width = sw + 'px';
+        }
+      }
+    }
+    el.addEventListener('input', limit);
+    limit();
+  }
+  function toCssPx(pixels) {
+    if (!window.isFinite(pixels)) console.error('Pixel value is not a number: ' + pixels);
+    return Math.round(pixels) + 'px';
+  }
+  function swallowDoubleClick(e) {
+    var doc = e.target.ownerDocument;
+    var counter = Math.min(1, e.detail);
+    function swallow(e) {
+      e.stopPropagation();
+      e.preventDefault();
+    }
+    function onclick(e) {
+      if (e.detail > counter) {
+        counter = e.detail;
+        swallow(e);
+      } else {
+        doc.removeEventListener('dblclick', swallow, true);
+        doc.removeEventListener('click', onclick, true);
+      }
+    }
+    setTimeout(function() {
+      doc.addEventListener('click', onclick, true);
+      doc.addEventListener('dblclick', swallow, true);
+    }, 0);
+  }
+  return {
+    decorate: decorate,
+    define: define,
+    limitInputWidth: limitInputWidth,
+    toCssPx: toCssPx,
+    swallowDoubleClick: swallowDoubleClick
+  };
+});
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+cr.define('cr.ui', function() {
+  function KeyboardShortcut(shortcut) {
+    var mods = {};
+    var ident = '';
+    shortcut.split('|').forEach(function(part) {
+      var partLc = part.toLowerCase();
+      switch (partLc) {
+       case 'alt':
+       case 'ctrl':
+       case 'meta':
+       case 'shift':
+        mods[partLc + 'Key'] = true;
+        break;
+
+       default:
+        if (ident) throw Error('Invalid shortcut');
+        ident = part;
+      }
+    });
+    this.ident_ = ident;
+    this.mods_ = mods;
+  }
+  KeyboardShortcut.prototype = {
+    matchesEvent: function(e) {
+      if (e.key == this.ident_) {
+        var mods = this.mods_;
+        return [ 'altKey', 'ctrlKey', 'metaKey', 'shiftKey' ].every(function(k) {
+          return e[k] == !!mods[k];
+        });
+      }
+      return false;
+    }
+  };
+  var Command = cr.ui.define('command');
+  Command.prototype = {
+    __proto__: HTMLElement.prototype,
+    decorate: function() {
+      CommandManager.init(assert(this.ownerDocument));
+      if (this.hasAttribute('shortcut')) this.shortcut = this.getAttribute('shortcut');
+    },
+    execute: function(opt_element) {
+      if (this.disabled) return;
+      var doc = this.ownerDocument;
+      if (doc.activeElement) {
+        var e = new Event('command', {
+          bubbles: true
+        });
+        e.command = this;
+        (opt_element || doc.activeElement).dispatchEvent(e);
+      }
+    },
+    canExecuteChange: function(opt_node) {
+      dispatchCanExecuteEvent(this, opt_node || this.ownerDocument.activeElement);
+    },
+    shortcut_: '',
+    get shortcut() {
+      return this.shortcut_;
+    },
+    set shortcut(shortcut) {
+      var oldShortcut = this.shortcut_;
+      if (shortcut !== oldShortcut) {
+        this.keyboardShortcuts_ = shortcut.split(/\s+/).map(function(shortcut) {
+          return new KeyboardShortcut(shortcut);
+        });
+        this.shortcut_ = shortcut;
+        cr.dispatchPropertyChange(this, 'shortcut', this.shortcut_, oldShortcut);
+      }
+    },
+    matchesEvent: function(e) {
+      if (!this.keyboardShortcuts_) return false;
+      return this.keyboardShortcuts_.some(function(keyboardShortcut) {
+        return keyboardShortcut.matchesEvent(e);
+      });
+    }
+  };
+  cr.defineProperty(Command, 'label', cr.PropertyKind.ATTR);
+  cr.defineProperty(Command, 'disabled', cr.PropertyKind.BOOL_ATTR);
+  cr.defineProperty(Command, 'hidden', cr.PropertyKind.BOOL_ATTR);
+  cr.defineProperty(Command, 'checked', cr.PropertyKind.BOOL_ATTR);
+  cr.defineProperty(Command, 'hideShortcutText', cr.PropertyKind.BOOL_ATTR);
+  function dispatchCanExecuteEvent(command, target) {
+    var e = new CanExecuteEvent(command);
+    target.dispatchEvent(e);
+    command.disabled = !e.canExecute;
+  }
+  var commandManagers = {};
+  function CommandManager(doc) {
+    doc.addEventListener('focus', this.handleFocus_.bind(this), true);
+    doc.addEventListener('keydown', this.handleKeyDown_.bind(this), false);
+  }
+  CommandManager.init = function(doc) {
+    var uid = cr.getUid(doc);
+    if (!(uid in commandManagers)) {
+      commandManagers[uid] = new CommandManager(doc);
+    }
+  };
+  CommandManager.prototype = {
+    handleFocus_: function(e) {
+      var target = e.target;
+      if (target.menu || target.command) return;
+      var commands = Array.prototype.slice.call(target.ownerDocument.querySelectorAll('command'));
+      commands.forEach(function(command) {
+        dispatchCanExecuteEvent(command, target);
+      });
+    },
+    handleKeyDown_: function(e) {
+      var target = e.target;
+      var commands = Array.prototype.slice.call(target.ownerDocument.querySelectorAll('command'));
+      for (var i = 0, command; command = commands[i]; i++) {
+        if (command.matchesEvent(e)) {
+          command.canExecuteChange();
+          if (!command.disabled) {
+            e.preventDefault();
+            e.stopPropagation();
+            command.execute();
+            return;
+          }
+        }
+      }
+    }
+  };
+  function CanExecuteEvent(command) {
+    var e = new Event('canExecute', {
+      bubbles: true,
+      cancelable: true
+    });
+    e.__proto__ = CanExecuteEvent.prototype;
+    e.command = command;
+    return e;
+  }
+  CanExecuteEvent.prototype = {
+    __proto__: Event.prototype,
+    command: null,
+    canExecute_: false,
+    get canExecute() {
+      return this.canExecute_;
+    },
+    set canExecute(canExecute) {
+      this.canExecute_ = !!canExecute;
+      this.stopPropagation();
+      this.preventDefault();
+    }
+  };
+  return {
+    Command: Command,
+    CanExecuteEvent: CanExecuteEvent
+  };
+});
+
+Polymer({
+  is: 'app-drawer',
+  properties: {
+    opened: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      reflectToAttribute: true
+    },
+    persistent: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    align: {
+      type: String,
+      value: 'left'
+    },
+    position: {
+      type: String,
+      readOnly: true,
+      value: 'left',
+      reflectToAttribute: true
+    },
+    swipeOpen: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    noFocusTrap: {
+      type: Boolean,
+      value: false
+    }
+  },
+  observers: [ 'resetLayout(position)', '_resetPosition(align, isAttached)' ],
+  _translateOffset: 0,
+  _trackDetails: null,
+  _drawerState: 0,
+  _boundEscKeydownHandler: null,
+  _firstTabStop: null,
+  _lastTabStop: null,
+  ready: function() {
+    this.setScrollDirection('y');
+    this._setTransitionDuration('0s');
+  },
+  attached: function() {
+    Polymer.RenderStatus.afterNextRender(this, function() {
+      this._setTransitionDuration('');
+      this._boundEscKeydownHandler = this._escKeydownHandler.bind(this);
+      this._resetDrawerState();
+      this.listen(this, 'track', '_track');
+      this.addEventListener('transitionend', this._transitionend.bind(this));
+      this.addEventListener('keydown', this._tabKeydownHandler.bind(this));
+    });
+  },
+  detached: function() {
+    document.removeEventListener('keydown', this._boundEscKeydownHandler);
+  },
+  open: function() {
+    this.opened = true;
+  },
+  close: function() {
+    this.opened = false;
+  },
+  toggle: function() {
+    this.opened = !this.opened;
+  },
+  getWidth: function() {
+    return this.$.contentContainer.offsetWidth;
+  },
+  resetLayout: function() {
+    this.debounce('_resetLayout', function() {
+      this.fire('app-drawer-reset-layout');
+    }, 1);
+  },
+  _isRTL: function() {
+    return window.getComputedStyle(this).direction === 'rtl';
+  },
+  _resetPosition: function() {
+    switch (this.align) {
+     case 'start':
+      this._setPosition(this._isRTL() ? 'right' : 'left');
+      return;
+
+     case 'end':
+      this._setPosition(this._isRTL() ? 'left' : 'right');
+      return;
+    }
+    this._setPosition(this.align);
+  },
+  _escKeydownHandler: function(event) {
+    var ESC_KEYCODE = 27;
+    if (event.keyCode === ESC_KEYCODE) {
+      event.preventDefault();
+      this.close();
+    }
+  },
+  _track: function(event) {
+    if (this.persistent) {
+      return;
+    }
+    event.preventDefault();
+    switch (event.detail.state) {
+     case 'start':
+      this._trackStart(event);
+      break;
+
+     case 'track':
+      this._trackMove(event);
+      break;
+
+     case 'end':
+      this._trackEnd(event);
+      break;
+    }
+  },
+  _trackStart: function(event) {
+    this._drawerState = this._DRAWER_STATE.TRACKING;
+    this._setTransitionDuration('0s');
+    this.style.visibility = 'visible';
+    var rect = this.$.contentContainer.getBoundingClientRect();
+    if (this.position === 'left') {
+      this._translateOffset = rect.left;
+    } else {
+      this._translateOffset = rect.right - window.innerWidth;
+    }
+    this._trackDetails = [];
+  },
+  _trackMove: function(event) {
+    this._translateDrawer(event.detail.dx + this._translateOffset);
+    this._trackDetails.push({
+      dx: event.detail.dx,
+      timeStamp: Date.now()
+    });
+  },
+  _trackEnd: function(event) {
+    var x = event.detail.dx + this._translateOffset;
+    var drawerWidth = this.getWidth();
+    var isPositionLeft = this.position === 'left';
+    var isInEndState = isPositionLeft ? x >= 0 || x <= -drawerWidth : x <= 0 || x >= drawerWidth;
+    if (!isInEndState) {
+      var trackDetails = this._trackDetails;
+      this._trackDetails = null;
+      this._flingDrawer(event, trackDetails);
+      if (this._drawerState === this._DRAWER_STATE.FLINGING) {
+        return;
+      }
+    }
+    var halfWidth = drawerWidth / 2;
+    if (event.detail.dx < -halfWidth) {
+      this.opened = this.position === 'right';
+    } else if (event.detail.dx > halfWidth) {
+      this.opened = this.position === 'left';
+    }
+    if (isInEndState) {
+      this._resetDrawerState();
+    }
+    this._setTransitionDuration('');
+    this._resetDrawerTranslate();
+    this.style.visibility = '';
+  },
+  _calculateVelocity: function(event, trackDetails) {
+    var now = Date.now();
+    var timeLowerBound = now - 100;
+    var trackDetail;
+    var min = 0;
+    var max = trackDetails.length - 1;
+    while (min <= max) {
+      var mid = min + max >> 1;
+      var d = trackDetails[mid];
+      if (d.timeStamp >= timeLowerBound) {
+        trackDetail = d;
+        max = mid - 1;
+      } else {
+        min = mid + 1;
+      }
+    }
+    if (trackDetail) {
+      var dx = event.detail.dx - trackDetail.dx;
+      var dt = now - trackDetail.timeStamp || 1;
+      return dx / dt;
+    }
+    return 0;
+  },
+  _flingDrawer: function(event, trackDetails) {
+    var velocity = this._calculateVelocity(event, trackDetails);
+    if (Math.abs(velocity) < this._MIN_FLING_THRESHOLD) {
+      return;
+    }
+    this._drawerState = this._DRAWER_STATE.FLINGING;
+    var x = event.detail.dx + this._translateOffset;
+    var drawerWidth = this.getWidth();
+    var isPositionLeft = this.position === 'left';
+    var isVelocityPositive = velocity > 0;
+    var isClosingLeft = !isVelocityPositive && isPositionLeft;
+    var isClosingRight = isVelocityPositive && !isPositionLeft;
+    var dx;
+    if (isClosingLeft) {
+      dx = -(x + drawerWidth);
+    } else if (isClosingRight) {
+      dx = drawerWidth - x;
+    } else {
+      dx = -x;
+    }
+    if (isVelocityPositive) {
+      velocity = Math.max(velocity, this._MIN_TRANSITION_VELOCITY);
+      this.opened = this.position === 'left';
+    } else {
+      velocity = Math.min(velocity, -this._MIN_TRANSITION_VELOCITY);
+      this.opened = this.position === 'right';
+    }
+    this._setTransitionDuration(this._FLING_INITIAL_SLOPE * dx / velocity + 'ms');
+    this._setTransitionTimingFunction(this._FLING_TIMING_FUNCTION);
+    this._resetDrawerTranslate();
+  },
+  _transitionend: function(event) {
+    var target = Polymer.dom(event).rootTarget;
+    if (target === this.$.contentContainer || target === this.$.scrim) {
+      if (this._drawerState === this._DRAWER_STATE.FLINGING) {
+        this._setTransitionDuration('');
+        this._setTransitionTimingFunction('');
+        this.style.visibility = '';
+      }
+      this._resetDrawerState();
+    }
+  },
+  _setTransitionDuration: function(duration) {
+    this.$.contentContainer.style.transitionDuration = duration;
+    this.$.scrim.style.transitionDuration = duration;
+  },
+  _setTransitionTimingFunction: function(timingFunction) {
+    this.$.contentContainer.style.transitionTimingFunction = timingFunction;
+    this.$.scrim.style.transitionTimingFunction = timingFunction;
+  },
+  _translateDrawer: function(x) {
+    var drawerWidth = this.getWidth();
+    if (this.position === 'left') {
+      x = Math.max(-drawerWidth, Math.min(x, 0));
+      this.$.scrim.style.opacity = 1 + x / drawerWidth;
+    } else {
+      x = Math.max(0, Math.min(x, drawerWidth));
+      this.$.scrim.style.opacity = 1 - x / drawerWidth;
+    }
+    this.translate3d(x + 'px', '0', '0', this.$.contentContainer);
+  },
+  _resetDrawerTranslate: function() {
+    this.$.scrim.style.opacity = '';
+    this.transform('', this.$.contentContainer);
+  },
+  _resetDrawerState: function() {
+    var oldState = this._drawerState;
+    if (this.opened) {
+      this._drawerState = this.persistent ? this._DRAWER_STATE.OPENED_PERSISTENT : this._DRAWER_STATE.OPENED;
+    } else {
+      this._drawerState = this._DRAWER_STATE.CLOSED;
+    }
+    if (oldState !== this._drawerState) {
+      if (this._drawerState === this._DRAWER_STATE.OPENED) {
+        this._setKeyboardFocusTrap();
+        document.addEventListener('keydown', this._boundEscKeydownHandler);
+        document.body.style.overflow = 'hidden';
+      } else {
+        document.removeEventListener('keydown', this._boundEscKeydownHandler);
+        document.body.style.overflow = '';
+      }
+      if (oldState !== this._DRAWER_STATE.INIT) {
+        this.fire('app-drawer-transitioned');
+      }
+    }
+  },
+  _setKeyboardFocusTrap: function() {
+    if (this.noFocusTrap) {
+      return;
+    }
+    var focusableElementsSelector = [ 'a[href]:not([tabindex="-1"])', 'area[href]:not([tabindex="-1"])', 'input:not([disabled]):not([tabindex="-1"])', 'select:not([disabled]):not([tabindex="-1"])', 'textarea:not([disabled]):not([tabindex="-1"])', 'button:not([disabled]):not([tabindex="-1"])', 'iframe:not([tabindex="-1"])', '[tabindex]:not([tabindex="-1"])', '[contentEditable=true]:not([tabindex="-1"])' ].join(',');
+    var focusableElements = Polymer.dom(this).querySelectorAll(focusableElementsSelector);
+    if (focusableElements.length > 0) {
+      this._firstTabStop = focusableElements[0];
+      this._lastTabStop = focusableElements[focusableElements.length - 1];
+    } else {
+      this._firstTabStop = null;
+      this._lastTabStop = null;
+    }
+    var tabindex = this.getAttribute('tabindex');
+    if (tabindex && parseInt(tabindex, 10) > -1) {
+      this.focus();
+    } else if (this._firstTabStop) {
+      this._firstTabStop.focus();
+    }
+  },
+  _tabKeydownHandler: function(event) {
+    if (this.noFocusTrap) {
+      return;
+    }
+    var TAB_KEYCODE = 9;
+    if (this._drawerState === this._DRAWER_STATE.OPENED && event.keyCode === TAB_KEYCODE) {
+      if (event.shiftKey) {
+        if (this._firstTabStop && Polymer.dom(event).localTarget === this._firstTabStop) {
+          event.preventDefault();
+          this._lastTabStop.focus();
+        }
+      } else {
+        if (this._lastTabStop && Polymer.dom(event).localTarget === this._lastTabStop) {
+          event.preventDefault();
+          this._firstTabStop.focus();
+        }
+      }
+    }
+  },
+  _MIN_FLING_THRESHOLD: .2,
+  _MIN_TRANSITION_VELOCITY: 1.2,
+  _FLING_TIMING_FUNCTION: 'cubic-bezier(0.667, 1, 0.667, 1)',
+  _FLING_INITIAL_SLOPE: 1.5,
+  _DRAWER_STATE: {
+    INIT: 0,
+    OPENED: 1,
+    OPENED_PERSISTENT: 2,
+    CLOSED: 3,
+    TRACKING: 4,
+    FLINGING: 5
+  }
+});
+
+(function() {
+  'use strict';
+  Polymer({
+    is: 'iron-location',
+    properties: {
+      path: {
+        type: String,
+        notify: true,
+        value: function() {
+          return window.decodeURIComponent(window.location.pathname);
+        }
+      },
+      query: {
+        type: String,
+        notify: true,
+        value: function() {
+          return window.decodeURIComponent(window.location.search.slice(1));
+        }
+      },
+      hash: {
+        type: String,
+        notify: true,
+        value: function() {
+          return window.decodeURIComponent(window.location.hash.slice(1));
+        }
+      },
+      dwellTime: {
+        type: Number,
+        value: 2e3
+      },
+      urlSpaceRegex: {
+        type: String,
+        value: ''
+      },
+      _urlSpaceRegExp: {
+        computed: '_makeRegExp(urlSpaceRegex)'
+      },
+      _lastChangedAt: {
+        type: Number
+      },
+      _initialized: {
+        type: Boolean,
+        value: false
+      }
+    },
+    hostAttributes: {
+      hidden: true
+    },
+    observers: [ '_updateUrl(path, query, hash)' ],
+    attached: function() {
+      this.listen(window, 'hashchange', '_hashChanged');
+      this.listen(window, 'location-changed', '_urlChanged');
+      this.listen(window, 'popstate', '_urlChanged');
+      this.listen(document.body, 'click', '_globalOnClick');
+      this._lastChangedAt = window.performance.now() - (this.dwellTime - 200);
+      this._initialized = true;
+      this._urlChanged();
+    },
+    detached: function() {
+      this.unlisten(window, 'hashchange', '_hashChanged');
+      this.unlisten(window, 'location-changed', '_urlChanged');
+      this.unlisten(window, 'popstate', '_urlChanged');
+      this.unlisten(document.body, 'click', '_globalOnClick');
+      this._initialized = false;
+    },
+    _hashChanged: function() {
+      this.hash = window.decodeURIComponent(window.location.hash.substring(1));
+    },
+    _urlChanged: function() {
+      this._dontUpdateUrl = true;
+      this._hashChanged();
+      this.path = window.decodeURIComponent(window.location.pathname);
+      this.query = window.decodeURIComponent(window.location.search.substring(1));
+      this._dontUpdateUrl = false;
+      this._updateUrl();
+    },
+    _getUrl: function() {
+      var partiallyEncodedPath = window.encodeURI(this.path).replace(/\#/g, '%23').replace(/\?/g, '%3F');
+      var partiallyEncodedQuery = '';
+      if (this.query) {
+        partiallyEncodedQuery = '?' + window.encodeURI(this.query).replace(/\#/g, '%23');
+      }
+      var partiallyEncodedHash = '';
+      if (this.hash) {
+        partiallyEncodedHash = '#' + window.encodeURI(this.hash);
+      }
+      return partiallyEncodedPath + partiallyEncodedQuery + partiallyEncodedHash;
+    },
+    _updateUrl: function() {
+      if (this._dontUpdateUrl || !this._initialized) {
+        return;
+      }
+      if (this.path === window.decodeURIComponent(window.location.pathname) && this.query === window.decodeURIComponent(window.location.search.substring(1)) && this.hash === window.decodeURIComponent(window.location.hash.substring(1))) {
+        return;
+      }
+      var newUrl = this._getUrl();
+      var fullNewUrl = new URL(newUrl, window.location.protocol + '//' + window.location.host).href;
+      var now = window.performance.now();
+      var shouldReplace = this._lastChangedAt + this.dwellTime > now;
+      this._lastChangedAt = now;
+      if (shouldReplace) {
+        window.history.replaceState({}, '', fullNewUrl);
+      } else {
+        window.history.pushState({}, '', fullNewUrl);
+      }
+      this.fire('location-changed', {}, {
+        node: window
+      });
+    },
+    _globalOnClick: function(event) {
+      if (event.defaultPrevented) {
+        return;
+      }
+      var href = this._getSameOriginLinkHref(event);
+      if (!href) {
+        return;
+      }
+      event.preventDefault();
+      if (href === window.location.href) {
+        return;
+      }
+      window.history.pushState({}, '', href);
+      this.fire('location-changed', {}, {
+        node: window
+      });
+    },
+    _getSameOriginLinkHref: function(event) {
+      if (event.button !== 0) {
+        return null;
+      }
+      if (event.metaKey || event.ctrlKey) {
+        return null;
+      }
+      var eventPath = Polymer.dom(event).path;
+      var anchor = null;
+      for (var i = 0; i < eventPath.length; i++) {
+        var element = eventPath[i];
+        if (element.tagName === 'A' && element.href) {
+          anchor = element;
+          break;
+        }
+      }
+      if (!anchor) {
+        return null;
+      }
+      if (anchor.target === '_blank') {
+        return null;
+      }
+      if ((anchor.target === '_top' || anchor.target === '_parent') && window.top !== window) {
+        return null;
+      }
+      var href = anchor.href;
+      var url;
+      if (document.baseURI != null) {
+        url = new URL(href, document.baseURI);
+      } else {
+        url = new URL(href);
+      }
+      var origin;
+      if (window.location.origin) {
+        origin = window.location.origin;
+      } else {
+        origin = window.location.protocol + '//' + window.location.hostname;
+        if (window.location.port) {
+          origin += ':' + window.location.port;
+        }
+      }
+      if (url.origin !== origin) {
+        return null;
+      }
+      var normalizedHref = url.pathname + url.search + url.hash;
+      if (this._urlSpaceRegExp && !this._urlSpaceRegExp.test(normalizedHref)) {
+        return null;
+      }
+      var fullNormalizedHref = new URL(normalizedHref, window.location.href).href;
+      return fullNormalizedHref;
+    },
+    _makeRegExp: function(urlSpaceRegex) {
+      return RegExp(urlSpaceRegex);
+    }
+  });
+})();
+
+'use strict';
+
+Polymer({
+  is: 'iron-query-params',
+  properties: {
+    paramsString: {
+      type: String,
+      notify: true,
+      observer: 'paramsStringChanged'
+    },
+    paramsObject: {
+      type: Object,
+      notify: true,
+      value: function() {
+        return {};
+      }
+    },
+    _dontReact: {
+      type: Boolean,
+      value: false
+    }
+  },
+  hostAttributes: {
+    hidden: true
+  },
+  observers: [ 'paramsObjectChanged(paramsObject.*)' ],
+  paramsStringChanged: function() {
+    this._dontReact = true;
+    this.paramsObject = this._decodeParams(this.paramsString);
+    this._dontReact = false;
+  },
+  paramsObjectChanged: function() {
+    if (this._dontReact) {
+      return;
+    }
+    this.paramsString = this._encodeParams(this.paramsObject);
+  },
+  _encodeParams: function(params) {
+    var encodedParams = [];
+    for (var key in params) {
+      var value = params[key];
+      if (value === '') {
+        encodedParams.push(encodeURIComponent(key));
+      } else if (value) {
+        encodedParams.push(encodeURIComponent(key) + '=' + encodeURIComponent(value.toString()));
+      }
+    }
+    return encodedParams.join('&');
+  },
+  _decodeParams: function(paramString) {
+    var params = {};
+    paramString = (paramString || '').replace(/\+/g, '%20');
+    var paramList = paramString.split('&');
+    for (var i = 0; i < paramList.length; i++) {
+      var param = paramList[i].split('=');
+      if (param[0]) {
+        params[decodeURIComponent(param[0])] = decodeURIComponent(param[1] || '');
+      }
+    }
+    return params;
+  }
+});
+
+'use strict';
+
+Polymer.AppRouteConverterBehavior = {
+  properties: {
+    route: {
+      type: Object,
+      notify: true
+    },
+    queryParams: {
+      type: Object,
+      notify: true
+    },
+    path: {
+      type: String,
+      notify: true
+    }
+  },
+  observers: [ '_locationChanged(path, queryParams)', '_routeChanged(route.prefix, route.path)', '_routeQueryParamsChanged(route.__queryParams)' ],
+  created: function() {
+    this.linkPaths('route.__queryParams', 'queryParams');
+    this.linkPaths('queryParams', 'route.__queryParams');
+  },
+  _locationChanged: function() {
+    if (this.route && this.route.path === this.path && this.queryParams === this.route.__queryParams) {
+      return;
+    }
+    this.route = {
+      prefix: '',
+      path: this.path,
+      __queryParams: this.queryParams
+    };
+  },
+  _routeChanged: function() {
+    if (!this.route) {
+      return;
+    }
+    this.path = this.route.prefix + this.route.path;
+  },
+  _routeQueryParamsChanged: function(queryParams) {
+    if (!this.route) {
+      return;
+    }
+    this.queryParams = queryParams;
+  }
+};
+
+'use strict';
+
+Polymer({
+  is: 'app-location',
+  properties: {
+    route: {
+      type: Object,
+      notify: true
+    },
+    useHashAsPath: {
+      type: Boolean,
+      value: false
+    },
+    urlSpaceRegex: {
+      type: String,
+      notify: true
+    },
+    __queryParams: {
+      type: Object
+    },
+    __path: {
+      type: String
+    },
+    __query: {
+      type: String
+    },
+    __hash: {
+      type: String
+    },
+    path: {
+      type: String,
+      observer: '__onPathChanged'
+    }
+  },
+  behaviors: [ Polymer.AppRouteConverterBehavior ],
+  observers: [ '__computeRoutePath(useHashAsPath, __hash, __path)' ],
+  __computeRoutePath: function() {
+    this.path = this.useHashAsPath ? this.__hash : this.__path;
+  },
+  __onPathChanged: function() {
+    if (!this._readied) {
+      return;
+    }
+    if (this.useHashAsPath) {
+      this.__hash = this.path;
+    } else {
+      this.__path = this.path;
+    }
+  }
+});
+
+'use strict';
+
+Polymer({
+  is: 'app-route',
+  properties: {
+    route: {
+      type: Object,
+      notify: true
+    },
+    pattern: {
+      type: String
+    },
+    data: {
+      type: Object,
+      value: function() {
+        return {};
+      },
+      notify: true
+    },
+    queryParams: {
+      type: Object,
+      value: function() {
+        return {};
+      },
+      notify: true
+    },
+    tail: {
+      type: Object,
+      value: function() {
+        return {
+          path: null,
+          prefix: null,
+          __queryParams: null
+        };
+      },
+      notify: true
+    },
+    active: {
+      type: Boolean,
+      notify: true,
+      readOnly: true
+    },
+    _queryParamsUpdating: {
+      type: Boolean,
+      value: false
+    },
+    _matched: {
+      type: String,
+      value: ''
+    }
+  },
+  observers: [ '__tryToMatch(route.path, pattern)', '__updatePathOnDataChange(data.*)', '__tailPathChanged(tail.path)', '__routeQueryParamsChanged(route.__queryParams)', '__tailQueryParamsChanged(tail.__queryParams)', '__queryParamsChanged(queryParams.*)' ],
+  created: function() {
+    this.linkPaths('route.__queryParams', 'tail.__queryParams');
+    this.linkPaths('tail.__queryParams', 'route.__queryParams');
+  },
+  __routeQueryParamsChanged: function(queryParams) {
+    if (queryParams && this.tail) {
+      this.set('tail.__queryParams', queryParams);
+      if (!this.active || this._queryParamsUpdating) {
+        return;
+      }
+      var copyOfQueryParams = {};
+      var anythingChanged = false;
+      for (var key in queryParams) {
+        copyOfQueryParams[key] = queryParams[key];
+        if (anythingChanged || !this.queryParams || queryParams[key] !== this.queryParams[key]) {
+          anythingChanged = true;
+        }
+      }
+      for (var key in this.queryParams) {
+        if (anythingChanged || !(key in queryParams)) {
+          anythingChanged = true;
+          break;
+        }
+      }
+      if (!anythingChanged) {
+        return;
+      }
+      this._queryParamsUpdating = true;
+      this.set('queryParams', copyOfQueryParams);
+      this._queryParamsUpdating = false;
+    }
+  },
+  __tailQueryParamsChanged: function(queryParams) {
+    if (queryParams && this.route) {
+      this.set('route.__queryParams', queryParams);
+    }
+  },
+  __queryParamsChanged: function(changes) {
+    if (!this.active || this._queryParamsUpdating) {
+      return;
+    }
+    this.set('route.__' + changes.path, changes.value);
+  },
+  __resetProperties: function() {
+    this._setActive(false);
+    this._matched = null;
+  },
+  __tryToMatch: function() {
+    if (!this.route) {
+      return;
+    }
+    var path = this.route.path;
+    var pattern = this.pattern;
+    if (!pattern) {
+      return;
+    }
+    if (!path) {
+      this.__resetProperties();
+      return;
+    }
+    var remainingPieces = path.split('/');
+    var patternPieces = pattern.split('/');
+    var matched = [];
+    var namedMatches = {};
+    for (var i = 0; i < patternPieces.length; i++) {
+      var patternPiece = patternPieces[i];
+      if (!patternPiece && patternPiece !== '') {
+        break;
+      }
+      var pathPiece = remainingPieces.shift();
+      if (!pathPiece && pathPiece !== '') {
+        this.__resetProperties();
+        return;
+      }
+      matched.push(pathPiece);
+      if (patternPiece.charAt(0) == ':') {
+        namedMatches[patternPiece.slice(1)] = pathPiece;
+      } else if (patternPiece !== pathPiece) {
+        this.__resetProperties();
+        return;
+      }
+    }
+    this._matched = matched.join('/');
+    var propertyUpdates = {};
+    if (!this.active) {
+      propertyUpdates.active = true;
+    }
+    var tailPrefix = this.route.prefix + this._matched;
+    var tailPath = remainingPieces.join('/');
+    if (remainingPieces.length > 0) {
+      tailPath = '/' + tailPath;
+    }
+    if (!this.tail || this.tail.prefix !== tailPrefix || this.tail.path !== tailPath) {
+      propertyUpdates.tail = {
+        prefix: tailPrefix,
+        path: tailPath,
+        __queryParams: this.route.__queryParams
+      };
+    }
+    propertyUpdates.data = namedMatches;
+    this._dataInUrl = {};
+    for (var key in namedMatches) {
+      this._dataInUrl[key] = namedMatches[key];
+    }
+    this.__setMulti(propertyUpdates);
+  },
+  __tailPathChanged: function() {
+    if (!this.active) {
+      return;
+    }
+    var tailPath = this.tail.path;
+    var newPath = this._matched;
+    if (tailPath) {
+      if (tailPath.charAt(0) !== '/') {
+        tailPath = '/' + tailPath;
+      }
+      newPath += tailPath;
+    }
+    this.set('route.path', newPath);
+  },
+  __updatePathOnDataChange: function() {
+    if (!this.route || !this.active) {
+      return;
+    }
+    var newPath = this.__getLink({});
+    var oldPath = this.__getLink(this._dataInUrl);
+    if (newPath === oldPath) {
+      return;
+    }
+    this.set('route.path', newPath);
+  },
+  __getLink: function(overrideValues) {
+    var values = {
+      tail: null
+    };
+    for (var key in this.data) {
+      values[key] = this.data[key];
+    }
+    for (var key in overrideValues) {
+      values[key] = overrideValues[key];
+    }
+    var patternPieces = this.pattern.split('/');
+    var interp = patternPieces.map(function(value) {
+      if (value[0] == ':') {
+        value = values[value.slice(1)];
+      }
+      return value;
+    }, this);
+    if (values.tail && values.tail.path) {
+      if (interp.length > 0 && values.tail.path.charAt(0) === '/') {
+        interp.push(values.tail.path.slice(1));
+      } else {
+        interp.push(values.tail.path);
+      }
+    }
+    return interp.join('/');
+  },
+  __setMulti: function(setObj) {
+    for (var property in setObj) {
+      this._propertySetter(property, setObj[property]);
+    }
+    for (var property in setObj) {
+      this._pathEffector(property, this[property]);
+      this._notifyPathUp(property, this[property]);
+    }
+  }
+});
+
+Polymer({
+  is: 'iron-media-query',
+  properties: {
+    queryMatches: {
+      type: Boolean,
+      value: false,
+      readOnly: true,
+      notify: true
+    },
+    query: {
+      type: String,
+      observer: 'queryChanged'
+    },
+    full: {
+      type: Boolean,
+      value: false
+    },
+    _boundMQHandler: {
+      value: function() {
+        return this.queryHandler.bind(this);
+      }
+    },
+    _mq: {
+      value: null
+    }
+  },
+  attached: function() {
+    this.style.display = 'none';
+    this.queryChanged();
+  },
+  detached: function() {
+    this._remove();
+  },
+  _add: function() {
+    if (this._mq) {
+      this._mq.addListener(this._boundMQHandler);
+    }
+  },
+  _remove: function() {
+    if (this._mq) {
+      this._mq.removeListener(this._boundMQHandler);
+    }
+    this._mq = null;
+  },
+  queryChanged: function() {
+    this._remove();
+    var query = this.query;
+    if (!query) {
+      return;
+    }
+    if (!this.full && query[0] !== '(') {
+      query = '(' + query + ')';
+    }
+    this._mq = window.matchMedia(query);
+    this._add();
+    this.queryHandler(this._mq);
+  },
+  queryHandler: function(mq) {
+    this._setQueryMatches(mq.matches);
+  }
+});
+
+Polymer.IronResizableBehavior = {
+  properties: {
+    _parentResizable: {
+      type: Object,
+      observer: '_parentResizableChanged'
+    },
+    _notifyingDescendant: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    'iron-request-resize-notifications': '_onIronRequestResizeNotifications'
+  },
+  created: function() {
+    this._interestedResizables = [];
+    this._boundNotifyResize = this.notifyResize.bind(this);
+  },
+  attached: function() {
+    this.fire('iron-request-resize-notifications', null, {
+      node: this,
+      bubbles: true,
+      cancelable: true
+    });
+    if (!this._parentResizable) {
+      window.addEventListener('resize', this._boundNotifyResize);
+      this.notifyResize();
+    }
+  },
+  detached: function() {
+    if (this._parentResizable) {
+      this._parentResizable.stopResizeNotificationsFor(this);
+    } else {
+      window.removeEventListener('resize', this._boundNotifyResize);
+    }
+    this._parentResizable = null;
+  },
+  notifyResize: function() {
+    if (!this.isAttached) {
+      return;
+    }
+    this._interestedResizables.forEach(function(resizable) {
+      if (this.resizerShouldNotify(resizable)) {
+        this._notifyDescendant(resizable);
+      }
+    }, this);
+    this._fireResize();
+  },
+  assignParentResizable: function(parentResizable) {
+    this._parentResizable = parentResizable;
+  },
+  stopResizeNotificationsFor: function(target) {
+    var index = this._interestedResizables.indexOf(target);
+    if (index > -1) {
+      this._interestedResizables.splice(index, 1);
+      this.unlisten(target, 'iron-resize', '_onDescendantIronResize');
+    }
+  },
+  resizerShouldNotify: function(element) {
+    return true;
+  },
+  _onDescendantIronResize: function(event) {
+    if (this._notifyingDescendant) {
+      event.stopPropagation();
+      return;
+    }
+    if (!Polymer.Settings.useShadow) {
+      this._fireResize();
+    }
+  },
+  _fireResize: function() {
+    this.fire('iron-resize', null, {
+      node: this,
+      bubbles: false
+    });
+  },
+  _onIronRequestResizeNotifications: function(event) {
+    var target = event.path ? event.path[0] : event.target;
+    if (target === this) {
+      return;
+    }
+    if (this._interestedResizables.indexOf(target) === -1) {
+      this._interestedResizables.push(target);
+      this.listen(target, 'iron-resize', '_onDescendantIronResize');
+    }
+    target.assignParentResizable(this);
+    this._notifyDescendant(target);
+    event.stopPropagation();
+  },
+  _parentResizableChanged: function(parentResizable) {
+    if (parentResizable) {
+      window.removeEventListener('resize', this._boundNotifyResize);
+    }
+  },
+  _notifyDescendant: function(descendant) {
+    if (!this.isAttached) {
+      return;
+    }
+    this._notifyingDescendant = true;
+    descendant.notifyResize();
+    this._notifyingDescendant = false;
+  }
+};
+
+Polymer.IronSelection = function(selectCallback) {
+  this.selection = [];
+  this.selectCallback = selectCallback;
+};
+
+Polymer.IronSelection.prototype = {
+  get: function() {
+    return this.multi ? this.selection.slice() : this.selection[0];
+  },
+  clear: function(excludes) {
+    this.selection.slice().forEach(function(item) {
+      if (!excludes || excludes.indexOf(item) < 0) {
+        this.setItemSelected(item, false);
+      }
+    }, this);
+  },
+  isSelected: function(item) {
+    return this.selection.indexOf(item) >= 0;
+  },
+  setItemSelected: function(item, isSelected) {
+    if (item != null) {
+      if (isSelected !== this.isSelected(item)) {
+        if (isSelected) {
+          this.selection.push(item);
+        } else {
+          var i = this.selection.indexOf(item);
+          if (i >= 0) {
+            this.selection.splice(i, 1);
+          }
+        }
+        if (this.selectCallback) {
+          this.selectCallback(item, isSelected);
+        }
+      }
+    }
+  },
+  select: function(item) {
+    if (this.multi) {
+      this.toggle(item);
+    } else if (this.get() !== item) {
+      this.setItemSelected(this.get(), false);
+      this.setItemSelected(item, true);
+    }
+  },
+  toggle: function(item) {
+    this.setItemSelected(item, !this.isSelected(item));
+  }
+};
+
+Polymer.IronSelectableBehavior = {
+  properties: {
+    attrForSelected: {
+      type: String,
+      value: null
+    },
+    selected: {
+      type: String,
+      notify: true
+    },
+    selectedItem: {
+      type: Object,
+      readOnly: true,
+      notify: true
+    },
+    activateEvent: {
+      type: String,
+      value: 'tap',
+      observer: '_activateEventChanged'
+    },
+    selectable: String,
+    selectedClass: {
+      type: String,
+      value: 'iron-selected'
+    },
+    selectedAttribute: {
+      type: String,
+      value: null
+    },
+    fallbackSelection: {
+      type: String,
+      value: null
+    },
+    items: {
+      type: Array,
+      readOnly: true,
+      notify: true,
+      value: function() {
+        return [];
+      }
+    },
+    _excludedLocalNames: {
+      type: Object,
+      value: function() {
+        return {
+          template: 1
+        };
+      }
+    }
+  },
+  observers: [ '_updateAttrForSelected(attrForSelected)', '_updateSelected(selected)', '_checkFallback(fallbackSelection)' ],
+  created: function() {
+    this._bindFilterItem = this._filterItem.bind(this);
+    this._selection = new Polymer.IronSelection(this._applySelection.bind(this));
+  },
+  attached: function() {
+    this._observer = this._observeItems(this);
+    this._updateItems();
+    if (!this._shouldUpdateSelection) {
+      this._updateSelected();
+    }
+    this._addListener(this.activateEvent);
+  },
+  detached: function() {
+    if (this._observer) {
+      Polymer.dom(this).unobserveNodes(this._observer);
+    }
+    this._removeListener(this.activateEvent);
+  },
+  indexOf: function(item) {
+    return this.items.indexOf(item);
+  },
+  select: function(value) {
+    this.selected = value;
+  },
+  selectPrevious: function() {
+    var length = this.items.length;
+    var index = (Number(this._valueToIndex(this.selected)) - 1 + length) % length;
+    this.selected = this._indexToValue(index);
+  },
+  selectNext: function() {
+    var index = (Number(this._valueToIndex(this.selected)) + 1) % this.items.length;
+    this.selected = this._indexToValue(index);
+  },
+  selectIndex: function(index) {
+    this.select(this._indexToValue(index));
+  },
+  forceSynchronousItemUpdate: function() {
+    this._updateItems();
+  },
+  get _shouldUpdateSelection() {
+    return this.selected != null;
+  },
+  _checkFallback: function() {
+    if (this._shouldUpdateSelection) {
+      this._updateSelected();
+    }
+  },
+  _addListener: function(eventName) {
+    this.listen(this, eventName, '_activateHandler');
+  },
+  _removeListener: function(eventName) {
+    this.unlisten(this, eventName, '_activateHandler');
+  },
+  _activateEventChanged: function(eventName, old) {
+    this._removeListener(old);
+    this._addListener(eventName);
+  },
+  _updateItems: function() {
+    var nodes = Polymer.dom(this).queryDistributedElements(this.selectable || '*');
+    nodes = Array.prototype.filter.call(nodes, this._bindFilterItem);
+    this._setItems(nodes);
+  },
+  _updateAttrForSelected: function() {
+    if (this._shouldUpdateSelection) {
+      this.selected = this._indexToValue(this.indexOf(this.selectedItem));
+    }
+  },
+  _updateSelected: function() {
+    this._selectSelected(this.selected);
+  },
+  _selectSelected: function(selected) {
+    this._selection.select(this._valueToItem(this.selected));
+    if (this.fallbackSelection && this.items.length && this._selection.get() === undefined) {
+      this.selected = this.fallbackSelection;
+    }
+  },
+  _filterItem: function(node) {
+    return !this._excludedLocalNames[node.localName];
+  },
+  _valueToItem: function(value) {
+    return value == null ? null : this.items[this._valueToIndex(value)];
+  },
+  _valueToIndex: function(value) {
+    if (this.attrForSelected) {
+      for (var i = 0, item; item = this.items[i]; i++) {
+        if (this._valueForItem(item) == value) {
+          return i;
+        }
+      }
+    } else {
+      return Number(value);
+    }
+  },
+  _indexToValue: function(index) {
+    if (this.attrForSelected) {
+      var item = this.items[index];
+      if (item) {
+        return this._valueForItem(item);
+      }
+    } else {
+      return index;
+    }
+  },
+  _valueForItem: function(item) {
+    var propValue = item[Polymer.CaseMap.dashToCamelCase(this.attrForSelected)];
+    return propValue != undefined ? propValue : item.getAttribute(this.attrForSelected);
+  },
+  _applySelection: function(item, isSelected) {
+    if (this.selectedClass) {
+      this.toggleClass(this.selectedClass, isSelected, item);
+    }
+    if (this.selectedAttribute) {
+      this.toggleAttribute(this.selectedAttribute, isSelected, item);
+    }
+    this._selectionChange();
+    this.fire('iron-' + (isSelected ? 'select' : 'deselect'), {
+      item: item
+    });
+  },
+  _selectionChange: function() {
+    this._setSelectedItem(this._selection.get());
+  },
+  _observeItems: function(node) {
+    return Polymer.dom(node).observeNodes(function(mutation) {
+      this._updateItems();
+      if (this._shouldUpdateSelection) {
+        this._updateSelected();
+      }
+      this.fire('iron-items-changed', mutation, {
+        bubbles: false,
+        cancelable: false
+      });
+    });
+  },
+  _activateHandler: function(e) {
+    var t = e.target;
+    var items = this.items;
+    while (t && t != this) {
+      var i = items.indexOf(t);
+      if (i >= 0) {
+        var value = this._indexToValue(i);
+        this._itemActivate(value, t);
+        return;
+      }
+      t = t.parentNode;
+    }
+  },
+  _itemActivate: function(value, item) {
+    if (!this.fire('iron-activate', {
+      selected: value,
+      item: item
+    }, {
+      cancelable: true
+    }).defaultPrevented) {
+      this.select(value);
+    }
+  }
+};
+
+Polymer({
+  is: 'iron-pages',
+  behaviors: [ Polymer.IronResizableBehavior, Polymer.IronSelectableBehavior ],
+  properties: {
+    activateEvent: {
+      type: String,
+      value: null
+    }
+  },
+  observers: [ '_selectedPageChanged(selected)' ],
+  _selectedPageChanged: function(selected, old) {
+    this.async(this.notifyResize);
+  }
+});
+
+(function() {
+  'use strict';
+  var KEY_IDENTIFIER = {
+    'U+0008': 'backspace',
+    'U+0009': 'tab',
+    'U+001B': 'esc',
+    'U+0020': 'space',
+    'U+007F': 'del'
+  };
+  var KEY_CODE = {
+    8: 'backspace',
+    9: 'tab',
+    13: 'enter',
+    27: 'esc',
+    33: 'pageup',
+    34: 'pagedown',
+    35: 'end',
+    36: 'home',
+    32: 'space',
+    37: 'left',
+    38: 'up',
+    39: 'right',
+    40: 'down',
+    46: 'del',
+    106: '*'
+  };
+  var MODIFIER_KEYS = {
+    shift: 'shiftKey',
+    ctrl: 'ctrlKey',
+    alt: 'altKey',
+    meta: 'metaKey'
+  };
+  var KEY_CHAR = /[a-z0-9*]/;
+  var IDENT_CHAR = /U\+/;
+  var ARROW_KEY = /^arrow/;
+  var SPACE_KEY = /^space(bar)?/;
+  var ESC_KEY = /^escape$/;
+  function transformKey(key, noSpecialChars) {
+    var validKey = '';
+    if (key) {
+      var lKey = key.toLowerCase();
+      if (lKey === ' ' || SPACE_KEY.test(lKey)) {
+        validKey = 'space';
+      } else if (ESC_KEY.test(lKey)) {
+        validKey = 'esc';
+      } else if (lKey.length == 1) {
+        if (!noSpecialChars || KEY_CHAR.test(lKey)) {
+          validKey = lKey;
+        }
+      } else if (ARROW_KEY.test(lKey)) {
+        validKey = lKey.replace('arrow', '');
+      } else if (lKey == 'multiply') {
+        validKey = '*';
+      } else {
+        validKey = lKey;
+      }
+    }
+    return validKey;
+  }
+  function transformKeyIdentifier(keyIdent) {
+    var validKey = '';
+    if (keyIdent) {
+      if (keyIdent in KEY_IDENTIFIER) {
+        validKey = KEY_IDENTIFIER[keyIdent];
+      } else if (IDENT_CHAR.test(keyIdent)) {
+        keyIdent = parseInt(keyIdent.replace('U+', '0x'), 16);
+        validKey = String.fromCharCode(keyIdent).toLowerCase();
+      } else {
+        validKey = keyIdent.toLowerCase();
+      }
+    }
+    return validKey;
+  }
+  function transformKeyCode(keyCode) {
+    var validKey = '';
+    if (Number(keyCode)) {
+      if (keyCode >= 65 && keyCode <= 90) {
+        validKey = String.fromCharCode(32 + keyCode);
+      } else if (keyCode >= 112 && keyCode <= 123) {
+        validKey = 'f' + (keyCode - 112);
+      } else if (keyCode >= 48 && keyCode <= 57) {
+        validKey = String(keyCode - 48);
+      } else if (keyCode >= 96 && keyCode <= 105) {
+        validKey = String(keyCode - 96);
+      } else {
+        validKey = KEY_CODE[keyCode];
+      }
+    }
+    return validKey;
+  }
+  function normalizedKeyForEvent(keyEvent, noSpecialChars) {
+    return transformKey(keyEvent.key, noSpecialChars) || transformKeyIdentifier(keyEvent.keyIdentifier) || transformKeyCode(keyEvent.keyCode) || transformKey(keyEvent.detail ? keyEvent.detail.key : keyEvent.detail, noSpecialChars) || '';
+  }
+  function keyComboMatchesEvent(keyCombo, event) {
+    var keyEvent = normalizedKeyForEvent(event, keyCombo.hasModifiers);
+    return keyEvent === keyCombo.key && (!keyCombo.hasModifiers || !!event.shiftKey === !!keyCombo.shiftKey && !!event.ctrlKey === !!keyCombo.ctrlKey && !!event.altKey === !!keyCombo.altKey && !!event.metaKey === !!keyCombo.metaKey);
+  }
+  function parseKeyComboString(keyComboString) {
+    if (keyComboString.length === 1) {
+      return {
+        combo: keyComboString,
+        key: keyComboString,
+        event: 'keydown'
+      };
+    }
+    return keyComboString.split('+').reduce(function(parsedKeyCombo, keyComboPart) {
+      var eventParts = keyComboPart.split(':');
+      var keyName = eventParts[0];
+      var event = eventParts[1];
+      if (keyName in MODIFIER_KEYS) {
+        parsedKeyCombo[MODIFIER_KEYS[keyName]] = true;
+        parsedKeyCombo.hasModifiers = true;
+      } else {
+        parsedKeyCombo.key = keyName;
+        parsedKeyCombo.event = event || 'keydown';
+      }
+      return parsedKeyCombo;
+    }, {
+      combo: keyComboString.split(':').shift()
+    });
+  }
+  function parseEventString(eventString) {
+    return eventString.trim().split(' ').map(function(keyComboString) {
+      return parseKeyComboString(keyComboString);
+    });
+  }
+  Polymer.IronA11yKeysBehavior = {
+    properties: {
+      keyEventTarget: {
+        type: Object,
+        value: function() {
+          return this;
+        }
+      },
+      stopKeyboardEventPropagation: {
+        type: Boolean,
+        value: false
+      },
+      _boundKeyHandlers: {
+        type: Array,
+        value: function() {
+          return [];
+        }
+      },
+      _imperativeKeyBindings: {
+        type: Object,
+        value: function() {
+          return {};
+        }
+      }
+    },
+    observers: [ '_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)' ],
+    keyBindings: {},
+    registered: function() {
+      this._prepKeyBindings();
+    },
+    attached: function() {
+      this._listenKeyEventListeners();
+    },
+    detached: function() {
+      this._unlistenKeyEventListeners();
+    },
+    addOwnKeyBinding: function(eventString, handlerName) {
+      this._imperativeKeyBindings[eventString] = handlerName;
+      this._prepKeyBindings();
+      this._resetKeyEventListeners();
+    },
+    removeOwnKeyBindings: function() {
+      this._imperativeKeyBindings = {};
+      this._prepKeyBindings();
+      this._resetKeyEventListeners();
+    },
+    keyboardEventMatchesKeys: function(event, eventString) {
+      var keyCombos = parseEventString(eventString);
+      for (var i = 0; i < keyCombos.length; ++i) {
+        if (keyComboMatchesEvent(keyCombos[i], event)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    _collectKeyBindings: function() {
+      var keyBindings = this.behaviors.map(function(behavior) {
+        return behavior.keyBindings;
+      });
+      if (keyBindings.indexOf(this.keyBindings) === -1) {
+        keyBindings.push(this.keyBindings);
+      }
+      return keyBindings;
+    },
+    _prepKeyBindings: function() {
+      this._keyBindings = {};
+      this._collectKeyBindings().forEach(function(keyBindings) {
+        for (var eventString in keyBindings) {
+          this._addKeyBinding(eventString, keyBindings[eventString]);
+        }
+      }, this);
+      for (var eventString in this._imperativeKeyBindings) {
+        this._addKeyBinding(eventString, this._imperativeKeyBindings[eventString]);
+      }
+      for (var eventName in this._keyBindings) {
+        this._keyBindings[eventName].sort(function(kb1, kb2) {
+          var b1 = kb1[0].hasModifiers;
+          var b2 = kb2[0].hasModifiers;
+          return b1 === b2 ? 0 : b1 ? -1 : 1;
+        });
+      }
+    },
+    _addKeyBinding: function(eventString, handlerName) {
+      parseEventString(eventString).forEach(function(keyCombo) {
+        this._keyBindings[keyCombo.event] = this._keyBindings[keyCombo.event] || [];
+        this._keyBindings[keyCombo.event].push([ keyCombo, handlerName ]);
+      }, this);
+    },
+    _resetKeyEventListeners: function() {
+      this._unlistenKeyEventListeners();
+      if (this.isAttached) {
+        this._listenKeyEventListeners();
+      }
+    },
+    _listenKeyEventListeners: function() {
+      if (!this.keyEventTarget) {
+        return;
+      }
+      Object.keys(this._keyBindings).forEach(function(eventName) {
+        var keyBindings = this._keyBindings[eventName];
+        var boundKeyHandler = this._onKeyBindingEvent.bind(this, keyBindings);
+        this._boundKeyHandlers.push([ this.keyEventTarget, eventName, boundKeyHandler ]);
+        this.keyEventTarget.addEventListener(eventName, boundKeyHandler);
+      }, this);
+    },
+    _unlistenKeyEventListeners: function() {
+      var keyHandlerTuple;
+      var keyEventTarget;
+      var eventName;
+      var boundKeyHandler;
+      while (this._boundKeyHandlers.length) {
+        keyHandlerTuple = this._boundKeyHandlers.pop();
+        keyEventTarget = keyHandlerTuple[0];
+        eventName = keyHandlerTuple[1];
+        boundKeyHandler = keyHandlerTuple[2];
+        keyEventTarget.removeEventListener(eventName, boundKeyHandler);
+      }
+    },
+    _onKeyBindingEvent: function(keyBindings, event) {
+      if (this.stopKeyboardEventPropagation) {
+        event.stopPropagation();
+      }
+      if (event.defaultPrevented) {
+        return;
+      }
+      for (var i = 0; i < keyBindings.length; i++) {
+        var keyCombo = keyBindings[i][0];
+        var handlerName = keyBindings[i][1];
+        if (keyComboMatchesEvent(keyCombo, event)) {
+          this._triggerKeyHandler(keyCombo, handlerName, event);
+          if (event.defaultPrevented) {
+            return;
+          }
+        }
+      }
+    },
+    _triggerKeyHandler: function(keyCombo, handlerName, keyboardEvent) {
+      var detail = Object.create(keyCombo);
+      detail.keyboardEvent = keyboardEvent;
+      var event = new CustomEvent(keyCombo.event, {
+        detail: detail,
+        cancelable: true
+      });
+      this[handlerName].call(this, event);
+      if (event.defaultPrevented) {
+        keyboardEvent.preventDefault();
+      }
+    }
+  };
+})();
+
+Polymer.IronControlState = {
+  properties: {
+    focused: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      readOnly: true,
+      reflectToAttribute: true
+    },
+    disabled: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      observer: '_disabledChanged',
+      reflectToAttribute: true
+    },
+    _oldTabIndex: {
+      type: Number
+    },
+    _boundFocusBlurHandler: {
+      type: Function,
+      value: function() {
+        return this._focusBlurHandler.bind(this);
+      }
+    }
+  },
+  observers: [ '_changedControlState(focused, disabled)' ],
+  ready: function() {
+    this.addEventListener('focus', this._boundFocusBlurHandler, true);
+    this.addEventListener('blur', this._boundFocusBlurHandler, true);
+  },
+  _focusBlurHandler: function(event) {
+    if (event.target === this) {
+      this._setFocused(event.type === 'focus');
+    } else if (!this.shadowRoot) {
+      var target = Polymer.dom(event).localTarget;
+      if (!this.isLightDescendant(target)) {
+        this.fire(event.type, {
+          sourceEvent: event
+        }, {
+          node: this,
+          bubbles: event.bubbles,
+          cancelable: event.cancelable
+        });
+      }
+    }
+  },
+  _disabledChanged: function(disabled, old) {
+    this.setAttribute('aria-disabled', disabled ? 'true' : 'false');
+    this.style.pointerEvents = disabled ? 'none' : '';
+    if (disabled) {
+      this._oldTabIndex = this.tabIndex;
+      this._setFocused(false);
+      this.tabIndex = -1;
+      this.blur();
+    } else if (this._oldTabIndex !== undefined) {
+      this.tabIndex = this._oldTabIndex;
+    }
+  },
+  _changedControlState: function() {
+    if (this._controlStateChanged) {
+      this._controlStateChanged();
+    }
+  }
+};
+
+Polymer.IronButtonStateImpl = {
+  properties: {
+    pressed: {
+      type: Boolean,
+      readOnly: true,
+      value: false,
+      reflectToAttribute: true,
+      observer: '_pressedChanged'
+    },
+    toggles: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    active: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      reflectToAttribute: true
+    },
+    pointerDown: {
+      type: Boolean,
+      readOnly: true,
+      value: false
+    },
+    receivedFocusFromKeyboard: {
+      type: Boolean,
+      readOnly: true
+    },
+    ariaActiveAttribute: {
+      type: String,
+      value: 'aria-pressed',
+      observer: '_ariaActiveAttributeChanged'
+    }
+  },
+  listeners: {
+    down: '_downHandler',
+    up: '_upHandler',
+    tap: '_tapHandler'
+  },
+  observers: [ '_detectKeyboardFocus(focused)', '_activeChanged(active, ariaActiveAttribute)' ],
+  keyBindings: {
+    'enter:keydown': '_asyncClick',
+    'space:keydown': '_spaceKeyDownHandler',
+    'space:keyup': '_spaceKeyUpHandler'
+  },
+  _mouseEventRe: /^mouse/,
+  _tapHandler: function() {
+    if (this.toggles) {
+      this._userActivate(!this.active);
+    } else {
+      this.active = false;
+    }
+  },
+  _detectKeyboardFocus: function(focused) {
+    this._setReceivedFocusFromKeyboard(!this.pointerDown && focused);
+  },
+  _userActivate: function(active) {
+    if (this.active !== active) {
+      this.active = active;
+      this.fire('change');
+    }
+  },
+  _downHandler: function(event) {
+    this._setPointerDown(true);
+    this._setPressed(true);
+    this._setReceivedFocusFromKeyboard(false);
+  },
+  _upHandler: function() {
+    this._setPointerDown(false);
+    this._setPressed(false);
+  },
+  _spaceKeyDownHandler: function(event) {
+    var keyboardEvent = event.detail.keyboardEvent;
+    var target = Polymer.dom(keyboardEvent).localTarget;
+    if (this.isLightDescendant(target)) return;
+    keyboardEvent.preventDefault();
+    keyboardEvent.stopImmediatePropagation();
+    this._setPressed(true);
+  },
+  _spaceKeyUpHandler: function(event) {
+    var keyboardEvent = event.detail.keyboardEvent;
+    var target = Polymer.dom(keyboardEvent).localTarget;
+    if (this.isLightDescendant(target)) return;
+    if (this.pressed) {
+      this._asyncClick();
+    }
+    this._setPressed(false);
+  },
+  _asyncClick: function() {
+    this.async(function() {
+      this.click();
+    }, 1);
+  },
+  _pressedChanged: function(pressed) {
+    this._changedButtonState();
+  },
+  _ariaActiveAttributeChanged: function(value, oldValue) {
+    if (oldValue && oldValue != value && this.hasAttribute(oldValue)) {
+      this.removeAttribute(oldValue);
+    }
+  },
+  _activeChanged: function(active, ariaActiveAttribute) {
+    if (this.toggles) {
+      this.setAttribute(this.ariaActiveAttribute, active ? 'true' : 'false');
+    } else {
+      this.removeAttribute(this.ariaActiveAttribute);
+    }
+    this._changedButtonState();
+  },
+  _controlStateChanged: function() {
+    if (this.disabled) {
+      this._setPressed(false);
+    } else {
+      this._changedButtonState();
+    }
+  },
+  _changedButtonState: function() {
+    if (this._buttonStateChanged) {
+      this._buttonStateChanged();
+    }
+  }
+};
+
+Polymer.IronButtonState = [ Polymer.IronA11yKeysBehavior, Polymer.IronButtonStateImpl ];
+
+(function() {
+  var Utility = {
+    distance: function(x1, y1, x2, y2) {
+      var xDelta = x1 - x2;
+      var yDelta = y1 - y2;
+      return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
+    },
+    now: window.performance && window.performance.now ? window.performance.now.bind(window.performance) : Date.now
+  };
+  function ElementMetrics(element) {
+    this.element = element;
+    this.width = this.boundingRect.width;
+    this.height = this.boundingRect.height;
+    this.size = Math.max(this.width, this.height);
+  }
+  ElementMetrics.prototype = {
+    get boundingRect() {
+      return this.element.getBoundingClientRect();
+    },
+    furthestCornerDistanceFrom: function(x, y) {
+      var topLeft = Utility.distance(x, y, 0, 0);
+      var topRight = Utility.distance(x, y, this.width, 0);
+      var bottomLeft = Utility.distance(x, y, 0, this.height);
+      var bottomRight = Utility.distance(x, y, this.width, this.height);
+      return Math.max(topLeft, topRight, bottomLeft, bottomRight);
+    }
+  };
+  function Ripple(element) {
+    this.element = element;
+    this.color = window.getComputedStyle(element).color;
+    this.wave = document.createElement('div');
+    this.waveContainer = document.createElement('div');
+    this.wave.style.backgroundColor = this.color;
+    this.wave.classList.add('wave');
+    this.waveContainer.classList.add('wave-container');
+    Polymer.dom(this.waveContainer).appendChild(this.wave);
+    this.resetInteractionState();
+  }
+  Ripple.MAX_RADIUS = 300;
+  Ripple.prototype = {
+    get recenters() {
+      return this.element.recenters;
+    },
+    get center() {
+      return this.element.center;
+    },
+    get mouseDownElapsed() {
+      var elapsed;
+      if (!this.mouseDownStart) {
+        return 0;
+      }
+      elapsed = Utility.now() - this.mouseDownStart;
+      if (this.mouseUpStart) {
+        elapsed -= this.mouseUpElapsed;
+      }
+      return elapsed;
+    },
+    get mouseUpElapsed() {
+      return this.mouseUpStart ? Utility.now() - this.mouseUpStart : 0;
+    },
+    get mouseDownElapsedSeconds() {
+      return this.mouseDownElapsed / 1e3;
+    },
+    get mouseUpElapsedSeconds() {
+      return this.mouseUpElapsed / 1e3;
+    },
+    get mouseInteractionSeconds() {
+      return this.mouseDownElapsedSeconds + this.mouseUpElapsedSeconds;
+    },
+    get initialOpacity() {
+      return this.element.initialOpacity;
+    },
+    get opacityDecayVelocity() {
+      return this.element.opacityDecayVelocity;
+    },
+    get radius() {
+      var width2 = this.containerMetrics.width * this.containerMetrics.width;
+      var height2 = this.containerMetrics.height * this.containerMetrics.height;
+      var waveRadius = Math.min(Math.sqrt(width2 + height2), Ripple.MAX_RADIUS) * 1.1 + 5;
+      var duration = 1.1 - .2 * (waveRadius / Ripple.MAX_RADIUS);
+      var timeNow = this.mouseInteractionSeconds / duration;
+      var size = waveRadius * (1 - Math.pow(80, -timeNow));
+      return Math.abs(size);
+    },
+    get opacity() {
+      if (!this.mouseUpStart) {
+        return this.initialOpacity;
+      }
+      return Math.max(0, this.initialOpacity - this.mouseUpElapsedSeconds * this.opacityDecayVelocity);
+    },
+    get outerOpacity() {
+      var outerOpacity = this.mouseUpElapsedSeconds * .3;
+      var waveOpacity = this.opacity;
+      return Math.max(0, Math.min(outerOpacity, waveOpacity));
+    },
+    get isOpacityFullyDecayed() {
+      return this.opacity < .01 && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
+    },
+    get isRestingAtMaxRadius() {
+      return this.opacity >= this.initialOpacity && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
+    },
+    get isAnimationComplete() {
+      return this.mouseUpStart ? this.isOpacityFullyDecayed : this.isRestingAtMaxRadius;
+    },
+    get translationFraction() {
+      return Math.min(1, this.radius / this.containerMetrics.size * 2 / Math.sqrt(2));
+    },
+    get xNow() {
+      if (this.xEnd) {
+        return this.xStart + this.translationFraction * (this.xEnd - this.xStart);
+      }
+      return this.xStart;
+    },
+    get yNow() {
+      if (this.yEnd) {
+        return this.yStart + this.translationFraction * (this.yEnd - this.yStart);
+      }
+      return this.yStart;
+    },
+    get isMouseDown() {
+      return this.mouseDownStart && !this.mouseUpStart;
+    },
+    resetInteractionState: function() {
+      this.maxRadius = 0;
+      this.mouseDownStart = 0;
+      this.mouseUpStart = 0;
+      this.xStart = 0;
+      this.yStart = 0;
+      this.xEnd = 0;
+      this.yEnd = 0;
+      this.slideDistance = 0;
+      this.containerMetrics = new ElementMetrics(this.element);
+    },
+    draw: function() {
+      var scale;
+      var translateString;
+      var dx;
+      var dy;
+      this.wave.style.opacity = this.opacity;
+      scale = this.radius / (this.containerMetrics.size / 2);
+      dx = this.xNow - this.containerMetrics.width / 2;
+      dy = this.yNow - this.containerMetrics.height / 2;
+      this.waveContainer.style.webkitTransform = 'translate(' + dx + 'px, ' + dy + 'px)';
+      this.waveContainer.style.transform = 'translate3d(' + dx + 'px, ' + dy + 'px, 0)';
+      this.wave.style.webkitTransform = 'scale(' + scale + ',' + scale + ')';
+      this.wave.style.transform = 'scale3d(' + scale + ',' + scale + ',1)';
+    },
+    downAction: function(event) {
+      var xCenter = this.containerMetrics.width / 2;
+      var yCenter = this.containerMetrics.height / 2;
+      this.resetInteractionState();
+      this.mouseDownStart = Utility.now();
+      if (this.center) {
+        this.xStart = xCenter;
+        this.yStart = yCenter;
+        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
+      } else {
+        this.xStart = event ? event.detail.x - this.containerMetrics.boundingRect.left : this.containerMetrics.width / 2;
+        this.yStart = event ? event.detail.y - this.containerMetrics.boundingRect.top : this.containerMetrics.height / 2;
+      }
+      if (this.recenters) {
+        this.xEnd = xCenter;
+        this.yEnd = yCenter;
+        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
+      }
+      this.maxRadius = this.containerMetrics.furthestCornerDistanceFrom(this.xStart, this.yStart);
+      this.waveContainer.style.top = (this.containerMetrics.height - this.containerMetrics.size) / 2 + 'px';
+      this.waveContainer.style.left = (this.containerMetrics.width - this.containerMetrics.size) / 2 + 'px';
+      this.waveContainer.style.width = this.containerMetrics.size + 'px';
+      this.waveContainer.style.height = this.containerMetrics.size + 'px';
+    },
+    upAction: function(event) {
+      if (!this.isMouseDown) {
+        return;
+      }
+      this.mouseUpStart = Utility.now();
+    },
+    remove: function() {
+      Polymer.dom(this.waveContainer.parentNode).removeChild(this.waveContainer);
+    }
+  };
+  Polymer({
+    is: 'paper-ripple',
+    behaviors: [ Polymer.IronA11yKeysBehavior ],
+    properties: {
+      initialOpacity: {
+        type: Number,
+        value: .25
+      },
+      opacityDecayVelocity: {
+        type: Number,
+        value: .8
+      },
+      recenters: {
+        type: Boolean,
+        value: false
+      },
+      center: {
+        type: Boolean,
+        value: false
+      },
+      ripples: {
+        type: Array,
+        value: function() {
+          return [];
+        }
+      },
+      animating: {
+        type: Boolean,
+        readOnly: true,
+        reflectToAttribute: true,
+        value: false
+      },
+      holdDown: {
+        type: Boolean,
+        value: false,
+        observer: '_holdDownChanged'
+      },
+      noink: {
+        type: Boolean,
+        value: false
+      },
+      _animating: {
+        type: Boolean
+      },
+      _boundAnimate: {
+        type: Function,
+        value: function() {
+          return this.animate.bind(this);
+        }
+      }
+    },
+    get target() {
+      return this.keyEventTarget;
+    },
+    keyBindings: {
+      'enter:keydown': '_onEnterKeydown',
+      'space:keydown': '_onSpaceKeydown',
+      'space:keyup': '_onSpaceKeyup'
+    },
+    attached: function() {
+      if (this.parentNode.nodeType == 11) {
+        this.keyEventTarget = Polymer.dom(this).getOwnerRoot().host;
+      } else {
+        this.keyEventTarget = this.parentNode;
+      }
+      var keyEventTarget = this.keyEventTarget;
+      this.listen(keyEventTarget, 'up', 'uiUpAction');
+      this.listen(keyEventTarget, 'down', 'uiDownAction');
+    },
+    detached: function() {
+      this.unlisten(this.keyEventTarget, 'up', 'uiUpAction');
+      this.unlisten(this.keyEventTarget, 'down', 'uiDownAction');
+      this.keyEventTarget = null;
+    },
+    get shouldKeepAnimating() {
+      for (var index = 0; index < this.ripples.length; ++index) {
+        if (!this.ripples[index].isAnimationComplete) {
+          return true;
+        }
+      }
+      return false;
+    },
+    simulatedRipple: function() {
+      this.downAction(null);
+      this.async(function() {
+        this.upAction();
+      }, 1);
+    },
+    uiDownAction: function(event) {
+      if (!this.noink) {
+        this.downAction(event);
+      }
+    },
+    downAction: function(event) {
+      if (this.holdDown && this.ripples.length > 0) {
+        return;
+      }
+      var ripple = this.addRipple();
+      ripple.downAction(event);
+      if (!this._animating) {
+        this._animating = true;
+        this.animate();
+      }
+    },
+    uiUpAction: function(event) {
+      if (!this.noink) {
+        this.upAction(event);
+      }
+    },
+    upAction: function(event) {
+      if (this.holdDown) {
+        return;
+      }
+      this.ripples.forEach(function(ripple) {
+        ripple.upAction(event);
+      });
+      this._animating = true;
+      this.animate();
+    },
+    onAnimationComplete: function() {
+      this._animating = false;
+      this.$.background.style.backgroundColor = null;
+      this.fire('transitionend');
+    },
+    addRipple: function() {
+      var ripple = new Ripple(this);
+      Polymer.dom(this.$.waves).appendChild(ripple.waveContainer);
+      this.$.background.style.backgroundColor = ripple.color;
+      this.ripples.push(ripple);
+      this._setAnimating(true);
+      return ripple;
+    },
+    removeRipple: function(ripple) {
+      var rippleIndex = this.ripples.indexOf(ripple);
+      if (rippleIndex < 0) {
+        return;
+      }
+      this.ripples.splice(rippleIndex, 1);
+      ripple.remove();
+      if (!this.ripples.length) {
+        this._setAnimating(false);
+      }
+    },
+    animate: function() {
+      if (!this._animating) {
+        return;
+      }
+      var index;
+      var ripple;
+      for (index = 0; index < this.ripples.length; ++index) {
+        ripple = this.ripples[index];
+        ripple.draw();
+        this.$.background.style.opacity = ripple.outerOpacity;
+        if (ripple.isOpacityFullyDecayed && !ripple.isRestingAtMaxRadius) {
+          this.removeRipple(ripple);
+        }
+      }
+      if (!this.shouldKeepAnimating && this.ripples.length === 0) {
+        this.onAnimationComplete();
+      } else {
+        window.requestAnimationFrame(this._boundAnimate);
+      }
+    },
+    _onEnterKeydown: function() {
+      this.uiDownAction();
+      this.async(this.uiUpAction, 1);
+    },
+    _onSpaceKeydown: function() {
+      this.uiDownAction();
+    },
+    _onSpaceKeyup: function() {
+      this.uiUpAction();
+    },
+    _holdDownChanged: function(newVal, oldVal) {
+      if (oldVal === undefined) {
+        return;
+      }
+      if (newVal) {
+        this.downAction();
+      } else {
+        this.upAction();
+      }
+    }
+  });
+})();
+
+Polymer.PaperRippleBehavior = {
+  properties: {
+    noink: {
+      type: Boolean,
+      observer: '_noinkChanged'
+    },
+    _rippleContainer: {
+      type: Object
+    }
+  },
+  _buttonStateChanged: function() {
+    if (this.focused) {
+      this.ensureRipple();
+    }
+  },
+  _downHandler: function(event) {
+    Polymer.IronButtonStateImpl._downHandler.call(this, event);
+    if (this.pressed) {
+      this.ensureRipple(event);
+    }
+  },
+  ensureRipple: function(optTriggeringEvent) {
+    if (!this.hasRipple()) {
+      this._ripple = this._createRipple();
+      this._ripple.noink = this.noink;
+      var rippleContainer = this._rippleContainer || this.root;
+      if (rippleContainer) {
+        Polymer.dom(rippleContainer).appendChild(this._ripple);
+      }
+      if (optTriggeringEvent) {
+        var domContainer = Polymer.dom(this._rippleContainer || this);
+        var target = Polymer.dom(optTriggeringEvent).rootTarget;
+        if (domContainer.deepContains(target)) {
+          this._ripple.uiDownAction(optTriggeringEvent);
+        }
+      }
+    }
+  },
+  getRipple: function() {
+    this.ensureRipple();
+    return this._ripple;
+  },
+  hasRipple: function() {
+    return Boolean(this._ripple);
+  },
+  _createRipple: function() {
+    return document.createElement('paper-ripple');
+  },
+  _noinkChanged: function(noink) {
+    if (this.hasRipple()) {
+      this._ripple.noink = noink;
+    }
+  }
+};
+
+Polymer.PaperButtonBehaviorImpl = {
+  properties: {
+    elevation: {
+      type: Number,
+      reflectToAttribute: true,
+      readOnly: true
+    }
+  },
+  observers: [ '_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)', '_computeKeyboardClass(receivedFocusFromKeyboard)' ],
+  hostAttributes: {
+    role: 'button',
+    tabindex: '0',
+    animated: true
+  },
+  _calculateElevation: function() {
+    var e = 1;
+    if (this.disabled) {
+      e = 0;
+    } else if (this.active || this.pressed) {
+      e = 4;
+    } else if (this.receivedFocusFromKeyboard) {
+      e = 3;
+    }
+    this._setElevation(e);
+  },
+  _computeKeyboardClass: function(receivedFocusFromKeyboard) {
+    this.toggleClass('keyboard-focus', receivedFocusFromKeyboard);
+  },
+  _spaceKeyDownHandler: function(event) {
+    Polymer.IronButtonStateImpl._spaceKeyDownHandler.call(this, event);
+    if (this.hasRipple() && this.getRipple().ripples.length < 1) {
+      this._ripple.uiDownAction();
+    }
+  },
+  _spaceKeyUpHandler: function(event) {
+    Polymer.IronButtonStateImpl._spaceKeyUpHandler.call(this, event);
+    if (this.hasRipple()) {
+      this._ripple.uiUpAction();
+    }
+  }
+};
+
+Polymer.PaperButtonBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperButtonBehaviorImpl ];
+
+Polymer({
+  is: 'paper-button',
+  behaviors: [ Polymer.PaperButtonBehavior ],
+  properties: {
+    raised: {
+      type: Boolean,
+      reflectToAttribute: true,
+      value: false,
+      observer: '_calculateElevation'
+    }
+  },
+  _calculateElevation: function() {
+    if (!this.raised) {
+      this._setElevation(0);
+    } else {
+      Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this);
+    }
+  }
+});
+
+(function() {
+  var metaDatas = {};
+  var metaArrays = {};
+  var singleton = null;
+  Polymer.IronMeta = Polymer({
+    is: 'iron-meta',
+    properties: {
+      type: {
+        type: String,
+        value: 'default',
+        observer: '_typeChanged'
+      },
+      key: {
+        type: String,
+        observer: '_keyChanged'
+      },
+      value: {
+        type: Object,
+        notify: true,
+        observer: '_valueChanged'
+      },
+      self: {
+        type: Boolean,
+        observer: '_selfChanged'
+      },
+      list: {
+        type: Array,
+        notify: true
+      }
+    },
+    hostAttributes: {
+      hidden: true
+    },
+    factoryImpl: function(config) {
+      if (config) {
+        for (var n in config) {
+          switch (n) {
+           case 'type':
+           case 'key':
+           case 'value':
+            this[n] = config[n];
+            break;
+          }
+        }
+      }
+    },
+    created: function() {
+      this._metaDatas = metaDatas;
+      this._metaArrays = metaArrays;
+    },
+    _keyChanged: function(key, old) {
+      this._resetRegistration(old);
+    },
+    _valueChanged: function(value) {
+      this._resetRegistration(this.key);
+    },
+    _selfChanged: function(self) {
+      if (self) {
+        this.value = this;
+      }
+    },
+    _typeChanged: function(type) {
+      this._unregisterKey(this.key);
+      if (!metaDatas[type]) {
+        metaDatas[type] = {};
+      }
+      this._metaData = metaDatas[type];
+      if (!metaArrays[type]) {
+        metaArrays[type] = [];
+      }
+      this.list = metaArrays[type];
+      this._registerKeyValue(this.key, this.value);
+    },
+    byKey: function(key) {
+      return this._metaData && this._metaData[key];
+    },
+    _resetRegistration: function(oldKey) {
+      this._unregisterKey(oldKey);
+      this._registerKeyValue(this.key, this.value);
+    },
+    _unregisterKey: function(key) {
+      this._unregister(key, this._metaData, this.list);
+    },
+    _registerKeyValue: function(key, value) {
+      this._register(key, value, this._metaData, this.list);
+    },
+    _register: function(key, value, data, list) {
+      if (key && data && value !== undefined) {
+        data[key] = value;
+        list.push(value);
+      }
+    },
+    _unregister: function(key, data, list) {
+      if (key && data) {
+        if (key in data) {
+          var value = data[key];
+          delete data[key];
+          this.arrayDelete(list, value);
+        }
+      }
+    }
+  });
+  Polymer.IronMeta.getIronMeta = function getIronMeta() {
+    if (singleton === null) {
+      singleton = new Polymer.IronMeta();
+    }
+    return singleton;
+  };
+  Polymer.IronMetaQuery = Polymer({
+    is: 'iron-meta-query',
+    properties: {
+      type: {
+        type: String,
+        value: 'default',
+        observer: '_typeChanged'
+      },
+      key: {
+        type: String,
+        observer: '_keyChanged'
+      },
+      value: {
+        type: Object,
+        notify: true,
+        readOnly: true
+      },
+      list: {
+        type: Array,
+        notify: true
+      }
+    },
+    factoryImpl: function(config) {
+      if (config) {
+        for (var n in config) {
+          switch (n) {
+           case 'type':
+           case 'key':
+            this[n] = config[n];
+            break;
+          }
+        }
+      }
+    },
+    created: function() {
+      this._metaDatas = metaDatas;
+      this._metaArrays = metaArrays;
+    },
+    _keyChanged: function(key) {
+      this._setValue(this._metaData && this._metaData[key]);
+    },
+    _typeChanged: function(type) {
+      this._metaData = metaDatas[type];
+      this.list = metaArrays[type];
+      if (this.key) {
+        this._keyChanged(this.key);
+      }
+    },
+    byKey: function(key) {
+      return this._metaData && this._metaData[key];
+    }
+  });
+})();
+
+Polymer({
+  is: 'iron-icon',
+  properties: {
+    icon: {
+      type: String,
+      observer: '_iconChanged'
+    },
+    theme: {
+      type: String,
+      observer: '_updateIcon'
+    },
+    src: {
+      type: String,
+      observer: '_srcChanged'
+    },
+    _meta: {
+      value: Polymer.Base.create('iron-meta', {
+        type: 'iconset'
+      }),
+      observer: '_updateIcon'
+    }
+  },
+  _DEFAULT_ICONSET: 'icons',
+  _iconChanged: function(icon) {
+    var parts = (icon || '').split(':');
+    this._iconName = parts.pop();
+    this._iconsetName = parts.pop() || this._DEFAULT_ICONSET;
+    this._updateIcon();
+  },
+  _srcChanged: function(src) {
+    this._updateIcon();
+  },
+  _usesIconset: function() {
+    return this.icon || !this.src;
+  },
+  _updateIcon: function() {
+    if (this._usesIconset()) {
+      if (this._img && this._img.parentNode) {
+        Polymer.dom(this.root).removeChild(this._img);
+      }
+      if (this._iconName === "") {
+        if (this._iconset) {
+          this._iconset.removeIcon(this);
+        }
+      } else if (this._iconsetName && this._meta) {
+        this._iconset = this._meta.byKey(this._iconsetName);
+        if (this._iconset) {
+          this._iconset.applyIcon(this, this._iconName, this.theme);
+          this.unlisten(window, 'iron-iconset-added', '_updateIcon');
+        } else {
+          this.listen(window, 'iron-iconset-added', '_updateIcon');
+        }
+      }
+    } else {
+      if (this._iconset) {
+        this._iconset.removeIcon(this);
+      }
+      if (!this._img) {
+        this._img = document.createElement('img');
+        this._img.style.width = '100%';
+        this._img.style.height = '100%';
+        this._img.draggable = false;
+      }
+      this._img.src = this.src;
+      Polymer.dom(this.root).appendChild(this._img);
+    }
+  }
+});
+
+Polymer.PaperInkyFocusBehaviorImpl = {
+  observers: [ '_focusedChanged(receivedFocusFromKeyboard)' ],
+  _focusedChanged: function(receivedFocusFromKeyboard) {
+    if (receivedFocusFromKeyboard) {
+      this.ensureRipple();
+    }
+    if (this.hasRipple()) {
+      this._ripple.holdDown = receivedFocusFromKeyboard;
+    }
+  },
+  _createRipple: function() {
+    var ripple = Polymer.PaperRippleBehavior._createRipple();
+    ripple.id = 'ink';
+    ripple.setAttribute('center', '');
+    ripple.classList.add('circle');
+    return ripple;
+  }
+};
+
+Polymer.PaperInkyFocusBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperInkyFocusBehaviorImpl ];
+
+Polymer({
+  is: 'paper-icon-button',
+  hostAttributes: {
+    role: 'button',
+    tabindex: '0'
+  },
+  behaviors: [ Polymer.PaperInkyFocusBehavior ],
+  properties: {
+    src: {
+      type: String
+    },
+    icon: {
+      type: String
+    },
+    alt: {
+      type: String,
+      observer: "_altChanged"
+    }
+  },
+  _altChanged: function(newValue, oldValue) {
+    var label = this.getAttribute('aria-label');
+    if (!label || oldValue == label) {
+      this.setAttribute('aria-label', newValue);
+    }
+  }
+});
+
+Polymer({
+  is: 'paper-tab',
+  behaviors: [ Polymer.IronControlState, Polymer.IronButtonState, Polymer.PaperRippleBehavior ],
+  properties: {
+    link: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    }
+  },
+  hostAttributes: {
+    role: 'tab'
+  },
+  listeners: {
+    down: '_updateNoink',
+    tap: '_onTap'
+  },
+  attached: function() {
+    this._updateNoink();
+  },
+  get _parentNoink() {
+    var parent = Polymer.dom(this).parentNode;
+    return !!parent && !!parent.noink;
+  },
+  _updateNoink: function() {
+    this.noink = !!this.noink || !!this._parentNoink;
+  },
+  _onTap: function(event) {
+    if (this.link) {
+      var anchor = this.queryEffectiveChildren('a');
+      if (!anchor) {
+        return;
+      }
+      if (event.target === anchor) {
+        return;
+      }
+      anchor.click();
+    }
+  }
+});
+
+Polymer.IronMultiSelectableBehaviorImpl = {
+  properties: {
+    multi: {
+      type: Boolean,
+      value: false,
+      observer: 'multiChanged'
+    },
+    selectedValues: {
+      type: Array,
+      notify: true
+    },
+    selectedItems: {
+      type: Array,
+      readOnly: true,
+      notify: true
+    }
+  },
+  observers: [ '_updateSelected(selectedValues.splices)' ],
+  select: function(value) {
+    if (this.multi) {
+      if (this.selectedValues) {
+        this._toggleSelected(value);
+      } else {
+        this.selectedValues = [ value ];
+      }
+    } else {
+      this.selected = value;
+    }
+  },
+  multiChanged: function(multi) {
+    this._selection.multi = multi;
+  },
+  get _shouldUpdateSelection() {
+    return this.selected != null || this.selectedValues != null && this.selectedValues.length;
+  },
+  _updateAttrForSelected: function() {
+    if (!this.multi) {
+      Polymer.IronSelectableBehavior._updateAttrForSelected.apply(this);
+    } else if (this._shouldUpdateSelection) {
+      this.selectedValues = this.selectedItems.map(function(selectedItem) {
+        return this._indexToValue(this.indexOf(selectedItem));
+      }, this).filter(function(unfilteredValue) {
+        return unfilteredValue != null;
+      }, this);
+    }
+  },
+  _updateSelected: function() {
+    if (this.multi) {
+      this._selectMulti(this.selectedValues);
+    } else {
+      this._selectSelected(this.selected);
+    }
+  },
+  _selectMulti: function(values) {
+    if (values) {
+      var selectedItems = this._valuesToItems(values);
+      this._selection.clear(selectedItems);
+      for (var i = 0; i < selectedItems.length; i++) {
+        this._selection.setItemSelected(selectedItems[i], true);
+      }
+      if (this.fallbackSelection && this.items.length && !this._selection.get().length) {
+        var fallback = this._valueToItem(this.fallbackSelection);
+        if (fallback) {
+          this.selectedValues = [ this.fallbackSelection ];
+        }
+      }
+    } else {
+      this._selection.clear();
+    }
+  },
+  _selectionChange: function() {
+    var s = this._selection.get();
+    if (this.multi) {
+      this._setSelectedItems(s);
+    } else {
+      this._setSelectedItems([ s ]);
+      this._setSelectedItem(s);
+    }
+  },
+  _toggleSelected: function(value) {
+    var i = this.selectedValues.indexOf(value);
+    var unselected = i < 0;
+    if (unselected) {
+      this.push('selectedValues', value);
+    } else {
+      this.splice('selectedValues', i, 1);
+    }
+  },
+  _valuesToItems: function(values) {
+    return values == null ? null : values.map(function(value) {
+      return this._valueToItem(value);
+    }, this);
+  }
+};
+
+Polymer.IronMultiSelectableBehavior = [ Polymer.IronSelectableBehavior, Polymer.IronMultiSelectableBehaviorImpl ];
+
+Polymer.IronMenuBehaviorImpl = {
+  properties: {
+    focusedItem: {
+      observer: '_focusedItemChanged',
+      readOnly: true,
+      type: Object
+    },
+    attrForItemTitle: {
+      type: String
+    }
+  },
+  hostAttributes: {
+    role: 'menu',
+    tabindex: '0'
+  },
+  observers: [ '_updateMultiselectable(multi)' ],
+  listeners: {
+    focus: '_onFocus',
+    keydown: '_onKeydown',
+    'iron-items-changed': '_onIronItemsChanged'
+  },
+  keyBindings: {
+    up: '_onUpKey',
+    down: '_onDownKey',
+    esc: '_onEscKey',
+    'shift+tab:keydown': '_onShiftTabDown'
+  },
+  attached: function() {
+    this._resetTabindices();
+  },
+  select: function(value) {
+    if (this._defaultFocusAsync) {
+      this.cancelAsync(this._defaultFocusAsync);
+      this._defaultFocusAsync = null;
+    }
+    var item = this._valueToItem(value);
+    if (item && item.hasAttribute('disabled')) return;
+    this._setFocusedItem(item);
+    Polymer.IronMultiSelectableBehaviorImpl.select.apply(this, arguments);
+  },
+  _resetTabindices: function() {
+    var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
+    this.items.forEach(function(item) {
+      item.setAttribute('tabindex', item === selectedItem ? '0' : '-1');
+    }, this);
+  },
+  _updateMultiselectable: function(multi) {
+    if (multi) {
+      this.setAttribute('aria-multiselectable', 'true');
+    } else {
+      this.removeAttribute('aria-multiselectable');
+    }
+  },
+  _focusWithKeyboardEvent: function(event) {
+    for (var i = 0, item; item = this.items[i]; i++) {
+      var attr = this.attrForItemTitle || 'textContent';
+      var title = item[attr] || item.getAttribute(attr);
+      if (!item.hasAttribute('disabled') && title && title.trim().charAt(0).toLowerCase() === String.fromCharCode(event.keyCode).toLowerCase()) {
+        this._setFocusedItem(item);
+        break;
+      }
+    }
+  },
+  _focusPrevious: function() {
+    var length = this.items.length;
+    var curFocusIndex = Number(this.indexOf(this.focusedItem));
+    for (var i = 1; i < length + 1; i++) {
+      var item = this.items[(curFocusIndex - i + length) % length];
+      if (!item.hasAttribute('disabled')) {
+        this._setFocusedItem(item);
+        return;
+      }
+    }
+  },
+  _focusNext: function() {
+    var length = this.items.length;
+    var curFocusIndex = Number(this.indexOf(this.focusedItem));
+    for (var i = 1; i < length + 1; i++) {
+      var item = this.items[(curFocusIndex + i) % length];
+      if (!item.hasAttribute('disabled')) {
+        this._setFocusedItem(item);
+        return;
+      }
+    }
+  },
+  _applySelection: function(item, isSelected) {
+    if (isSelected) {
+      item.setAttribute('aria-selected', 'true');
+    } else {
+      item.removeAttribute('aria-selected');
+    }
+    Polymer.IronSelectableBehavior._applySelection.apply(this, arguments);
+  },
+  _focusedItemChanged: function(focusedItem, old) {
+    old && old.setAttribute('tabindex', '-1');
+    if (focusedItem) {
+      focusedItem.setAttribute('tabindex', '0');
+      focusedItem.focus();
+    }
+  },
+  _onIronItemsChanged: function(event) {
+    if (event.detail.addedNodes.length) {
+      this._resetTabindices();
+    }
+  },
+  _onShiftTabDown: function(event) {
+    var oldTabIndex = this.getAttribute('tabindex');
+    Polymer.IronMenuBehaviorImpl._shiftTabPressed = true;
+    this._setFocusedItem(null);
+    this.setAttribute('tabindex', '-1');
+    this.async(function() {
+      this.setAttribute('tabindex', oldTabIndex);
+      Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
+    }, 1);
+  },
+  _onFocus: function(event) {
+    if (Polymer.IronMenuBehaviorImpl._shiftTabPressed) {
+      return;
+    }
+    var rootTarget = Polymer.dom(event).rootTarget;
+    if (rootTarget !== this && typeof rootTarget.tabIndex !== "undefined" && !this.isLightDescendant(rootTarget)) {
+      return;
+    }
+    this._defaultFocusAsync = this.async(function() {
+      var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
+      this._setFocusedItem(null);
+      if (selectedItem) {
+        this._setFocusedItem(selectedItem);
+      } else if (this.items[0]) {
+        this._focusNext();
+      }
+    });
+  },
+  _onUpKey: function(event) {
+    this._focusPrevious();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onDownKey: function(event) {
+    this._focusNext();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onEscKey: function(event) {
+    this.focusedItem.blur();
+  },
+  _onKeydown: function(event) {
+    if (!this.keyboardEventMatchesKeys(event, 'up down esc')) {
+      this._focusWithKeyboardEvent(event);
+    }
+    event.stopPropagation();
+  },
+  _activateHandler: function(event) {
+    Polymer.IronSelectableBehavior._activateHandler.call(this, event);
+    event.stopPropagation();
+  }
+};
+
+Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
+
+Polymer.IronMenuBehavior = [ Polymer.IronMultiSelectableBehavior, Polymer.IronA11yKeysBehavior, Polymer.IronMenuBehaviorImpl ];
+
+Polymer.IronMenubarBehaviorImpl = {
+  hostAttributes: {
+    role: 'menubar'
+  },
+  keyBindings: {
+    left: '_onLeftKey',
+    right: '_onRightKey'
+  },
+  _onUpKey: function(event) {
+    this.focusedItem.click();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onDownKey: function(event) {
+    this.focusedItem.click();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  get _isRTL() {
+    return window.getComputedStyle(this)['direction'] === 'rtl';
+  },
+  _onLeftKey: function(event) {
+    if (this._isRTL) {
+      this._focusNext();
+    } else {
+      this._focusPrevious();
+    }
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onRightKey: function(event) {
+    if (this._isRTL) {
+      this._focusPrevious();
+    } else {
+      this._focusNext();
+    }
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onKeydown: function(event) {
+    if (this.keyboardEventMatchesKeys(event, 'up down left right esc')) {
+      return;
+    }
+    this._focusWithKeyboardEvent(event);
+  }
+};
+
+Polymer.IronMenubarBehavior = [ Polymer.IronMenuBehavior, Polymer.IronMenubarBehaviorImpl ];
+
+Polymer({
+  is: 'iron-iconset-svg',
+  properties: {
+    name: {
+      type: String,
+      observer: '_nameChanged'
+    },
+    size: {
+      type: Number,
+      value: 24
+    }
+  },
+  attached: function() {
+    this.style.display = 'none';
+  },
+  getIconNames: function() {
+    this._icons = this._createIconMap();
+    return Object.keys(this._icons).map(function(n) {
+      return this.name + ':' + n;
+    }, this);
+  },
+  applyIcon: function(element, iconName) {
+    element = element.root || element;
+    this.removeIcon(element);
+    var svg = this._cloneIcon(iconName);
+    if (svg) {
+      var pde = Polymer.dom(element);
+      pde.insertBefore(svg, pde.childNodes[0]);
+      return element._svgIcon = svg;
+    }
+    return null;
+  },
+  removeIcon: function(element) {
+    if (element._svgIcon) {
+      Polymer.dom(element).removeChild(element._svgIcon);
+      element._svgIcon = null;
+    }
+  },
+  _nameChanged: function() {
+    new Polymer.IronMeta({
+      type: 'iconset',
+      key: this.name,
+      value: this
+    });
+    this.async(function() {
+      this.fire('iron-iconset-added', this, {
+        node: window
+      });
+    });
+  },
+  _createIconMap: function() {
+    var icons = Object.create(null);
+    Polymer.dom(this).querySelectorAll('[id]').forEach(function(icon) {
+      icons[icon.id] = icon;
+    });
+    return icons;
+  },
+  _cloneIcon: function(id) {
+    this._icons = this._icons || this._createIconMap();
+    return this._prepareSvgClone(this._icons[id], this.size);
+  },
+  _prepareSvgClone: function(sourceSvg, size) {
+    if (sourceSvg) {
+      var content = sourceSvg.cloneNode(true), svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'), viewBox = content.getAttribute('viewBox') || '0 0 ' + size + ' ' + size;
+      svg.setAttribute('viewBox', viewBox);
+      svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
+      svg.style.cssText = 'pointer-events: none; display: block; width: 100%; height: 100%;';
+      svg.appendChild(content).removeAttribute('id');
+      return svg;
+    }
+    return null;
+  }
+});
+
+Polymer({
+  is: 'paper-tabs',
+  behaviors: [ Polymer.IronResizableBehavior, Polymer.IronMenubarBehavior ],
+  properties: {
+    noink: {
+      type: Boolean,
+      value: false,
+      observer: '_noinkChanged'
+    },
+    noBar: {
+      type: Boolean,
+      value: false
+    },
+    noSlide: {
+      type: Boolean,
+      value: false
+    },
+    scrollable: {
+      type: Boolean,
+      value: false
+    },
+    fitContainer: {
+      type: Boolean,
+      value: false
+    },
+    disableDrag: {
+      type: Boolean,
+      value: false
+    },
+    hideScrollButtons: {
+      type: Boolean,
+      value: false
+    },
+    alignBottom: {
+      type: Boolean,
+      value: false
+    },
+    selectable: {
+      type: String,
+      value: 'paper-tab'
+    },
+    autoselect: {
+      type: Boolean,
+      value: false
+    },
+    autoselectDelay: {
+      type: Number,
+      value: 0
+    },
+    _step: {
+      type: Number,
+      value: 10
+    },
+    _holdDelay: {
+      type: Number,
+      value: 1
+    },
+    _leftHidden: {
+      type: Boolean,
+      value: false
+    },
+    _rightHidden: {
+      type: Boolean,
+      value: false
+    },
+    _previousTab: {
+      type: Object
+    }
+  },
+  hostAttributes: {
+    role: 'tablist'
+  },
+  listeners: {
+    'iron-resize': '_onTabSizingChanged',
+    'iron-items-changed': '_onTabSizingChanged',
+    'iron-select': '_onIronSelect',
+    'iron-deselect': '_onIronDeselect'
+  },
+  keyBindings: {
+    'left:keyup right:keyup': '_onArrowKeyup'
+  },
+  created: function() {
+    this._holdJob = null;
+    this._pendingActivationItem = undefined;
+    this._pendingActivationTimeout = undefined;
+    this._bindDelayedActivationHandler = this._delayedActivationHandler.bind(this);
+    this.addEventListener('blur', this._onBlurCapture.bind(this), true);
+  },
+  ready: function() {
+    this.setScrollDirection('y', this.$.tabsContainer);
+  },
+  detached: function() {
+    this._cancelPendingActivation();
+  },
+  _noinkChanged: function(noink) {
+    var childTabs = Polymer.dom(this).querySelectorAll('paper-tab');
+    childTabs.forEach(noink ? this._setNoinkAttribute : this._removeNoinkAttribute);
+  },
+  _setNoinkAttribute: function(element) {
+    element.setAttribute('noink', '');
+  },
+  _removeNoinkAttribute: function(element) {
+    element.removeAttribute('noink');
+  },
+  _computeScrollButtonClass: function(hideThisButton, scrollable, hideScrollButtons) {
+    if (!scrollable || hideScrollButtons) {
+      return 'hidden';
+    }
+    if (hideThisButton) {
+      return 'not-visible';
+    }
+    return '';
+  },
+  _computeTabsContentClass: function(scrollable, fitContainer) {
+    return scrollable ? 'scrollable' + (fitContainer ? ' fit-container' : '') : ' fit-container';
+  },
+  _computeSelectionBarClass: function(noBar, alignBottom) {
+    if (noBar) {
+      return 'hidden';
+    } else if (alignBottom) {
+      return 'align-bottom';
+    }
+    return '';
+  },
+  _onTabSizingChanged: function() {
+    this.debounce('_onTabSizingChanged', function() {
+      this._scroll();
+      this._tabChanged(this.selectedItem);
+    }, 10);
+  },
+  _onIronSelect: function(event) {
+    this._tabChanged(event.detail.item, this._previousTab);
+    this._previousTab = event.detail.item;
+    this.cancelDebouncer('tab-changed');
+  },
+  _onIronDeselect: function(event) {
+    this.debounce('tab-changed', function() {
+      this._tabChanged(null, this._previousTab);
+      this._previousTab = null;
+    }, 1);
+  },
+  _activateHandler: function() {
+    this._cancelPendingActivation();
+    Polymer.IronMenuBehaviorImpl._activateHandler.apply(this, arguments);
+  },
+  _scheduleActivation: function(item, delay) {
+    this._pendingActivationItem = item;
+    this._pendingActivationTimeout = this.async(this._bindDelayedActivationHandler, delay);
+  },
+  _delayedActivationHandler: function() {
+    var item = this._pendingActivationItem;
+    this._pendingActivationItem = undefined;
+    this._pendingActivationTimeout = undefined;
+    item.fire(this.activateEvent, null, {
+      bubbles: true,
+      cancelable: true
+    });
+  },
+  _cancelPendingActivation: function() {
+    if (this._pendingActivationTimeout !== undefined) {
+      this.cancelAsync(this._pendingActivationTimeout);
+      this._pendingActivationItem = undefined;
+      this._pendingActivationTimeout = undefined;
+    }
+  },
+  _onArrowKeyup: function(event) {
+    if (this.autoselect) {
+      this._scheduleActivation(this.focusedItem, this.autoselectDelay);
+    }
+  },
+  _onBlurCapture: function(event) {
+    if (event.target === this._pendingActivationItem) {
+      this._cancelPendingActivation();
+    }
+  },
+  get _tabContainerScrollSize() {
+    return Math.max(0, this.$.tabsContainer.scrollWidth - this.$.tabsContainer.offsetWidth);
+  },
+  _scroll: function(e, detail) {
+    if (!this.scrollable) {
+      return;
+    }
+    var ddx = detail && -detail.ddx || 0;
+    this._affectScroll(ddx);
+  },
+  _down: function(e) {
+    this.async(function() {
+      if (this._defaultFocusAsync) {
+        this.cancelAsync(this._defaultFocusAsync);
+        this._defaultFocusAsync = null;
+      }
+    }, 1);
+  },
+  _affectScroll: function(dx) {
+    this.$.tabsContainer.scrollLeft += dx;
+    var scrollLeft = this.$.tabsContainer.scrollLeft;
+    this._leftHidden = scrollLeft === 0;
+    this._rightHidden = scrollLeft === this._tabContainerScrollSize;
+  },
+  _onLeftScrollButtonDown: function() {
+    this._scrollToLeft();
+    this._holdJob = setInterval(this._scrollToLeft.bind(this), this._holdDelay);
+  },
+  _onRightScrollButtonDown: function() {
+    this._scrollToRight();
+    this._holdJob = setInterval(this._scrollToRight.bind(this), this._holdDelay);
+  },
+  _onScrollButtonUp: function() {
+    clearInterval(this._holdJob);
+    this._holdJob = null;
+  },
+  _scrollToLeft: function() {
+    this._affectScroll(-this._step);
+  },
+  _scrollToRight: function() {
+    this._affectScroll(this._step);
+  },
+  _tabChanged: function(tab, old) {
+    if (!tab) {
+      this.$.selectionBar.classList.remove('expand');
+      this.$.selectionBar.classList.remove('contract');
+      this._positionBar(0, 0);
+      return;
+    }
+    var r = this.$.tabsContent.getBoundingClientRect();
+    var w = r.width;
+    var tabRect = tab.getBoundingClientRect();
+    var tabOffsetLeft = tabRect.left - r.left;
+    this._pos = {
+      width: this._calcPercent(tabRect.width, w),
+      left: this._calcPercent(tabOffsetLeft, w)
+    };
+    if (this.noSlide || old == null) {
+      this.$.selectionBar.classList.remove('expand');
+      this.$.selectionBar.classList.remove('contract');
+      this._positionBar(this._pos.width, this._pos.left);
+      return;
+    }
+    var oldRect = old.getBoundingClientRect();
+    var oldIndex = this.items.indexOf(old);
+    var index = this.items.indexOf(tab);
+    var m = 5;
+    this.$.selectionBar.classList.add('expand');
+    var moveRight = oldIndex < index;
+    var isRTL = this._isRTL;
+    if (isRTL) {
+      moveRight = !moveRight;
+    }
+    if (moveRight) {
+      this._positionBar(this._calcPercent(tabRect.left + tabRect.width - oldRect.left, w) - m, this._left);
+    } else {
+      this._positionBar(this._calcPercent(oldRect.left + oldRect.width - tabRect.left, w) - m, this._calcPercent(tabOffsetLeft, w) + m);
+    }
+    if (this.scrollable) {
+      this._scrollToSelectedIfNeeded(tabRect.width, tabOffsetLeft);
+    }
+  },
+  _scrollToSelectedIfNeeded: function(tabWidth, tabOffsetLeft) {
+    var l = tabOffsetLeft - this.$.tabsContainer.scrollLeft;
+    if (l < 0) {
+      this.$.tabsContainer.scrollLeft += l;
+    } else {
+      l += tabWidth - this.$.tabsContainer.offsetWidth;
+      if (l > 0) {
+        this.$.tabsContainer.scrollLeft += l;
+      }
+    }
+  },
+  _calcPercent: function(w, w0) {
+    return 100 * w / w0;
+  },
+  _positionBar: function(width, left) {
+    width = width || 0;
+    left = left || 0;
+    this._width = width;
+    this._left = left;
+    this.transform('translateX(' + left + '%) scaleX(' + width / 100 + ')', this.$.selectionBar);
+  },
+  _onBarTransitionEnd: function(e) {
+    var cl = this.$.selectionBar.classList;
+    if (cl.contains('expand')) {
+      cl.remove('expand');
+      cl.add('contract');
+      this._positionBar(this._pos.width, this._pos.left);
+    } else if (cl.contains('contract')) {
+      cl.remove('contract');
+    }
+  }
+});
+
+(function() {
+  'use strict';
+  Polymer.IronA11yAnnouncer = Polymer({
+    is: 'iron-a11y-announcer',
+    properties: {
+      mode: {
+        type: String,
+        value: 'polite'
+      },
+      _text: {
+        type: String,
+        value: ''
+      }
+    },
+    created: function() {
+      if (!Polymer.IronA11yAnnouncer.instance) {
+        Polymer.IronA11yAnnouncer.instance = this;
+      }
+      document.body.addEventListener('iron-announce', this._onIronAnnounce.bind(this));
+    },
+    announce: function(text) {
+      this._text = '';
+      this.async(function() {
+        this._text = text;
+      }, 100);
+    },
+    _onIronAnnounce: function(event) {
+      if (event.detail && event.detail.text) {
+        this.announce(event.detail.text);
+      }
+    }
+  });
+  Polymer.IronA11yAnnouncer.instance = null;
+  Polymer.IronA11yAnnouncer.requestAvailability = function() {
+    if (!Polymer.IronA11yAnnouncer.instance) {
+      Polymer.IronA11yAnnouncer.instance = document.createElement('iron-a11y-announcer');
+    }
+    document.body.appendChild(Polymer.IronA11yAnnouncer.instance);
+  };
+})();
+
+Polymer.IronValidatableBehaviorMeta = null;
+
+Polymer.IronValidatableBehavior = {
+  properties: {
+    validator: {
+      type: String
+    },
+    invalid: {
+      notify: true,
+      reflectToAttribute: true,
+      type: Boolean,
+      value: false
+    },
+    _validatorMeta: {
+      type: Object
+    },
+    validatorType: {
+      type: String,
+      value: 'validator'
+    },
+    _validator: {
+      type: Object,
+      computed: '__computeValidator(validator)'
+    }
+  },
+  observers: [ '_invalidChanged(invalid)' ],
+  registered: function() {
+    Polymer.IronValidatableBehaviorMeta = new Polymer.IronMeta({
+      type: 'validator'
+    });
+  },
+  _invalidChanged: function() {
+    if (this.invalid) {
+      this.setAttribute('aria-invalid', 'true');
+    } else {
+      this.removeAttribute('aria-invalid');
+    }
+  },
+  hasValidator: function() {
+    return this._validator != null;
+  },
+  validate: function(value) {
+    this.invalid = !this._getValidity(value);
+    return !this.invalid;
+  },
+  _getValidity: function(value) {
+    if (this.hasValidator()) {
+      return this._validator.validate(value);
+    }
+    return true;
+  },
+  __computeValidator: function() {
+    return Polymer.IronValidatableBehaviorMeta && Polymer.IronValidatableBehaviorMeta.byKey(this.validator);
+  }
+};
+
+Polymer({
+  is: 'iron-input',
+  "extends": 'input',
+  behaviors: [ Polymer.IronValidatableBehavior ],
+  properties: {
+    bindValue: {
+      observer: '_bindValueChanged',
+      type: String
+    },
+    preventInvalidInput: {
+      type: Boolean
+    },
+    allowedPattern: {
+      type: String,
+      observer: "_allowedPatternChanged"
+    },
+    _previousValidInput: {
+      type: String,
+      value: ''
+    },
+    _patternAlreadyChecked: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    input: '_onInput',
+    keypress: '_onKeypress'
+  },
+  registered: function() {
+    if (!this._canDispatchEventOnDisabled()) {
+      this._origDispatchEvent = this.dispatchEvent;
+      this.dispatchEvent = this._dispatchEventFirefoxIE;
+    }
+  },
+  created: function() {
+    Polymer.IronA11yAnnouncer.requestAvailability();
+  },
+  _canDispatchEventOnDisabled: function() {
+    var input = document.createElement('input');
+    var canDispatch = false;
+    input.disabled = true;
+    input.addEventListener('feature-check-dispatch-event', function() {
+      canDispatch = true;
+    });
+    try {
+      input.dispatchEvent(new Event('feature-check-dispatch-event'));
+    } catch (e) {}
+    return canDispatch;
+  },
+  _dispatchEventFirefoxIE: function() {
+    var disabled = this.disabled;
+    this.disabled = false;
+    this._origDispatchEvent.apply(this, arguments);
+    this.disabled = disabled;
+  },
+  get _patternRegExp() {
+    var pattern;
+    if (this.allowedPattern) {
+      pattern = new RegExp(this.allowedPattern);
+    } else {
+      switch (this.type) {
+       case 'number':
+        pattern = /[0-9.,e-]/;
+        break;
+      }
+    }
+    return pattern;
+  },
+  ready: function() {
+    this.bindValue = this.value;
+  },
+  _bindValueChanged: function() {
+    if (this.value !== this.bindValue) {
+      this.value = !(this.bindValue || this.bindValue === 0 || this.bindValue === false) ? '' : this.bindValue;
+    }
+    this.fire('bind-value-changed', {
+      value: this.bindValue
+    });
+  },
+  _allowedPatternChanged: function() {
+    this.preventInvalidInput = this.allowedPattern ? true : false;
+  },
+  _onInput: function() {
+    if (this.preventInvalidInput && !this._patternAlreadyChecked) {
+      var valid = this._checkPatternValidity();
+      if (!valid) {
+        this._announceInvalidCharacter('Invalid string of characters not entered.');
+        this.value = this._previousValidInput;
+      }
+    }
+    this.bindValue = this.value;
+    this._previousValidInput = this.value;
+    this._patternAlreadyChecked = false;
+  },
+  _isPrintable: function(event) {
+    var anyNonPrintable = event.keyCode == 8 || event.keyCode == 9 || event.keyCode == 13 || event.keyCode == 27;
+    var mozNonPrintable = event.keyCode == 19 || event.keyCode == 20 || event.keyCode == 45 || event.keyCode == 46 || event.keyCode == 144 || event.keyCode == 145 || event.keyCode > 32 && event.keyCode < 41 || event.keyCode > 111 && event.keyCode < 124;
+    return !anyNonPrintable && !(event.charCode == 0 && mozNonPrintable);
+  },
+  _onKeypress: function(event) {
+    if (!this.preventInvalidInput && this.type !== 'number') {
+      return;
+    }
+    var regexp = this._patternRegExp;
+    if (!regexp) {
+      return;
+    }
+    if (event.metaKey || event.ctrlKey || event.altKey) return;
+    this._patternAlreadyChecked = true;
+    var thisChar = String.fromCharCode(event.charCode);
+    if (this._isPrintable(event) && !regexp.test(thisChar)) {
+      event.preventDefault();
+      this._announceInvalidCharacter('Invalid character ' + thisChar + ' not entered.');
+    }
+  },
+  _checkPatternValidity: function() {
+    var regexp = this._patternRegExp;
+    if (!regexp) {
+      return true;
+    }
+    for (var i = 0; i < this.value.length; i++) {
+      if (!regexp.test(this.value[i])) {
+        return false;
+      }
+    }
+    return true;
+  },
+  validate: function() {
+    var valid = this.checkValidity();
+    if (valid) {
+      if (this.required && this.value === '') {
+        valid = false;
+      } else if (this.hasValidator()) {
+        valid = Polymer.IronValidatableBehavior.validate.call(this, this.value);
+      }
+    }
+    this.invalid = !valid;
+    this.fire('iron-input-validate');
+    return valid;
+  },
+  _announceInvalidCharacter: function(message) {
+    this.fire('iron-announce', {
+      text: message
+    });
+  }
+});
+
+Polymer({
+  is: 'paper-input-container',
+  properties: {
+    noLabelFloat: {
+      type: Boolean,
+      value: false
+    },
+    alwaysFloatLabel: {
+      type: Boolean,
+      value: false
+    },
+    attrForValue: {
+      type: String,
+      value: 'bind-value'
+    },
+    autoValidate: {
+      type: Boolean,
+      value: false
+    },
+    invalid: {
+      observer: '_invalidChanged',
+      type: Boolean,
+      value: false
+    },
+    focused: {
+      readOnly: true,
+      type: Boolean,
+      value: false,
+      notify: true
+    },
+    _addons: {
+      type: Array
+    },
+    _inputHasContent: {
+      type: Boolean,
+      value: false
+    },
+    _inputSelector: {
+      type: String,
+      value: 'input,textarea,.paper-input-input'
+    },
+    _boundOnFocus: {
+      type: Function,
+      value: function() {
+        return this._onFocus.bind(this);
+      }
+    },
+    _boundOnBlur: {
+      type: Function,
+      value: function() {
+        return this._onBlur.bind(this);
+      }
+    },
+    _boundOnInput: {
+      type: Function,
+      value: function() {
+        return this._onInput.bind(this);
+      }
+    },
+    _boundValueChanged: {
+      type: Function,
+      value: function() {
+        return this._onValueChanged.bind(this);
+      }
+    }
+  },
+  listeners: {
+    'addon-attached': '_onAddonAttached',
+    'iron-input-validate': '_onIronInputValidate'
+  },
+  get _valueChangedEvent() {
+    return this.attrForValue + '-changed';
+  },
+  get _propertyForValue() {
+    return Polymer.CaseMap.dashToCamelCase(this.attrForValue);
+  },
+  get _inputElement() {
+    return Polymer.dom(this).querySelector(this._inputSelector);
+  },
+  get _inputElementValue() {
+    return this._inputElement[this._propertyForValue] || this._inputElement.value;
+  },
+  ready: function() {
+    if (!this._addons) {
+      this._addons = [];
+    }
+    this.addEventListener('focus', this._boundOnFocus, true);
+    this.addEventListener('blur', this._boundOnBlur, true);
+  },
+  attached: function() {
+    if (this.attrForValue) {
+      this._inputElement.addEventListener(this._valueChangedEvent, this._boundValueChanged);
+    } else {
+      this.addEventListener('input', this._onInput);
+    }
+    if (this._inputElementValue != '') {
+      this._handleValueAndAutoValidate(this._inputElement);
+    } else {
+      this._handleValue(this._inputElement);
+    }
+  },
+  _onAddonAttached: function(event) {
+    if (!this._addons) {
+      this._addons = [];
+    }
+    var target = event.target;
+    if (this._addons.indexOf(target) === -1) {
+      this._addons.push(target);
+      if (this.isAttached) {
+        this._handleValue(this._inputElement);
+      }
+    }
+  },
+  _onFocus: function() {
+    this._setFocused(true);
+  },
+  _onBlur: function() {
+    this._setFocused(false);
+    this._handleValueAndAutoValidate(this._inputElement);
+  },
+  _onInput: function(event) {
+    this._handleValueAndAutoValidate(event.target);
+  },
+  _onValueChanged: function(event) {
+    this._handleValueAndAutoValidate(event.target);
+  },
+  _handleValue: function(inputElement) {
+    var value = this._inputElementValue;
+    if (value || value === 0 || inputElement.type === 'number' && !inputElement.checkValidity()) {
+      this._inputHasContent = true;
+    } else {
+      this._inputHasContent = false;
+    }
+    this.updateAddons({
+      inputElement: inputElement,
+      value: value,
+      invalid: this.invalid
+    });
+  },
+  _handleValueAndAutoValidate: function(inputElement) {
+    if (this.autoValidate) {
+      var valid;
+      if (inputElement.validate) {
+        valid = inputElement.validate(this._inputElementValue);
+      } else {
+        valid = inputElement.checkValidity();
+      }
+      this.invalid = !valid;
+    }
+    this._handleValue(inputElement);
+  },
+  _onIronInputValidate: function(event) {
+    this.invalid = this._inputElement.invalid;
+  },
+  _invalidChanged: function() {
+    if (this._addons) {
+      this.updateAddons({
+        invalid: this.invalid
+      });
+    }
+  },
+  updateAddons: function(state) {
+    for (var addon, index = 0; addon = this._addons[index]; index++) {
+      addon.update(state);
+    }
+  },
+  _computeInputContentClass: function(noLabelFloat, alwaysFloatLabel, focused, invalid, _inputHasContent) {
+    var cls = 'input-content';
+    if (!noLabelFloat) {
+      var label = this.querySelector('label');
+      if (alwaysFloatLabel || _inputHasContent) {
+        cls += ' label-is-floating';
+        this.$.labelAndInputContainer.style.position = 'static';
+        if (invalid) {
+          cls += ' is-invalid';
+        } else if (focused) {
+          cls += " label-is-highlighted";
+        }
+      } else {
+        if (label) {
+          this.$.labelAndInputContainer.style.position = 'relative';
+        }
+      }
+    } else {
+      if (_inputHasContent) {
+        cls += ' label-is-hidden';
+      }
+    }
+    return cls;
+  },
+  _computeUnderlineClass: function(focused, invalid) {
+    var cls = 'underline';
+    if (invalid) {
+      cls += ' is-invalid';
+    } else if (focused) {
+      cls += ' is-highlighted';
+    }
+    return cls;
+  },
+  _computeAddOnContentClass: function(focused, invalid) {
+    var cls = 'add-on-content';
+    if (invalid) {
+      cls += ' is-invalid';
+    } else if (focused) {
+      cls += ' is-highlighted';
+    }
+    return cls;
+  }
+});
+
+Polymer.PaperSpinnerBehavior = {
+  listeners: {
+    animationend: '__reset',
+    webkitAnimationEnd: '__reset'
+  },
+  properties: {
+    active: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true,
+      observer: '__activeChanged'
+    },
+    alt: {
+      type: String,
+      value: 'loading',
+      observer: '__altChanged'
+    },
+    __coolingDown: {
+      type: Boolean,
+      value: false
+    }
+  },
+  __computeContainerClasses: function(active, coolingDown) {
+    return [ active || coolingDown ? 'active' : '', coolingDown ? 'cooldown' : '' ].join(' ');
+  },
+  __activeChanged: function(active, old) {
+    this.__setAriaHidden(!active);
+    this.__coolingDown = !active && old;
+  },
+  __altChanged: function(alt) {
+    if (alt === this.getPropertyInfo('alt').value) {
+      this.alt = this.getAttribute('aria-label') || alt;
+    } else {
+      this.__setAriaHidden(alt === '');
+      this.setAttribute('aria-label', alt);
+    }
+  },
+  __setAriaHidden: function(hidden) {
+    var attr = 'aria-hidden';
+    if (hidden) {
+      this.setAttribute(attr, 'true');
+    } else {
+      this.removeAttribute(attr);
+    }
+  },
+  __reset: function() {
+    this.active = false;
+    this.__coolingDown = false;
+  }
+};
+
+Polymer({
+  is: 'paper-spinner-lite',
+  behaviors: [ Polymer.PaperSpinnerBehavior ]
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var CrSearchFieldBehavior = {
+  properties: {
+    label: {
+      type: String,
+      value: ''
+    },
+    clearLabel: {
+      type: String,
+      value: ''
+    },
+    showingSearch: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      observer: 'showingSearchChanged_',
+      reflectToAttribute: true
+    },
+    lastValue_: {
+      type: String,
+      value: ''
+    }
+  },
+  getSearchInput: function() {},
+  getValue: function() {
+    return this.getSearchInput().value;
+  },
+  setValue: function(value) {
+    this.getSearchInput().bindValue = value;
+    this.onValueChanged_(value);
+  },
+  showAndFocus: function() {
+    this.showingSearch = true;
+    this.focus_();
+  },
+  focus_: function() {
+    this.getSearchInput().focus();
+  },
+  onSearchTermSearch: function() {
+    this.onValueChanged_(this.getValue());
+  },
+  onValueChanged_: function(newValue) {
+    if (newValue == this.lastValue_) return;
+    this.fire('search-changed', newValue);
+    this.lastValue_ = newValue;
+  },
+  onSearchTermKeydown: function(e) {
+    if (e.key == 'Escape') this.showingSearch = false;
+  },
+  showingSearchChanged_: function() {
+    if (this.showingSearch) {
+      this.focus_();
+      return;
+    }
+    this.setValue('');
+    this.getSearchInput().blur();
+  }
+};
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-toolbar-search-field',
+  behaviors: [ CrSearchFieldBehavior ],
+  properties: {
+    narrow: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    label: String,
+    clearLabel: String,
+    spinnerActive: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    hasSearchText_: Boolean
+  },
+  listeners: {
+    tap: 'showSearch_',
+    'searchInput.bind-value-changed': 'onBindValueChanged_'
+  },
+  getSearchInput: function() {
+    return this.$.searchInput;
+  },
+  isSearchFocused: function() {
+    return this.$.searchTerm.focused;
+  },
+  computeIconTabIndex_: function(narrow) {
+    return narrow ? 0 : -1;
+  },
+  isSpinnerShown_: function(spinnerActive, showingSearch) {
+    return spinnerActive && showingSearch;
+  },
+  onInputBlur_: function() {
+    if (!this.hasSearchText_) this.showingSearch = false;
+  },
+  onBindValueChanged_: function() {
+    var newValue = this.$.searchInput.bindValue;
+    this.hasSearchText_ = newValue != '';
+    if (newValue != '') this.showingSearch = true;
+  },
+  showSearch_: function(e) {
+    if (e.target != this.$.clearSearch) this.showingSearch = true;
+  },
+  hideSearch_: function(e) {
+    this.showingSearch = false;
+    e.stopPropagation();
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-toolbar',
+  properties: {
+    pageName: String,
+    searchPrompt: String,
+    clearLabel: String,
+    spinnerActive: Boolean,
+    showMenu: {
+      type: Boolean,
+      reflectToAttribute: true,
+      value: true
+    },
+    narrow_: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    showingSearch_: {
+      type: Boolean,
+      reflectToAttribute: true
+    }
+  },
+  getSearchField: function() {
+    return this.$.search;
+  },
+  onMenuTap_: function(e) {
+    this.fire('cr-menu-tap');
+  }
+});
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-toolbar',
+  properties: {
+    count: {
+      type: Number,
+      value: 0,
+      observer: 'changeToolbarView_'
+    },
+    itemsSelected_: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    searchTerm: {
+      type: String,
+      notify: true
+    },
+    spinnerActive: {
+      type: Boolean,
+      value: false
+    },
+    hasDrawer: {
+      type: Boolean,
+      observer: 'hasDrawerChanged_',
+      reflectToAttribute: true
+    },
+    isGroupedMode: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    groupedRange: {
+      type: Number,
+      value: 0,
+      reflectToAttribute: true,
+      notify: true
+    },
+    queryStartTime: String,
+    queryEndTime: String
+  },
+  changeToolbarView_: function() {
+    this.itemsSelected_ = this.count > 0;
+  },
+  setSearchTerm: function(search) {
+    if (this.searchTerm == search) return;
+    this.searchTerm = search;
+    var searchField = this.$['main-toolbar'].getSearchField();
+    searchField.showAndFocus();
+    searchField.setValue(search);
+  },
+  onSearchChanged_: function(event) {
+    this.searchTerm = event.detail;
+  },
+  onClearSelectionTap_: function() {
+    this.fire('unselect-all');
+  },
+  onDeleteTap_: function() {
+    this.fire('delete-selected');
+  },
+  get searchBar() {
+    return this.$['main-toolbar'].getSearchField();
+  },
+  showSearchField: function() {
+    this.$['main-toolbar'].getSearchField().showAndFocus();
+  },
+  deletingAllowed_: function() {
+    return loadTimeData.getBoolean('allowDeletingHistory');
+  },
+  numberOfItemsSelected_: function(count) {
+    return count > 0 ? loadTimeData.getStringF('itemsSelected', count) : '';
+  },
+  getHistoryInterval_: function(queryStartTime, queryEndTime) {
+    return loadTimeData.getStringF('historyInterval', queryStartTime, queryEndTime);
+  },
+  hasDrawerChanged_: function() {
+    this.updateStyles();
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-dialog',
+  "extends": 'dialog',
+  cancel: function() {
+    this.fire('cancel');
+    HTMLDialogElement.prototype.close.call(this, '');
+  },
+  close: function(opt_returnValue) {
+    HTMLDialogElement.prototype.close.call(this, 'success');
+  },
+  getCloseButton: function() {
+    return this.$.close;
+  }
+});
+
+Polymer.IronFitBehavior = {
+  properties: {
+    sizingTarget: {
+      type: Object,
+      value: function() {
+        return this;
+      }
+    },
+    fitInto: {
+      type: Object,
+      value: window
+    },
+    noOverlap: {
+      type: Boolean
+    },
+    positionTarget: {
+      type: Element
+    },
+    horizontalAlign: {
+      type: String
+    },
+    verticalAlign: {
+      type: String
+    },
+    dynamicAlign: {
+      type: Boolean
+    },
+    horizontalOffset: {
+      type: Number,
+      value: 0,
+      notify: true
+    },
+    verticalOffset: {
+      type: Number,
+      value: 0,
+      notify: true
+    },
+    autoFitOnAttach: {
+      type: Boolean,
+      value: false
+    },
+    _fitInfo: {
+      type: Object
+    }
+  },
+  get _fitWidth() {
+    var fitWidth;
+    if (this.fitInto === window) {
+      fitWidth = this.fitInto.innerWidth;
+    } else {
+      fitWidth = this.fitInto.getBoundingClientRect().width;
+    }
+    return fitWidth;
+  },
+  get _fitHeight() {
+    var fitHeight;
+    if (this.fitInto === window) {
+      fitHeight = this.fitInto.innerHeight;
+    } else {
+      fitHeight = this.fitInto.getBoundingClientRect().height;
+    }
+    return fitHeight;
+  },
+  get _fitLeft() {
+    var fitLeft;
+    if (this.fitInto === window) {
+      fitLeft = 0;
+    } else {
+      fitLeft = this.fitInto.getBoundingClientRect().left;
+    }
+    return fitLeft;
+  },
+  get _fitTop() {
+    var fitTop;
+    if (this.fitInto === window) {
+      fitTop = 0;
+    } else {
+      fitTop = this.fitInto.getBoundingClientRect().top;
+    }
+    return fitTop;
+  },
+  get _defaultPositionTarget() {
+    var parent = Polymer.dom(this).parentNode;
+    if (parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      parent = parent.host;
+    }
+    return parent;
+  },
+  get _localeHorizontalAlign() {
+    if (this._isRTL) {
+      if (this.horizontalAlign === 'right') {
+        return 'left';
+      }
+      if (this.horizontalAlign === 'left') {
+        return 'right';
+      }
+    }
+    return this.horizontalAlign;
+  },
+  attached: function() {
+    this._isRTL = window.getComputedStyle(this).direction == 'rtl';
+    this.positionTarget = this.positionTarget || this._defaultPositionTarget;
+    if (this.autoFitOnAttach) {
+      if (window.getComputedStyle(this).display === 'none') {
+        setTimeout(function() {
+          this.fit();
+        }.bind(this));
+      } else {
+        this.fit();
+      }
+    }
+  },
+  fit: function() {
+    this.position();
+    this.constrain();
+    this.center();
+  },
+  _discoverInfo: function() {
+    if (this._fitInfo) {
+      return;
+    }
+    var target = window.getComputedStyle(this);
+    var sizer = window.getComputedStyle(this.sizingTarget);
+    this._fitInfo = {
+      inlineStyle: {
+        top: this.style.top || '',
+        left: this.style.left || '',
+        position: this.style.position || ''
+      },
+      sizerInlineStyle: {
+        maxWidth: this.sizingTarget.style.maxWidth || '',
+        maxHeight: this.sizingTarget.style.maxHeight || '',
+        boxSizing: this.sizingTarget.style.boxSizing || ''
+      },
+      positionedBy: {
+        vertically: target.top !== 'auto' ? 'top' : target.bottom !== 'auto' ? 'bottom' : null,
+        horizontally: target.left !== 'auto' ? 'left' : target.right !== 'auto' ? 'right' : null
+      },
+      sizedBy: {
+        height: sizer.maxHeight !== 'none',
+        width: sizer.maxWidth !== 'none',
+        minWidth: parseInt(sizer.minWidth, 10) || 0,
+        minHeight: parseInt(sizer.minHeight, 10) || 0
+      },
+      margin: {
+        top: parseInt(target.marginTop, 10) || 0,
+        right: parseInt(target.marginRight, 10) || 0,
+        bottom: parseInt(target.marginBottom, 10) || 0,
+        left: parseInt(target.marginLeft, 10) || 0
+      }
+    };
+    if (this.verticalOffset) {
+      this._fitInfo.margin.top = this._fitInfo.margin.bottom = this.verticalOffset;
+      this._fitInfo.inlineStyle.marginTop = this.style.marginTop || '';
+      this._fitInfo.inlineStyle.marginBottom = this.style.marginBottom || '';
+      this.style.marginTop = this.style.marginBottom = this.verticalOffset + 'px';
+    }
+    if (this.horizontalOffset) {
+      this._fitInfo.margin.left = this._fitInfo.margin.right = this.horizontalOffset;
+      this._fitInfo.inlineStyle.marginLeft = this.style.marginLeft || '';
+      this._fitInfo.inlineStyle.marginRight = this.style.marginRight || '';
+      this.style.marginLeft = this.style.marginRight = this.horizontalOffset + 'px';
+    }
+  },
+  resetFit: function() {
+    var info = this._fitInfo || {};
+    for (var property in info.sizerInlineStyle) {
+      this.sizingTarget.style[property] = info.sizerInlineStyle[property];
+    }
+    for (var property in info.inlineStyle) {
+      this.style[property] = info.inlineStyle[property];
+    }
+    this._fitInfo = null;
+  },
+  refit: function() {
+    var scrollLeft = this.sizingTarget.scrollLeft;
+    var scrollTop = this.sizingTarget.scrollTop;
+    this.resetFit();
+    this.fit();
+    this.sizingTarget.scrollLeft = scrollLeft;
+    this.sizingTarget.scrollTop = scrollTop;
+  },
+  position: function() {
+    if (!this.horizontalAlign && !this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    this.style.position = 'fixed';
+    this.sizingTarget.style.boxSizing = 'border-box';
+    this.style.left = '0px';
+    this.style.top = '0px';
+    var rect = this.getBoundingClientRect();
+    var positionRect = this.__getNormalizedRect(this.positionTarget);
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    var margin = this._fitInfo.margin;
+    var size = {
+      width: rect.width + margin.left + margin.right,
+      height: rect.height + margin.top + margin.bottom
+    };
+    var position = this.__getPosition(this._localeHorizontalAlign, this.verticalAlign, size, positionRect, fitRect);
+    var left = position.left + margin.left;
+    var top = position.top + margin.top;
+    var right = Math.min(fitRect.right - margin.right, left + rect.width);
+    var bottom = Math.min(fitRect.bottom - margin.bottom, top + rect.height);
+    var minWidth = this._fitInfo.sizedBy.minWidth;
+    var minHeight = this._fitInfo.sizedBy.minHeight;
+    if (left < margin.left) {
+      left = margin.left;
+      if (right - left < minWidth) {
+        left = right - minWidth;
+      }
+    }
+    if (top < margin.top) {
+      top = margin.top;
+      if (bottom - top < minHeight) {
+        top = bottom - minHeight;
+      }
+    }
+    this.sizingTarget.style.maxWidth = right - left + 'px';
+    this.sizingTarget.style.maxHeight = bottom - top + 'px';
+    this.style.left = left - rect.left + 'px';
+    this.style.top = top - rect.top + 'px';
+  },
+  constrain: function() {
+    if (this.horizontalAlign || this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    var info = this._fitInfo;
+    if (!info.positionedBy.vertically) {
+      this.style.position = 'fixed';
+      this.style.top = '0px';
+    }
+    if (!info.positionedBy.horizontally) {
+      this.style.position = 'fixed';
+      this.style.left = '0px';
+    }
+    this.sizingTarget.style.boxSizing = 'border-box';
+    var rect = this.getBoundingClientRect();
+    if (!info.sizedBy.height) {
+      this.__sizeDimension(rect, info.positionedBy.vertically, 'top', 'bottom', 'Height');
+    }
+    if (!info.sizedBy.width) {
+      this.__sizeDimension(rect, info.positionedBy.horizontally, 'left', 'right', 'Width');
+    }
+  },
+  _sizeDimension: function(rect, positionedBy, start, end, extent) {
+    this.__sizeDimension(rect, positionedBy, start, end, extent);
+  },
+  __sizeDimension: function(rect, positionedBy, start, end, extent) {
+    var info = this._fitInfo;
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    var max = extent === 'Width' ? fitRect.width : fitRect.height;
+    var flip = positionedBy === end;
+    var offset = flip ? max - rect[end] : rect[start];
+    var margin = info.margin[flip ? start : end];
+    var offsetExtent = 'offset' + extent;
+    var sizingOffset = this[offsetExtent] - this.sizingTarget[offsetExtent];
+    this.sizingTarget.style['max' + extent] = max - margin - offset - sizingOffset + 'px';
+  },
+  center: function() {
+    if (this.horizontalAlign || this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    var positionedBy = this._fitInfo.positionedBy;
+    if (positionedBy.vertically && positionedBy.horizontally) {
+      return;
+    }
+    this.style.position = 'fixed';
+    if (!positionedBy.vertically) {
+      this.style.top = '0px';
+    }
+    if (!positionedBy.horizontally) {
+      this.style.left = '0px';
+    }
+    var rect = this.getBoundingClientRect();
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    if (!positionedBy.vertically) {
+      var top = fitRect.top - rect.top + (fitRect.height - rect.height) / 2;
+      this.style.top = top + 'px';
+    }
+    if (!positionedBy.horizontally) {
+      var left = fitRect.left - rect.left + (fitRect.width - rect.width) / 2;
+      this.style.left = left + 'px';
+    }
+  },
+  __getNormalizedRect: function(target) {
+    if (target === document.documentElement || target === window) {
+      return {
+        top: 0,
+        left: 0,
+        width: window.innerWidth,
+        height: window.innerHeight,
+        right: window.innerWidth,
+        bottom: window.innerHeight
+      };
+    }
+    return target.getBoundingClientRect();
+  },
+  __getCroppedArea: function(position, size, fitRect) {
+    var verticalCrop = Math.min(0, position.top) + Math.min(0, fitRect.bottom - (position.top + size.height));
+    var horizontalCrop = Math.min(0, position.left) + Math.min(0, fitRect.right - (position.left + size.width));
+    return Math.abs(verticalCrop) * size.width + Math.abs(horizontalCrop) * size.height;
+  },
+  __getPosition: function(hAlign, vAlign, size, positionRect, fitRect) {
+    var positions = [ {
+      verticalAlign: 'top',
+      horizontalAlign: 'left',
+      top: positionRect.top,
+      left: positionRect.left
+    }, {
+      verticalAlign: 'top',
+      horizontalAlign: 'right',
+      top: positionRect.top,
+      left: positionRect.right - size.width
+    }, {
+      verticalAlign: 'bottom',
+      horizontalAlign: 'left',
+      top: positionRect.bottom - size.height,
+      left: positionRect.left
+    }, {
+      verticalAlign: 'bottom',
+      horizontalAlign: 'right',
+      top: positionRect.bottom - size.height,
+      left: positionRect.right - size.width
+    } ];
+    if (this.noOverlap) {
+      for (var i = 0, l = positions.length; i < l; i++) {
+        var copy = {};
+        for (var key in positions[i]) {
+          copy[key] = positions[i][key];
+        }
+        positions.push(copy);
+      }
+      positions[0].top = positions[1].top += positionRect.height;
+      positions[2].top = positions[3].top -= positionRect.height;
+      positions[4].left = positions[6].left += positionRect.width;
+      positions[5].left = positions[7].left -= positionRect.width;
+    }
+    vAlign = vAlign === 'auto' ? null : vAlign;
+    hAlign = hAlign === 'auto' ? null : hAlign;
+    var position;
+    for (var i = 0; i < positions.length; i++) {
+      var pos = positions[i];
+      if (!this.dynamicAlign && !this.noOverlap && pos.verticalAlign === vAlign && pos.horizontalAlign === hAlign) {
+        position = pos;
+        break;
+      }
+      var alignOk = (!vAlign || pos.verticalAlign === vAlign) && (!hAlign || pos.horizontalAlign === hAlign);
+      if (!this.dynamicAlign && !alignOk) {
+        continue;
+      }
+      position = position || pos;
+      pos.croppedArea = this.__getCroppedArea(pos, size, fitRect);
+      var diff = pos.croppedArea - position.croppedArea;
+      if (diff < 0 || diff === 0 && alignOk) {
+        position = pos;
+      }
+      if (position.croppedArea === 0 && alignOk) {
+        break;
+      }
+    }
+    return position;
+  }
+};
+
+(function() {
+  'use strict';
+  Polymer({
+    is: 'iron-overlay-backdrop',
+    properties: {
+      opened: {
+        reflectToAttribute: true,
+        type: Boolean,
+        value: false,
+        observer: '_openedChanged'
+      }
+    },
+    listeners: {
+      transitionend: '_onTransitionend'
+    },
+    created: function() {
+      this.__openedRaf = null;
+    },
+    attached: function() {
+      this.opened && this._openedChanged(this.opened);
+    },
+    prepare: function() {
+      if (this.opened && !this.parentNode) {
+        Polymer.dom(document.body).appendChild(this);
+      }
+    },
+    open: function() {
+      this.opened = true;
+    },
+    close: function() {
+      this.opened = false;
+    },
+    complete: function() {
+      if (!this.opened && this.parentNode === document.body) {
+        Polymer.dom(this.parentNode).removeChild(this);
+      }
+    },
+    _onTransitionend: function(event) {
+      if (event && event.target === this) {
+        this.complete();
+      }
+    },
+    _openedChanged: function(opened) {
+      if (opened) {
+        this.prepare();
+      } else {
+        var cs = window.getComputedStyle(this);
+        if (cs.transitionDuration === '0s' || cs.opacity == 0) {
+          this.complete();
+        }
+      }
+      if (!this.isAttached) {
+        return;
+      }
+      if (this.__openedRaf) {
+        window.cancelAnimationFrame(this.__openedRaf);
+        this.__openedRaf = null;
+      }
+      this.scrollTop = this.scrollTop;
+      this.__openedRaf = window.requestAnimationFrame(function() {
+        this.__openedRaf = null;
+        this.toggleClass('opened', this.opened);
+      }.bind(this));
+    }
+  });
+})();
+
+Polymer.IronOverlayManagerClass = function() {
+  this._overlays = [];
+  this._minimumZ = 101;
+  this._backdropElement = null;
+  Polymer.Gestures.add(document, 'tap', this._onCaptureClick.bind(this));
+  document.addEventListener('focus', this._onCaptureFocus.bind(this), true);
+  document.addEventListener('keydown', this._onCaptureKeyDown.bind(this), true);
+};
+
+Polymer.IronOverlayManagerClass.prototype = {
+  constructor: Polymer.IronOverlayManagerClass,
+  get backdropElement() {
+    if (!this._backdropElement) {
+      this._backdropElement = document.createElement('iron-overlay-backdrop');
+    }
+    return this._backdropElement;
+  },
+  get deepActiveElement() {
+    var active = document.activeElement || document.body;
+    while (active.root && Polymer.dom(active.root).activeElement) {
+      active = Polymer.dom(active.root).activeElement;
+    }
+    return active;
+  },
+  _bringOverlayAtIndexToFront: function(i) {
+    var overlay = this._overlays[i];
+    if (!overlay) {
+      return;
+    }
+    var lastI = this._overlays.length - 1;
+    var currentOverlay = this._overlays[lastI];
+    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
+      lastI--;
+    }
+    if (i >= lastI) {
+      return;
+    }
+    var minimumZ = Math.max(this.currentOverlayZ(), this._minimumZ);
+    if (this._getZ(overlay) <= minimumZ) {
+      this._applyOverlayZ(overlay, minimumZ);
+    }
+    while (i < lastI) {
+      this._overlays[i] = this._overlays[i + 1];
+      i++;
+    }
+    this._overlays[lastI] = overlay;
+  },
+  addOrRemoveOverlay: function(overlay) {
+    if (overlay.opened) {
+      this.addOverlay(overlay);
+    } else {
+      this.removeOverlay(overlay);
+    }
+  },
+  addOverlay: function(overlay) {
+    var i = this._overlays.indexOf(overlay);
+    if (i >= 0) {
+      this._bringOverlayAtIndexToFront(i);
+      this.trackBackdrop();
+      return;
+    }
+    var insertionIndex = this._overlays.length;
+    var currentOverlay = this._overlays[insertionIndex - 1];
+    var minimumZ = Math.max(this._getZ(currentOverlay), this._minimumZ);
+    var newZ = this._getZ(overlay);
+    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
+      this._applyOverlayZ(currentOverlay, minimumZ);
+      insertionIndex--;
+      var previousOverlay = this._overlays[insertionIndex - 1];
+      minimumZ = Math.max(this._getZ(previousOverlay), this._minimumZ);
+    }
+    if (newZ <= minimumZ) {
+      this._applyOverlayZ(overlay, minimumZ);
+    }
+    this._overlays.splice(insertionIndex, 0, overlay);
+    this.trackBackdrop();
+  },
+  removeOverlay: function(overlay) {
+    var i = this._overlays.indexOf(overlay);
+    if (i === -1) {
+      return;
+    }
+    this._overlays.splice(i, 1);
+    this.trackBackdrop();
+  },
+  currentOverlay: function() {
+    var i = this._overlays.length - 1;
+    return this._overlays[i];
+  },
+  currentOverlayZ: function() {
+    return this._getZ(this.currentOverlay());
+  },
+  ensureMinimumZ: function(minimumZ) {
+    this._minimumZ = Math.max(this._minimumZ, minimumZ);
+  },
+  focusOverlay: function() {
+    var current = this.currentOverlay();
+    if (current) {
+      current._applyFocus();
+    }
+  },
+  trackBackdrop: function() {
+    var overlay = this._overlayWithBackdrop();
+    if (!overlay && !this._backdropElement) {
+      return;
+    }
+    this.backdropElement.style.zIndex = this._getZ(overlay) - 1;
+    this.backdropElement.opened = !!overlay;
+  },
+  getBackdrops: function() {
+    var backdrops = [];
+    for (var i = 0; i < this._overlays.length; i++) {
+      if (this._overlays[i].withBackdrop) {
+        backdrops.push(this._overlays[i]);
+      }
+    }
+    return backdrops;
+  },
+  backdropZ: function() {
+    return this._getZ(this._overlayWithBackdrop()) - 1;
+  },
+  _overlayWithBackdrop: function() {
+    for (var i = 0; i < this._overlays.length; i++) {
+      if (this._overlays[i].withBackdrop) {
+        return this._overlays[i];
+      }
+    }
+  },
+  _getZ: function(overlay) {
+    var z = this._minimumZ;
+    if (overlay) {
+      var z1 = Number(overlay.style.zIndex || window.getComputedStyle(overlay).zIndex);
+      if (z1 === z1) {
+        z = z1;
+      }
+    }
+    return z;
+  },
+  _setZ: function(element, z) {
+    element.style.zIndex = z;
+  },
+  _applyOverlayZ: function(overlay, aboveZ) {
+    this._setZ(overlay, aboveZ + 2);
+  },
+  _overlayInPath: function(path) {
+    path = path || [];
+    for (var i = 0; i < path.length; i++) {
+      if (path[i]._manager === this) {
+        return path[i];
+      }
+    }
+  },
+  _onCaptureClick: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay && this._overlayInPath(Polymer.dom(event).path) !== overlay) {
+      overlay._onCaptureClick(event);
+    }
+  },
+  _onCaptureFocus: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay) {
+      overlay._onCaptureFocus(event);
+    }
+  },
+  _onCaptureKeyDown: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay) {
+      if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'esc')) {
+        overlay._onCaptureEsc(event);
+      } else if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'tab')) {
+        overlay._onCaptureTab(event);
+      }
+    }
+  },
+  _shouldBeBehindOverlay: function(overlay1, overlay2) {
+    return !overlay1.alwaysOnTop && overlay2.alwaysOnTop;
+  }
+};
+
+Polymer.IronOverlayManager = new Polymer.IronOverlayManagerClass();
+
+(function() {
+  'use strict';
+  Polymer.IronOverlayBehaviorImpl = {
+    properties: {
+      opened: {
+        observer: '_openedChanged',
+        type: Boolean,
+        value: false,
+        notify: true
+      },
+      canceled: {
+        observer: '_canceledChanged',
+        readOnly: true,
+        type: Boolean,
+        value: false
+      },
+      withBackdrop: {
+        observer: '_withBackdropChanged',
+        type: Boolean
+      },
+      noAutoFocus: {
+        type: Boolean,
+        value: false
+      },
+      noCancelOnEscKey: {
+        type: Boolean,
+        value: false
+      },
+      noCancelOnOutsideClick: {
+        type: Boolean,
+        value: false
+      },
+      closingReason: {
+        type: Object
+      },
+      restoreFocusOnClose: {
+        type: Boolean,
+        value: false
+      },
+      alwaysOnTop: {
+        type: Boolean
+      },
+      _manager: {
+        type: Object,
+        value: Polymer.IronOverlayManager
+      },
+      _focusedChild: {
+        type: Object
+      }
+    },
+    listeners: {
+      'iron-resize': '_onIronResize'
+    },
+    get backdropElement() {
+      return this._manager.backdropElement;
+    },
+    get _focusNode() {
+      return this._focusedChild || Polymer.dom(this).querySelector('[autofocus]') || this;
+    },
+    get _focusableNodes() {
+      var FOCUSABLE_WITH_DISABLED = [ 'a[href]', 'area[href]', 'iframe', '[tabindex]', '[contentEditable=true]' ];
+      var FOCUSABLE_WITHOUT_DISABLED = [ 'input', 'select', 'textarea', 'button' ];
+      var selector = FOCUSABLE_WITH_DISABLED.join(':not([tabindex="-1"]),') + ':not([tabindex="-1"]),' + FOCUSABLE_WITHOUT_DISABLED.join(':not([disabled]):not([tabindex="-1"]),') + ':not([disabled]):not([tabindex="-1"])';
+      var focusables = Polymer.dom(this).querySelectorAll(selector);
+      if (this.tabIndex >= 0) {
+        focusables.splice(0, 0, this);
+      }
+      return focusables.sort(function(a, b) {
+        if (a.tabIndex === b.tabIndex) {
+          return 0;
+        }
+        if (a.tabIndex === 0 || a.tabIndex > b.tabIndex) {
+          return 1;
+        }
+        return -1;
+      });
+    },
+    ready: function() {
+      this.__isAnimating = false;
+      this.__shouldRemoveTabIndex = false;
+      this.__firstFocusableNode = this.__lastFocusableNode = null;
+      this.__raf = null;
+      this.__restoreFocusNode = null;
+      this._ensureSetup();
+    },
+    attached: function() {
+      if (this.opened) {
+        this._openedChanged(this.opened);
+      }
+      this._observer = Polymer.dom(this).observeNodes(this._onNodesChange);
+    },
+    detached: function() {
+      Polymer.dom(this).unobserveNodes(this._observer);
+      this._observer = null;
+      if (this.__raf) {
+        window.cancelAnimationFrame(this.__raf);
+        this.__raf = null;
+      }
+      this._manager.removeOverlay(this);
+    },
+    toggle: function() {
+      this._setCanceled(false);
+      this.opened = !this.opened;
+    },
+    open: function() {
+      this._setCanceled(false);
+      this.opened = true;
+    },
+    close: function() {
+      this._setCanceled(false);
+      this.opened = false;
+    },
+    cancel: function(event) {
+      var cancelEvent = this.fire('iron-overlay-canceled', event, {
+        cancelable: true
+      });
+      if (cancelEvent.defaultPrevented) {
+        return;
+      }
+      this._setCanceled(true);
+      this.opened = false;
+    },
+    _ensureSetup: function() {
+      if (this._overlaySetup) {
+        return;
+      }
+      this._overlaySetup = true;
+      this.style.outline = 'none';
+      this.style.display = 'none';
+    },
+    _openedChanged: function(opened) {
+      if (opened) {
+        this.removeAttribute('aria-hidden');
+      } else {
+        this.setAttribute('aria-hidden', 'true');
+      }
+      if (!this.isAttached) {
+        return;
+      }
+      this.__isAnimating = true;
+      this.__onNextAnimationFrame(this.__openedChanged);
+    },
+    _canceledChanged: function() {
+      this.closingReason = this.closingReason || {};
+      this.closingReason.canceled = this.canceled;
+    },
+    _withBackdropChanged: function() {
+      if (this.withBackdrop && !this.hasAttribute('tabindex')) {
+        this.setAttribute('tabindex', '-1');
+        this.__shouldRemoveTabIndex = true;
+      } else if (this.__shouldRemoveTabIndex) {
+        this.removeAttribute('tabindex');
+        this.__shouldRemoveTabIndex = false;
+      }
+      if (this.opened && this.isAttached) {
+        this._manager.trackBackdrop();
+      }
+    },
+    _prepareRenderOpened: function() {
+      this.__restoreFocusNode = this._manager.deepActiveElement;
+      this._preparePositioning();
+      this.refit();
+      this._finishPositioning();
+      if (this.noAutoFocus && document.activeElement === this._focusNode) {
+        this._focusNode.blur();
+        this.__restoreFocusNode.focus();
+      }
+    },
+    _renderOpened: function() {
+      this._finishRenderOpened();
+    },
+    _renderClosed: function() {
+      this._finishRenderClosed();
+    },
+    _finishRenderOpened: function() {
+      this.notifyResize();
+      this.__isAnimating = false;
+      var focusableNodes = this._focusableNodes;
+      this.__firstFocusableNode = focusableNodes[0];
+      this.__lastFocusableNode = focusableNodes[focusableNodes.length - 1];
+      this.fire('iron-overlay-opened');
+    },
+    _finishRenderClosed: function() {
+      this.style.display = 'none';
+      this.style.zIndex = '';
+      this.notifyResize();
+      this.__isAnimating = false;
+      this.fire('iron-overlay-closed', this.closingReason);
+    },
+    _preparePositioning: function() {
+      this.style.transition = this.style.webkitTransition = 'none';
+      this.style.transform = this.style.webkitTransform = 'none';
+      this.style.display = '';
+    },
+    _finishPositioning: function() {
+      this.style.display = 'none';
+      this.scrollTop = this.scrollTop;
+      this.style.transition = this.style.webkitTransition = '';
+      this.style.transform = this.style.webkitTransform = '';
+      this.style.display = '';
+      this.scrollTop = this.scrollTop;
+    },
+    _applyFocus: function() {
+      if (this.opened) {
+        if (!this.noAutoFocus) {
+          this._focusNode.focus();
+        }
+      } else {
+        this._focusNode.blur();
+        this._focusedChild = null;
+        if (this.restoreFocusOnClose && this.__restoreFocusNode) {
+          this.__restoreFocusNode.focus();
+        }
+        this.__restoreFocusNode = null;
+        var currentOverlay = this._manager.currentOverlay();
+        if (currentOverlay && this !== currentOverlay) {
+          currentOverlay._applyFocus();
+        }
+      }
+    },
+    _onCaptureClick: function(event) {
+      if (!this.noCancelOnOutsideClick) {
+        this.cancel(event);
+      }
+    },
+    _onCaptureFocus: function(event) {
+      if (!this.withBackdrop) {
+        return;
+      }
+      var path = Polymer.dom(event).path;
+      if (path.indexOf(this) === -1) {
+        event.stopPropagation();
+        this._applyFocus();
+      } else {
+        this._focusedChild = path[0];
+      }
+    },
+    _onCaptureEsc: function(event) {
+      if (!this.noCancelOnEscKey) {
+        this.cancel(event);
+      }
+    },
+    _onCaptureTab: function(event) {
+      if (!this.withBackdrop) {
+        return;
+      }
+      var shift = event.shiftKey;
+      var nodeToCheck = shift ? this.__firstFocusableNode : this.__lastFocusableNode;
+      var nodeToSet = shift ? this.__lastFocusableNode : this.__firstFocusableNode;
+      var shouldWrap = false;
+      if (nodeToCheck === nodeToSet) {
+        shouldWrap = true;
+      } else {
+        var focusedNode = this._manager.deepActiveElement;
+        shouldWrap = focusedNode === nodeToCheck || focusedNode === this;
+      }
+      if (shouldWrap) {
+        event.preventDefault();
+        this._focusedChild = nodeToSet;
+        this._applyFocus();
+      }
+    },
+    _onIronResize: function() {
+      if (this.opened && !this.__isAnimating) {
+        this.__onNextAnimationFrame(this.refit);
+      }
+    },
+    _onNodesChange: function() {
+      if (this.opened && !this.__isAnimating) {
+        this.notifyResize();
+      }
+    },
+    __openedChanged: function() {
+      if (this.opened) {
+        this._prepareRenderOpened();
+        this._manager.addOverlay(this);
+        this._applyFocus();
+        this._renderOpened();
+      } else {
+        this._manager.removeOverlay(this);
+        this._applyFocus();
+        this._renderClosed();
+      }
+    },
+    __onNextAnimationFrame: function(callback) {
+      if (this.__raf) {
+        window.cancelAnimationFrame(this.__raf);
+      }
+      var self = this;
+      this.__raf = window.requestAnimationFrame(function nextAnimationFrame() {
+        self.__raf = null;
+        callback.call(self);
+      });
+    }
+  };
+  Polymer.IronOverlayBehavior = [ Polymer.IronFitBehavior, Polymer.IronResizableBehavior, Polymer.IronOverlayBehaviorImpl ];
+})();
+
+Polymer.NeonAnimatableBehavior = {
+  properties: {
+    animationConfig: {
+      type: Object
+    },
+    entryAnimation: {
+      observer: '_entryAnimationChanged',
+      type: String
+    },
+    exitAnimation: {
+      observer: '_exitAnimationChanged',
+      type: String
+    }
+  },
+  _entryAnimationChanged: function() {
+    this.animationConfig = this.animationConfig || {};
+    this.animationConfig['entry'] = [ {
+      name: this.entryAnimation,
+      node: this
+    } ];
+  },
+  _exitAnimationChanged: function() {
+    this.animationConfig = this.animationConfig || {};
+    this.animationConfig['exit'] = [ {
+      name: this.exitAnimation,
+      node: this
+    } ];
+  },
+  _copyProperties: function(config1, config2) {
+    for (var property in config2) {
+      config1[property] = config2[property];
+    }
+  },
+  _cloneConfig: function(config) {
+    var clone = {
+      isClone: true
+    };
+    this._copyProperties(clone, config);
+    return clone;
+  },
+  _getAnimationConfigRecursive: function(type, map, allConfigs) {
+    if (!this.animationConfig) {
+      return;
+    }
+    if (this.animationConfig.value && typeof this.animationConfig.value === 'function') {
+      this._warn(this._logf('playAnimation', "Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));
+      return;
+    }
+    var thisConfig;
+    if (type) {
+      thisConfig = this.animationConfig[type];
+    } else {
+      thisConfig = this.animationConfig;
+    }
+    if (!Array.isArray(thisConfig)) {
+      thisConfig = [ thisConfig ];
+    }
+    if (thisConfig) {
+      for (var config, index = 0; config = thisConfig[index]; index++) {
+        if (config.animatable) {
+          config.animatable._getAnimationConfigRecursive(config.type || type, map, allConfigs);
+        } else {
+          if (config.id) {
+            var cachedConfig = map[config.id];
+            if (cachedConfig) {
+              if (!cachedConfig.isClone) {
+                map[config.id] = this._cloneConfig(cachedConfig);
+                cachedConfig = map[config.id];
+              }
+              this._copyProperties(cachedConfig, config);
+            } else {
+              map[config.id] = config;
+            }
+          } else {
+            allConfigs.push(config);
+          }
+        }
+      }
+    }
+  },
+  getAnimationConfig: function(type) {
+    var map = {};
+    var allConfigs = [];
+    this._getAnimationConfigRecursive(type, map, allConfigs);
+    for (var key in map) {
+      allConfigs.push(map[key]);
+    }
+    return allConfigs;
+  }
+};
+
+Polymer.NeonAnimationRunnerBehaviorImpl = {
+  _configureAnimations: function(configs) {
+    var results = [];
+    if (configs.length > 0) {
+      for (var config, index = 0; config = configs[index]; index++) {
+        var neonAnimation = document.createElement(config.name);
+        if (neonAnimation.isNeonAnimation) {
+          var result = null;
+          try {
+            result = neonAnimation.configure(config);
+            if (typeof result.cancel != 'function') {
+              result = document.timeline.play(result);
+            }
+          } catch (e) {
+            result = null;
+            console.warn('Couldnt play', '(', config.name, ').', e);
+          }
+          if (result) {
+            results.push({
+              neonAnimation: neonAnimation,
+              config: config,
+              animation: result
+            });
+          }
+        } else {
+          console.warn(this.is + ':', config.name, 'not found!');
+        }
+      }
+    }
+    return results;
+  },
+  _shouldComplete: function(activeEntries) {
+    var finished = true;
+    for (var i = 0; i < activeEntries.length; i++) {
+      if (activeEntries[i].animation.playState != 'finished') {
+        finished = false;
+        break;
+      }
+    }
+    return finished;
+  },
+  _complete: function(activeEntries) {
+    for (var i = 0; i < activeEntries.length; i++) {
+      activeEntries[i].neonAnimation.complete(activeEntries[i].config);
+    }
+    for (var i = 0; i < activeEntries.length; i++) {
+      activeEntries[i].animation.cancel();
+    }
+  },
+  playAnimation: function(type, cookie) {
+    var configs = this.getAnimationConfig(type);
+    if (!configs) {
+      return;
+    }
+    this._active = this._active || {};
+    if (this._active[type]) {
+      this._complete(this._active[type]);
+      delete this._active[type];
+    }
+    var activeEntries = this._configureAnimations(configs);
+    if (activeEntries.length == 0) {
+      this.fire('neon-animation-finish', cookie, {
+        bubbles: false
+      });
+      return;
+    }
+    this._active[type] = activeEntries;
+    for (var i = 0; i < activeEntries.length; i++) {
+      activeEntries[i].animation.onfinish = function() {
+        if (this._shouldComplete(activeEntries)) {
+          this._complete(activeEntries);
+          delete this._active[type];
+          this.fire('neon-animation-finish', cookie, {
+            bubbles: false
+          });
+        }
+      }.bind(this);
+    }
+  },
+  cancelAnimation: function() {
+    for (var k in this._animations) {
+      this._animations[k].cancel();
+    }
+    this._animations = {};
+  }
+};
+
+Polymer.NeonAnimationRunnerBehavior = [ Polymer.NeonAnimatableBehavior, Polymer.NeonAnimationRunnerBehaviorImpl ];
+
+Polymer.NeonAnimationBehavior = {
+  properties: {
+    animationTiming: {
+      type: Object,
+      value: function() {
+        return {
+          duration: 500,
+          easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
+          fill: 'both'
+        };
+      }
+    }
+  },
+  isNeonAnimation: true,
+  timingFromConfig: function(config) {
+    if (config.timing) {
+      for (var property in config.timing) {
+        this.animationTiming[property] = config.timing[property];
+      }
+    }
+    return this.animationTiming;
+  },
+  setPrefixedProperty: function(node, property, value) {
+    var map = {
+      transform: [ 'webkitTransform' ],
+      transformOrigin: [ 'mozTransformOrigin', 'webkitTransformOrigin' ]
+    };
+    var prefixes = map[property];
+    for (var prefix, index = 0; prefix = prefixes[index]; index++) {
+      node.style[prefix] = value;
+    }
+    node.style[property] = value;
+  },
+  complete: function() {}
+};
+
+Polymer({
+  is: 'opaque-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    this._effect = new KeyframeEffect(node, [ {
+      opacity: '1'
+    }, {
+      opacity: '1'
+    } ], this.timingFromConfig(config));
+    node.style.opacity = '0';
+    return this._effect;
+  },
+  complete: function(config) {
+    config.node.style.opacity = '';
+  }
+});
+
+(function() {
+  'use strict';
+  var LAST_TOUCH_POSITION = {
+    pageX: 0,
+    pageY: 0
+  };
+  var ROOT_TARGET = null;
+  var SCROLLABLE_NODES = [];
+  Polymer.IronDropdownScrollManager = {
+    get currentLockingElement() {
+      return this._lockingElements[this._lockingElements.length - 1];
+    },
+    elementIsScrollLocked: function(element) {
+      var currentLockingElement = this.currentLockingElement;
+      if (currentLockingElement === undefined) return false;
+      var scrollLocked;
+      if (this._hasCachedLockedElement(element)) {
+        return true;
+      }
+      if (this._hasCachedUnlockedElement(element)) {
+        return false;
+      }
+      scrollLocked = !!currentLockingElement && currentLockingElement !== element && !this._composedTreeContains(currentLockingElement, element);
+      if (scrollLocked) {
+        this._lockedElementCache.push(element);
+      } else {
+        this._unlockedElementCache.push(element);
+      }
+      return scrollLocked;
+    },
+    pushScrollLock: function(element) {
+      if (this._lockingElements.indexOf(element) >= 0) {
+        return;
+      }
+      if (this._lockingElements.length === 0) {
+        this._lockScrollInteractions();
+      }
+      this._lockingElements.push(element);
+      this._lockedElementCache = [];
+      this._unlockedElementCache = [];
+    },
+    removeScrollLock: function(element) {
+      var index = this._lockingElements.indexOf(element);
+      if (index === -1) {
+        return;
+      }
+      this._lockingElements.splice(index, 1);
+      this._lockedElementCache = [];
+      this._unlockedElementCache = [];
+      if (this._lockingElements.length === 0) {
+        this._unlockScrollInteractions();
+      }
+    },
+    _lockingElements: [],
+    _lockedElementCache: null,
+    _unlockedElementCache: null,
+    _hasCachedLockedElement: function(element) {
+      return this._lockedElementCache.indexOf(element) > -1;
+    },
+    _hasCachedUnlockedElement: function(element) {
+      return this._unlockedElementCache.indexOf(element) > -1;
+    },
+    _composedTreeContains: function(element, child) {
+      var contentElements;
+      var distributedNodes;
+      var contentIndex;
+      var nodeIndex;
+      if (element.contains(child)) {
+        return true;
+      }
+      contentElements = Polymer.dom(element).querySelectorAll('content');
+      for (contentIndex = 0; contentIndex < contentElements.length; ++contentIndex) {
+        distributedNodes = Polymer.dom(contentElements[contentIndex]).getDistributedNodes();
+        for (nodeIndex = 0; nodeIndex < distributedNodes.length; ++nodeIndex) {
+          if (this._composedTreeContains(distributedNodes[nodeIndex], child)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    },
+    _scrollInteractionHandler: function(event) {
+      if (event.cancelable && this._shouldPreventScrolling(event)) {
+        event.preventDefault();
+      }
+      if (event.targetTouches) {
+        var touch = event.targetTouches[0];
+        LAST_TOUCH_POSITION.pageX = touch.pageX;
+        LAST_TOUCH_POSITION.pageY = touch.pageY;
+      }
+    },
+    _lockScrollInteractions: function() {
+      this._boundScrollHandler = this._boundScrollHandler || this._scrollInteractionHandler.bind(this);
+      document.addEventListener('wheel', this._boundScrollHandler, true);
+      document.addEventListener('mousewheel', this._boundScrollHandler, true);
+      document.addEventListener('DOMMouseScroll', this._boundScrollHandler, true);
+      document.addEventListener('touchstart', this._boundScrollHandler, true);
+      document.addEventListener('touchmove', this._boundScrollHandler, true);
+    },
+    _unlockScrollInteractions: function() {
+      document.removeEventListener('wheel', this._boundScrollHandler, true);
+      document.removeEventListener('mousewheel', this._boundScrollHandler, true);
+      document.removeEventListener('DOMMouseScroll', this._boundScrollHandler, true);
+      document.removeEventListener('touchstart', this._boundScrollHandler, true);
+      document.removeEventListener('touchmove', this._boundScrollHandler, true);
+    },
+    _shouldPreventScrolling: function(event) {
+      var target = Polymer.dom(event).rootTarget;
+      if (event.type !== 'touchmove' && ROOT_TARGET !== target) {
+        ROOT_TARGET = target;
+        SCROLLABLE_NODES = this._getScrollableNodes(Polymer.dom(event).path);
+      }
+      if (!SCROLLABLE_NODES.length) {
+        return true;
+      }
+      if (event.type === 'touchstart') {
+        return false;
+      }
+      var info = this._getScrollInfo(event);
+      return !this._getScrollingNode(SCROLLABLE_NODES, info.deltaX, info.deltaY);
+    },
+    _getScrollableNodes: function(nodes) {
+      var scrollables = [];
+      var lockingIndex = nodes.indexOf(this.currentLockingElement);
+      for (var i = 0; i <= lockingIndex; i++) {
+        var node = nodes[i];
+        if (node.nodeType === 11) {
+          continue;
+        }
+        var style = node.style;
+        if (style.overflow !== 'scroll' && style.overflow !== 'auto') {
+          style = window.getComputedStyle(node);
+        }
+        if (style.overflow === 'scroll' || style.overflow === 'auto') {
+          scrollables.push(node);
+        }
+      }
+      return scrollables;
+    },
+    _getScrollingNode: function(nodes, deltaX, deltaY) {
+      if (!deltaX && !deltaY) {
+        return;
+      }
+      var verticalScroll = Math.abs(deltaY) >= Math.abs(deltaX);
+      for (var i = 0; i < nodes.length; i++) {
+        var node = nodes[i];
+        var canScroll = false;
+        if (verticalScroll) {
+          canScroll = deltaY < 0 ? node.scrollTop > 0 : node.scrollTop < node.scrollHeight - node.clientHeight;
+        } else {
+          canScroll = deltaX < 0 ? node.scrollLeft > 0 : node.scrollLeft < node.scrollWidth - node.clientWidth;
+        }
+        if (canScroll) {
+          return node;
+        }
+      }
+    },
+    _getScrollInfo: function(event) {
+      var info = {
+        deltaX: event.deltaX,
+        deltaY: event.deltaY
+      };
+      if ('deltaX' in event) {} else if ('wheelDeltaX' in event) {
+        info.deltaX = -event.wheelDeltaX;
+        info.deltaY = -event.wheelDeltaY;
+      } else if ('axis' in event) {
+        info.deltaX = event.axis === 1 ? event.detail : 0;
+        info.deltaY = event.axis === 2 ? event.detail : 0;
+      } else if (event.targetTouches) {
+        var touch = event.targetTouches[0];
+        info.deltaX = LAST_TOUCH_POSITION.pageX - touch.pageX;
+        info.deltaY = LAST_TOUCH_POSITION.pageY - touch.pageY;
+      }
+      return info;
+    }
+  };
+})();
+
+(function() {
+  'use strict';
+  Polymer({
+    is: 'iron-dropdown',
+    behaviors: [ Polymer.IronControlState, Polymer.IronA11yKeysBehavior, Polymer.IronOverlayBehavior, Polymer.NeonAnimationRunnerBehavior ],
+    properties: {
+      horizontalAlign: {
+        type: String,
+        value: 'left',
+        reflectToAttribute: true
+      },
+      verticalAlign: {
+        type: String,
+        value: 'top',
+        reflectToAttribute: true
+      },
+      openAnimationConfig: {
+        type: Object
+      },
+      closeAnimationConfig: {
+        type: Object
+      },
+      focusTarget: {
+        type: Object
+      },
+      noAnimations: {
+        type: Boolean,
+        value: false
+      },
+      allowOutsideScroll: {
+        type: Boolean,
+        value: false
+      },
+      _boundOnCaptureScroll: {
+        type: Function,
+        value: function() {
+          return this._onCaptureScroll.bind(this);
+        }
+      }
+    },
+    listeners: {
+      'neon-animation-finish': '_onNeonAnimationFinish'
+    },
+    observers: [ '_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)' ],
+    get containedElement() {
+      return Polymer.dom(this.$.content).getDistributedNodes()[0];
+    },
+    get _focusTarget() {
+      return this.focusTarget || this.containedElement;
+    },
+    ready: function() {
+      this._scrollTop = 0;
+      this._scrollLeft = 0;
+      this._refitOnScrollRAF = null;
+    },
+    detached: function() {
+      this.cancelAnimation();
+      Polymer.IronDropdownScrollManager.removeScrollLock(this);
+    },
+    _openedChanged: function() {
+      if (this.opened && this.disabled) {
+        this.cancel();
+      } else {
+        this.cancelAnimation();
+        this.sizingTarget = this.containedElement || this.sizingTarget;
+        this._updateAnimationConfig();
+        this._saveScrollPosition();
+        if (this.opened) {
+          document.addEventListener('scroll', this._boundOnCaptureScroll);
+          !this.allowOutsideScroll && Polymer.IronDropdownScrollManager.pushScrollLock(this);
+        } else {
+          document.removeEventListener('scroll', this._boundOnCaptureScroll);
+          Polymer.IronDropdownScrollManager.removeScrollLock(this);
+        }
+        Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this, arguments);
+      }
+    },
+    _renderOpened: function() {
+      if (!this.noAnimations && this.animationConfig.open) {
+        this.$.contentWrapper.classList.add('animating');
+        this.playAnimation('open');
+      } else {
+        Polymer.IronOverlayBehaviorImpl._renderOpened.apply(this, arguments);
+      }
+    },
+    _renderClosed: function() {
+      if (!this.noAnimations && this.animationConfig.close) {
+        this.$.contentWrapper.classList.add('animating');
+        this.playAnimation('close');
+      } else {
+        Polymer.IronOverlayBehaviorImpl._renderClosed.apply(this, arguments);
+      }
+    },
+    _onNeonAnimationFinish: function() {
+      this.$.contentWrapper.classList.remove('animating');
+      if (this.opened) {
+        this._finishRenderOpened();
+      } else {
+        this._finishRenderClosed();
+      }
+    },
+    _onCaptureScroll: function() {
+      if (!this.allowOutsideScroll) {
+        this._restoreScrollPosition();
+      } else {
+        this._refitOnScrollRAF && window.cancelAnimationFrame(this._refitOnScrollRAF);
+        this._refitOnScrollRAF = window.requestAnimationFrame(this.refit.bind(this));
+      }
+    },
+    _saveScrollPosition: function() {
+      if (document.scrollingElement) {
+        this._scrollTop = document.scrollingElement.scrollTop;
+        this._scrollLeft = document.scrollingElement.scrollLeft;
+      } else {
+        this._scrollTop = Math.max(document.documentElement.scrollTop, document.body.scrollTop);
+        this._scrollLeft = Math.max(document.documentElement.scrollLeft, document.body.scrollLeft);
+      }
+    },
+    _restoreScrollPosition: function() {
+      if (document.scrollingElement) {
+        document.scrollingElement.scrollTop = this._scrollTop;
+        document.scrollingElement.scrollLeft = this._scrollLeft;
+      } else {
+        document.documentElement.scrollTop = this._scrollTop;
+        document.documentElement.scrollLeft = this._scrollLeft;
+        document.body.scrollTop = this._scrollTop;
+        document.body.scrollLeft = this._scrollLeft;
+      }
+    },
+    _updateAnimationConfig: function() {
+      var animations = (this.openAnimationConfig || []).concat(this.closeAnimationConfig || []);
+      for (var i = 0; i < animations.length; i++) {
+        animations[i].node = this.containedElement;
+      }
+      this.animationConfig = {
+        open: this.openAnimationConfig,
+        close: this.closeAnimationConfig
+      };
+    },
+    _updateOverlayPosition: function() {
+      if (this.isAttached) {
+        this.notifyResize();
+      }
+    },
+    _applyFocus: function() {
+      var focusTarget = this.focusTarget || this.containedElement;
+      if (focusTarget && this.opened && !this.noAutoFocus) {
+        focusTarget.focus();
+      } else {
+        Polymer.IronOverlayBehaviorImpl._applyFocus.apply(this, arguments);
+      }
+    }
+  });
+})();
+
+Polymer({
+  is: 'fade-in-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    this._effect = new KeyframeEffect(node, [ {
+      opacity: '0'
+    }, {
+      opacity: '1'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+Polymer({
+  is: 'fade-out-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    this._effect = new KeyframeEffect(node, [ {
+      opacity: '1'
+    }, {
+      opacity: '0'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+Polymer({
+  is: 'paper-menu-grow-height-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    var rect = node.getBoundingClientRect();
+    var height = rect.height;
+    this._effect = new KeyframeEffect(node, [ {
+      height: height / 2 + 'px'
+    }, {
+      height: height + 'px'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+Polymer({
+  is: 'paper-menu-grow-width-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    var rect = node.getBoundingClientRect();
+    var width = rect.width;
+    this._effect = new KeyframeEffect(node, [ {
+      width: width / 2 + 'px'
+    }, {
+      width: width + 'px'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+Polymer({
+  is: 'paper-menu-shrink-width-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    var rect = node.getBoundingClientRect();
+    var width = rect.width;
+    this._effect = new KeyframeEffect(node, [ {
+      width: width + 'px'
+    }, {
+      width: width - width / 20 + 'px'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+Polymer({
+  is: 'paper-menu-shrink-height-animation',
+  behaviors: [ Polymer.NeonAnimationBehavior ],
+  configure: function(config) {
+    var node = config.node;
+    var rect = node.getBoundingClientRect();
+    var height = rect.height;
+    var top = rect.top;
+    this.setPrefixedProperty(node, 'transformOrigin', '0 0');
+    this._effect = new KeyframeEffect(node, [ {
+      height: height + 'px',
+      transform: 'translateY(0)'
+    }, {
+      height: height / 2 + 'px',
+      transform: 'translateY(-20px)'
+    } ], this.timingFromConfig(config));
+    return this._effect;
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var SLIDE_CUBIC_BEZIER = 'cubic-bezier(0.3, 0.95, 0.5, 1)';
+
+Polymer({
+  is: 'cr-shared-menu',
+  behaviors: [ Polymer.IronA11yKeysBehavior ],
+  properties: {
+    menuOpen: {
+      type: Boolean,
+      observer: 'menuOpenChanged_',
+      value: false
+    },
+    itemData: {
+      type: Object,
+      value: null
+    },
+    keyEventTarget: {
+      type: Object,
+      value: function() {
+        return this.$.menu;
+      }
+    },
+    openAnimationConfig: {
+      type: Object,
+      value: function() {
+        return [ {
+          name: 'fade-in-animation',
+          timing: {
+            delay: 50,
+            duration: 200
+          }
+        }, {
+          name: 'paper-menu-grow-width-animation',
+          timing: {
+            delay: 50,
+            duration: 150,
+            easing: SLIDE_CUBIC_BEZIER
+          }
+        }, {
+          name: 'paper-menu-grow-height-animation',
+          timing: {
+            delay: 100,
+            duration: 275,
+            easing: SLIDE_CUBIC_BEZIER
+          }
+        } ];
+      }
+    },
+    closeAnimationConfig: {
+      type: Object,
+      value: function() {
+        return [ {
+          name: 'fade-out-animation',
+          timing: {
+            duration: 150
+          }
+        } ];
+      }
+    }
+  },
+  keyBindings: {
+    tab: 'onTabPressed_'
+  },
+  listeners: {
+    'dropdown.iron-overlay-canceled': 'onOverlayCanceled_'
+  },
+  lastAnchor_: null,
+  firstFocus_: null,
+  lastFocus_: null,
+  attached: function() {
+    window.addEventListener('resize', this.closeMenu.bind(this));
+  },
+  closeMenu: function() {
+    if (this.root.activeElement == null) {
+      this.$.dropdown.restoreFocusOnClose = false;
+    }
+    this.menuOpen = false;
+  },
+  openMenu: function(anchor, itemData) {
+    if (this.lastAnchor_ == anchor && this.menuOpen) return;
+    if (this.menuOpen) this.closeMenu();
+    this.itemData = itemData;
+    this.lastAnchor_ = anchor;
+    this.$.dropdown.restoreFocusOnClose = true;
+    var focusableChildren = Polymer.dom(this).querySelectorAll('[tabindex]:not([hidden]),button:not([hidden])');
+    if (focusableChildren.length > 0) {
+      this.$.dropdown.focusTarget = focusableChildren[0];
+      this.firstFocus_ = focusableChildren[0];
+      this.lastFocus_ = focusableChildren[focusableChildren.length - 1];
+    }
+    this.$.dropdown.positionTarget = anchor;
+    this.menuOpen = true;
+  },
+  toggleMenu: function(anchor, itemData) {
+    if (anchor == this.lastAnchor_ && this.menuOpen) this.closeMenu(); else this.openMenu(anchor, itemData);
+  },
+  onTabPressed_: function(e) {
+    if (!this.firstFocus_ || !this.lastFocus_) return;
+    var toFocus;
+    var keyEvent = e.detail.keyboardEvent;
+    if (keyEvent.shiftKey && keyEvent.target == this.firstFocus_) toFocus = this.lastFocus_; else if (keyEvent.target == this.lastFocus_) toFocus = this.firstFocus_;
+    if (!toFocus) return;
+    e.preventDefault();
+    toFocus.focus();
+  },
+  menuOpenChanged_: function() {
+    if (!this.menuOpen) {
+      this.itemData = null;
+      this.lastAnchor_ = null;
+    }
+  },
+  onOverlayCanceled_: function(e) {
+    if (e.detail.type == 'tap') this.$.dropdown.restoreFocusOnClose = false;
+  }
+});
+
+Polymer.PaperItemBehaviorImpl = {
+  hostAttributes: {
+    role: 'option',
+    tabindex: '0'
+  }
+};
+
+Polymer.PaperItemBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperItemBehaviorImpl ];
+
+Polymer({
+  is: 'paper-item',
+  behaviors: [ Polymer.PaperItemBehavior ]
+});
+
+Polymer({
+  is: 'iron-collapse',
+  behaviors: [ Polymer.IronResizableBehavior ],
+  properties: {
+    horizontal: {
+      type: Boolean,
+      value: false,
+      observer: '_horizontalChanged'
+    },
+    opened: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      observer: '_openedChanged'
+    },
+    noAnimation: {
+      type: Boolean
+    }
+  },
+  get dimension() {
+    return this.horizontal ? 'width' : 'height';
+  },
+  get _dimensionMax() {
+    return this.horizontal ? 'maxWidth' : 'maxHeight';
+  },
+  get _dimensionMaxCss() {
+    return this.horizontal ? 'max-width' : 'max-height';
+  },
+  hostAttributes: {
+    role: 'group',
+    'aria-hidden': 'true',
+    'aria-expanded': 'false'
+  },
+  listeners: {
+    transitionend: '_transitionEnd'
+  },
+  attached: function() {
+    this._transitionEnd();
+  },
+  toggle: function() {
+    this.opened = !this.opened;
+  },
+  show: function() {
+    this.opened = true;
+  },
+  hide: function() {
+    this.opened = false;
+  },
+  updateSize: function(size, animated) {
+    var curSize = this.style[this._dimensionMax];
+    if (curSize === size || size === 'auto' && !curSize) {
+      return;
+    }
+    this._updateTransition(false);
+    if (animated && !this.noAnimation && this._isDisplayed) {
+      var startSize = this._calcSize();
+      if (size === 'auto') {
+        this.style[this._dimensionMax] = '';
+        size = this._calcSize();
+      }
+      this.style[this._dimensionMax] = startSize;
+      this.scrollTop = this.scrollTop;
+      this._updateTransition(true);
+    }
+    if (size === 'auto') {
+      this.style[this._dimensionMax] = '';
+    } else {
+      this.style[this._dimensionMax] = size;
+    }
+  },
+  enableTransition: function(enabled) {
+    Polymer.Base._warn('`enableTransition()` is deprecated, use `noAnimation` instead.');
+    this.noAnimation = !enabled;
+  },
+  _updateTransition: function(enabled) {
+    this.style.transitionDuration = enabled && !this.noAnimation ? '' : '0s';
+  },
+  _horizontalChanged: function() {
+    this.style.transitionProperty = this._dimensionMaxCss;
+    var otherDimension = this._dimensionMax === 'maxWidth' ? 'maxHeight' : 'maxWidth';
+    this.style[otherDimension] = '';
+    this.updateSize(this.opened ? 'auto' : '0px', false);
+  },
+  _openedChanged: function() {
+    this.setAttribute('aria-expanded', this.opened);
+    this.setAttribute('aria-hidden', !this.opened);
+    this.toggleClass('iron-collapse-closed', false);
+    this.toggleClass('iron-collapse-opened', false);
+    this.updateSize(this.opened ? 'auto' : '0px', true);
+    if (this.opened) {
+      this.focus();
+    }
+    if (this.noAnimation) {
+      this._transitionEnd();
+    }
+  },
+  _transitionEnd: function() {
+    if (this.opened) {
+      this.style[this._dimensionMax] = '';
+    }
+    this.toggleClass('iron-collapse-closed', !this.opened);
+    this.toggleClass('iron-collapse-opened', this.opened);
+    this._updateTransition(false);
+    this.notifyResize();
+  },
+  get _isDisplayed() {
+    var rect = this.getBoundingClientRect();
+    for (var prop in rect) {
+      if (rect[prop] !== 0) return true;
+    }
+    return false;
+  },
+  _calcSize: function() {
+    return this.getBoundingClientRect()[this.dimension] + 'px';
+  }
+});
+
+Polymer.IronFormElementBehavior = {
+  properties: {
+    name: {
+      type: String
+    },
+    value: {
+      notify: true,
+      type: String
+    },
+    required: {
+      type: Boolean,
+      value: false
+    },
+    _parentForm: {
+      type: Object
+    }
+  },
+  attached: function() {
+    this.fire('iron-form-element-register');
+  },
+  detached: function() {
+    if (this._parentForm) {
+      this._parentForm.fire('iron-form-element-unregister', {
+        target: this
+      });
+    }
+  }
+};
+
+Polymer.IronCheckedElementBehaviorImpl = {
+  properties: {
+    checked: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true,
+      notify: true,
+      observer: '_checkedChanged'
+    },
+    toggles: {
+      type: Boolean,
+      value: true,
+      reflectToAttribute: true
+    },
+    value: {
+      type: String,
+      value: 'on',
+      observer: '_valueChanged'
+    }
+  },
+  observers: [ '_requiredChanged(required)' ],
+  created: function() {
+    this._hasIronCheckedElementBehavior = true;
+  },
+  _getValidity: function(_value) {
+    return this.disabled || !this.required || this.checked;
+  },
+  _requiredChanged: function() {
+    if (this.required) {
+      this.setAttribute('aria-required', 'true');
+    } else {
+      this.removeAttribute('aria-required');
+    }
+  },
+  _checkedChanged: function() {
+    this.active = this.checked;
+    this.fire('iron-change');
+  },
+  _valueChanged: function() {
+    if (this.value === undefined || this.value === null) {
+      this.value = 'on';
+    }
+  }
+};
+
+Polymer.IronCheckedElementBehavior = [ Polymer.IronFormElementBehavior, Polymer.IronValidatableBehavior, Polymer.IronCheckedElementBehaviorImpl ];
+
+Polymer.PaperCheckedElementBehaviorImpl = {
+  _checkedChanged: function() {
+    Polymer.IronCheckedElementBehaviorImpl._checkedChanged.call(this);
+    if (this.hasRipple()) {
+      if (this.checked) {
+        this._ripple.setAttribute('checked', '');
+      } else {
+        this._ripple.removeAttribute('checked');
+      }
+    }
+  },
+  _buttonStateChanged: function() {
+    Polymer.PaperRippleBehavior._buttonStateChanged.call(this);
+    if (this.disabled) {
+      return;
+    }
+    if (this.isAttached) {
+      this.checked = this.active;
+    }
+  }
+};
+
+Polymer.PaperCheckedElementBehavior = [ Polymer.PaperInkyFocusBehavior, Polymer.IronCheckedElementBehavior, Polymer.PaperCheckedElementBehaviorImpl ];
+
+Polymer({
+  is: 'paper-checkbox',
+  behaviors: [ Polymer.PaperCheckedElementBehavior ],
+  hostAttributes: {
+    role: 'checkbox',
+    'aria-checked': false,
+    tabindex: 0
+  },
+  properties: {
+    ariaActiveAttribute: {
+      type: String,
+      value: 'aria-checked'
+    }
+  },
+  _computeCheckboxClass: function(checked, invalid) {
+    var className = '';
+    if (checked) {
+      className += 'checked ';
+    }
+    if (invalid) {
+      className += 'invalid';
+    }
+    return className;
+  },
+  _computeCheckmarkClass: function(checked) {
+    return checked ? '' : 'hidden';
+  },
+  _createRipple: function() {
+    this._rippleContainer = this.$.checkboxContainer;
+    return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this);
+  }
+});
+
+Polymer({
+  is: 'paper-icon-button-light',
+  "extends": 'button',
+  behaviors: [ Polymer.PaperRippleBehavior ],
+  listeners: {
+    down: '_rippleDown',
+    up: '_rippleUp',
+    focus: '_rippleDown',
+    blur: '_rippleUp'
+  },
+  _rippleDown: function() {
+    this.getRipple().downAction();
+  },
+  _rippleUp: function() {
+    this.getRipple().upAction();
+  },
+  ensureRipple: function(var_args) {
+    var lastRipple = this._ripple;
+    Polymer.PaperRippleBehavior.ensureRipple.apply(this, arguments);
+    if (this._ripple && this._ripple !== lastRipple) {
+      this._ripple.center = true;
+      this._ripple.classList.add('circle');
+    }
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+cr.define('cr.icon', function() {
+  function getSupportedScaleFactors() {
+    var supportedScaleFactors = [];
+    if (cr.isMac || cr.isChromeOS || cr.isWindows || cr.isLinux) {
+      supportedScaleFactors.push(1);
+      supportedScaleFactors.push(2);
+    } else {
+      supportedScaleFactors.push(window.devicePixelRatio);
+    }
+    return supportedScaleFactors;
+  }
+  function getProfileAvatarIcon(path) {
+    var chromeThemePath = 'chrome://theme';
+    var isDefaultAvatar = path.slice(0, chromeThemePath.length) == chromeThemePath;
+    return isDefaultAvatar ? imageset(path + '@scalefactorx') : url(path);
+  }
+  function imageset(path) {
+    var supportedScaleFactors = getSupportedScaleFactors();
+    var replaceStartIndex = path.indexOf('scalefactor');
+    if (replaceStartIndex < 0) return url(path);
+    var s = '';
+    for (var i = 0; i < supportedScaleFactors.length; ++i) {
+      var scaleFactor = supportedScaleFactors[i];
+      var pathWithScaleFactor = path.substr(0, replaceStartIndex) + scaleFactor + path.substr(replaceStartIndex + 'scalefactor'.length);
+      s += url(pathWithScaleFactor) + ' ' + scaleFactor + 'x';
+      if (i != supportedScaleFactors.length - 1) s += ', ';
+    }
+    return '-webkit-image-set(' + s + ')';
+  }
+  var FAVICON_URL_REGEX = /\.ico$/i;
+  function getFaviconImageSet(url, opt_size, opt_type) {
+    var size = opt_size || 16;
+    var type = opt_type || 'favicon';
+    return imageset('chrome://' + type + '/size/' + size + '@scalefactorx/' + (FAVICON_URL_REGEX.test(url) ? 'iconurl/' : '') + url);
+  }
+  return {
+    getSupportedScaleFactors: getSupportedScaleFactors,
+    getProfileAvatarIcon: getProfileAvatarIcon,
+    getFaviconImageSet: getFaviconImageSet
+  };
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+cr.define('md_history', function() {
+  function BrowserService() {
+    this.pendingDeleteItems_ = null;
+    this.pendingDeletePromise_ = null;
+  }
+  BrowserService.prototype = {
+    deleteItems: function(items) {
+      if (this.pendingDeleteItems_ != null) {
+        return new Promise(function(resolve, reject) {
+          reject(items);
+        });
+      }
+      var removalList = items.map(function(item) {
+        return {
+          url: item.url,
+          timestamps: item.allTimestamps
+        };
+      });
+      this.pendingDeleteItems_ = items;
+      this.pendingDeletePromise_ = new PromiseResolver();
+      chrome.send('removeVisits', removalList);
+      return this.pendingDeletePromise_.promise;
+    },
+    removeBookmark: function(url) {
+      chrome.send('removeBookmark', [ url ]);
+    },
+    openForeignSessionAllTabs: function(sessionTag) {
+      chrome.send('openForeignSession', [ sessionTag ]);
+    },
+    openForeignSessionTab: function(sessionTag, windowId, tabId, e) {
+      chrome.send('openForeignSession', [ sessionTag, String(windowId), String(tabId), e.button || 0, e.altKey, e.ctrlKey, e.metaKey, e.shiftKey ]);
+    },
+    deleteForeignSession: function(sessionTag) {
+      chrome.send('deleteForeignSession', [ sessionTag ]);
+    },
+    openClearBrowsingData: function() {
+      chrome.send('clearBrowsingData');
+    },
+    resolveDelete_: function(successful) {
+      if (this.pendingDeleteItems_ == null || this.pendingDeletePromise_ == null) {
+        return;
+      }
+      if (successful) this.pendingDeletePromise_.resolve(this.pendingDeleteItems_); else this.pendingDeletePromise_.reject(this.pendingDeleteItems_);
+      this.pendingDeleteItems_ = null;
+      this.pendingDeletePromise_ = null;
+    }
+  };
+  cr.addSingletonGetter(BrowserService);
+  return {
+    BrowserService: BrowserService
+  };
+});
+
+function deleteComplete() {
+  md_history.BrowserService.getInstance().resolveDelete_(true);
+}
+
+function deleteFailed() {
+  md_history.BrowserService.getInstance().resolveDelete_(false);
+}
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-searched-label',
+  properties: {
+    title: String,
+    searchTerm: String
+  },
+  observers: [ 'setSearchedTextToBold_(title, searchTerm)' ],
+  setSearchedTextToBold_: function() {
+    var i = 0;
+    var titleElem = this.$.container;
+    var titleText = this.title;
+    if (this.searchTerm == '' || this.searchTerm == null) {
+      titleElem.textContent = titleText;
+      return;
+    }
+    var re = new RegExp(quoteString(this.searchTerm), 'gim');
+    var match;
+    titleElem.textContent = '';
+    while (match = re.exec(titleText)) {
+      if (match.index > i) titleElem.appendChild(document.createTextNode(titleText.slice(i, match.index)));
+      i = re.lastIndex;
+      var b = document.createElement('b');
+      b.textContent = titleText.substring(match.index, i);
+      titleElem.appendChild(b);
+    }
+    if (i < titleText.length) titleElem.appendChild(document.createTextNode(titleText.slice(i)));
+  }
+});
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+cr.define('md_history', function() {
+  var HistoryItem = Polymer({
+    is: 'history-item',
+    properties: {
+      item: {
+        type: Object,
+        observer: 'showIcon_'
+      },
+      searchTerm: {
+        type: String
+      },
+      selected: {
+        type: Boolean,
+        notify: true
+      },
+      isFirstItem: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      isCardStart: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      isCardEnd: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      embedded: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      hasTimeGap: {
+        type: Boolean
+      },
+      numberOfItems: {
+        type: Number
+      },
+      path: String
+    },
+    onCheckboxSelected_: function() {
+      this.fire('history-checkbox-select', {
+        element: this,
+        countAddition: this.$.checkbox.checked ? 1 : -1
+      });
+    },
+    onRemoveBookmarkTap_: function() {
+      if (!this.item.starred) return;
+      if (this.$$('#bookmark-star') == this.root.activeElement) this.$['menu-button'].focus();
+      md_history.BrowserService.getInstance().removeBookmark(this.item.url);
+      this.fire('remove-bookmark-stars', this.item.url);
+    },
+    onMenuButtonTap_: function(e) {
+      this.fire('toggle-menu', {
+        target: Polymer.dom(e).localTarget,
+        item: this.item
+      });
+      e.stopPropagation();
+    },
+    showIcon_: function() {
+      this.$.icon.style.backgroundImage = cr.icon.getFaviconImageSet(this.item.url);
+    },
+    selectionNotAllowed_: function() {
+      return !loadTimeData.getBoolean('allowDeletingHistory');
+    },
+    cardTitle_: function(numberOfItems, historyDate, search) {
+      if (!search) return this.item.dateRelativeDay;
+      var resultId = numberOfItems == 1 ? 'searchResult' : 'searchResults';
+      return loadTimeData.getStringF('foundSearchResults', numberOfItems, loadTimeData.getString(resultId), search);
+    },
+    cropItemTitle_: function(title) {
+      return title.length > TITLE_MAX_LENGTH ? title.substr(0, TITLE_MAX_LENGTH) : title;
+    }
+  });
+  HistoryItem.needsTimeGap = function(visits, currentIndex, searchedTerm) {
+    if (currentIndex >= visits.length - 1 || visits.length == 0) return false;
+    var currentItem = visits[currentIndex];
+    var nextItem = visits[currentIndex + 1];
+    if (searchedTerm) return currentItem.dateShort != nextItem.dateShort;
+    return currentItem.time - nextItem.time > BROWSING_GAP_TIME && currentItem.dateRelativeDay == nextItem.dateRelativeDay;
+  };
+  return {
+    HistoryItem: HistoryItem
+  };
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var SelectionTreeNode = function(currentPath) {
+  this.currentPath = currentPath;
+  this.leaf = false;
+  this.indexes = [];
+  this.children = [];
+};
+
+SelectionTreeNode.prototype.addChild = function(index, path) {
+  this.indexes.push(index);
+  this.children[index] = new SelectionTreeNode(path);
+};
+
+var HistoryListBehavior = {
+  properties: {
+    selectedPaths: {
+      type: Array,
+      value: function() {
+        return [];
+      }
+    }
+  },
+  listeners: {
+    'history-checkbox-select': 'itemSelected_'
+  },
+  hasResults: function(historyDataLength) {
+    return historyDataLength > 0;
+  },
+  noResultsMessage: function(searchedTerm, isLoading) {
+    if (isLoading) return '';
+    var messageId = searchedTerm !== '' ? 'noSearchResults' : 'noResults';
+    return loadTimeData.getString(messageId);
+  },
+  unselectAllItems: function() {
+    this.selectedPaths.forEach(function(path) {
+      this.set(path + '.selected', false);
+    }.bind(this));
+    this.selectedPaths = [];
+  },
+  deleteSelected: function() {
+    var toBeRemoved = this.selectedPaths.map(function(path) {
+      return this.get(path);
+    }.bind(this));
+    md_history.BrowserService.getInstance().deleteItems(toBeRemoved).then(function() {
+      this.removeItemsByPath(this.selectedPaths);
+      this.fire('unselect-all');
+    }.bind(this));
+  },
+  removeItemsByPath: function(paths) {
+    if (paths.length == 0) return;
+    this.removeItemsBeneathNode_(this.buildRemovalTree_(paths));
+  },
+  buildRemovalTree_: function(paths) {
+    var rootNode = new SelectionTreeNode(paths[0].split('.')[0]);
+    paths.forEach(function(path) {
+      var components = path.split('.');
+      var node = rootNode;
+      components.shift();
+      while (components.length > 1) {
+        var index = Number(components.shift());
+        var arrayName = components.shift();
+        if (!node.children[index]) node.addChild(index, [ node.currentPath, index, arrayName ].join('.'));
+        node = node.children[index];
+      }
+      node.leaf = true;
+      node.indexes.push(Number(components.shift()));
+    });
+    return rootNode;
+  },
+  removeItemsBeneathNode_: function(node) {
+    var array = this.get(node.currentPath);
+    var splices = [];
+    node.indexes.sort(function(a, b) {
+      return b - a;
+    });
+    node.indexes.forEach(function(index) {
+      if (node.leaf || this.removeItemsBeneathNode_(node.children[index])) {
+        var item = array.splice(index, 1);
+        splices.push({
+          index: index,
+          removed: [ item ],
+          addedCount: 0,
+          object: array,
+          type: 'splice'
+        });
+      }
+    }.bind(this));
+    if (array.length == 0) return true;
+    this.notifySplices(node.currentPath, splices);
+    return false;
+  },
+  itemSelected_: function(e) {
+    var item = e.detail.element;
+    var path = item.path;
+    if (item.selected) {
+      this.push('selectedPaths', path);
+      return;
+    }
+    var index = this.selectedPaths.indexOf(path);
+    if (index != -1) this.splice('selectedPaths', index, 1);
+  }
+};
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var HistoryDomain;
+
+var HistoryGroup;
+
+Polymer({
+  is: 'history-grouped-list',
+  behaviors: [ HistoryListBehavior ],
+  properties: {
+    historyData: {
+      type: Array
+    },
+    groupedHistoryData_: {
+      type: Array
+    },
+    searchedTerm: {
+      type: String,
+      value: ''
+    },
+    range: {
+      type: Number
+    },
+    queryStartTime: String,
+    queryEndTime: String
+  },
+  observers: [ 'updateGroupedHistoryData_(range, historyData)' ],
+  createHistoryDomains_: function(visits) {
+    var domainIndexes = {};
+    var domains = [];
+    for (var i = 0, visit; visit = visits[i]; i++) {
+      var domain = visit.domain;
+      if (domainIndexes[domain] == undefined) {
+        domainIndexes[domain] = domains.length;
+        domains.push({
+          domain: domain,
+          visits: [],
+          expanded: false,
+          rendered: false
+        });
+      }
+      domains[domainIndexes[domain]].visits.push(visit);
+    }
+    var sortByVisits = function(a, b) {
+      return b.visits.length - a.visits.length;
+    };
+    domains.sort(sortByVisits);
+    return domains;
+  },
+  updateGroupedHistoryData_: function() {
+    if (this.historyData.length == 0) {
+      this.groupedHistoryData_ = [];
+      return;
+    }
+    if (this.range == HistoryRange.WEEK) {
+      var days = [];
+      var currentDayVisits = [ this.historyData[0] ];
+      var pushCurrentDay = function() {
+        days.push({
+          title: this.searchedTerm ? currentDayVisits[0].dateShort : currentDayVisits[0].dateRelativeDay,
+          domains: this.createHistoryDomains_(currentDayVisits)
+        });
+      }.bind(this);
+      var visitsSameDay = function(a, b) {
+        if (this.searchedTerm) return a.dateShort == b.dateShort;
+        return a.dateRelativeDay == b.dateRelativeDay;
+      }.bind(this);
+      for (var i = 1; i < this.historyData.length; i++) {
+        var visit = this.historyData[i];
+        if (!visitsSameDay(visit, currentDayVisits[0])) {
+          pushCurrentDay();
+          currentDayVisits = [];
+        }
+        currentDayVisits.push(visit);
+      }
+      pushCurrentDay();
+      this.groupedHistoryData_ = days;
+    } else if (this.range == HistoryRange.MONTH) {
+      this.groupedHistoryData_ = [ {
+        title: this.queryStartTime + ' – ' + this.queryEndTime,
+        domains: this.createHistoryDomains_(this.historyData)
+      } ];
+    }
+  },
+  toggleDomainExpanded_: function(e) {
+    var collapse = e.currentTarget.parentNode.querySelector('iron-collapse');
+    e.model.set('domain.rendered', true);
+    setTimeout(function() {
+      collapse.toggle();
+    }, 0);
+  },
+  needsTimeGap_: function(groupIndex, domainIndex, itemIndex) {
+    var visits = this.groupedHistoryData_[groupIndex].domains[domainIndex].visits;
+    return md_history.HistoryItem.needsTimeGap(visits, itemIndex, this.searchedTerm);
+  },
+  pathForItem_: function(groupIndex, domainIndex, itemIndex) {
+    return [ 'groupedHistoryData_', groupIndex, 'domains', domainIndex, 'visits', itemIndex ].join('.');
+  },
+  getWebsiteIconStyle_: function(domain) {
+    return 'background-image: ' + cr.icon.getFaviconImageSet(domain.visits[0].url);
+  },
+  getDropdownIcon_: function(expanded) {
+    return expanded ? 'cr:expand-less' : 'cr:expand-more';
+  }
+});
+
+Polymer.IronScrollTargetBehavior = {
+  properties: {
+    scrollTarget: {
+      type: HTMLElement,
+      value: function() {
+        return this._defaultScrollTarget;
+      }
+    }
+  },
+  observers: [ '_scrollTargetChanged(scrollTarget, isAttached)' ],
+  _scrollTargetChanged: function(scrollTarget, isAttached) {
+    var eventTarget;
+    if (this._oldScrollTarget) {
+      eventTarget = this._oldScrollTarget === this._doc ? window : this._oldScrollTarget;
+      eventTarget.removeEventListener('scroll', this._boundScrollHandler);
+      this._oldScrollTarget = null;
+    }
+    if (!isAttached) {
+      return;
+    }
+    if (scrollTarget === 'document') {
+      this.scrollTarget = this._doc;
+    } else if (typeof scrollTarget === 'string') {
+      this.scrollTarget = this.domHost ? this.domHost.$[scrollTarget] : Polymer.dom(this.ownerDocument).querySelector('#' + scrollTarget);
+    } else if (this._isValidScrollTarget()) {
+      eventTarget = scrollTarget === this._doc ? window : scrollTarget;
+      this._boundScrollHandler = this._boundScrollHandler || this._scrollHandler.bind(this);
+      this._oldScrollTarget = scrollTarget;
+      eventTarget.addEventListener('scroll', this._boundScrollHandler);
+    }
+  },
+  _scrollHandler: function scrollHandler() {},
+  get _defaultScrollTarget() {
+    return this._doc;
+  },
+  get _doc() {
+    return this.ownerDocument.documentElement;
+  },
+  get _scrollTop() {
+    if (this._isValidScrollTarget()) {
+      return this.scrollTarget === this._doc ? window.pageYOffset : this.scrollTarget.scrollTop;
+    }
+    return 0;
+  },
+  get _scrollLeft() {
+    if (this._isValidScrollTarget()) {
+      return this.scrollTarget === this._doc ? window.pageXOffset : this.scrollTarget.scrollLeft;
+    }
+    return 0;
+  },
+  set _scrollTop(top) {
+    if (this.scrollTarget === this._doc) {
+      window.scrollTo(window.pageXOffset, top);
+    } else if (this._isValidScrollTarget()) {
+      this.scrollTarget.scrollTop = top;
+    }
+  },
+  set _scrollLeft(left) {
+    if (this.scrollTarget === this._doc) {
+      window.scrollTo(left, window.pageYOffset);
+    } else if (this._isValidScrollTarget()) {
+      this.scrollTarget.scrollLeft = left;
+    }
+  },
+  scroll: function(left, top) {
+    if (this.scrollTarget === this._doc) {
+      window.scrollTo(left, top);
+    } else if (this._isValidScrollTarget()) {
+      this.scrollTarget.scrollLeft = left;
+      this.scrollTarget.scrollTop = top;
+    }
+  },
+  get _scrollTargetWidth() {
+    if (this._isValidScrollTarget()) {
+      return this.scrollTarget === this._doc ? window.innerWidth : this.scrollTarget.offsetWidth;
+    }
+    return 0;
+  },
+  get _scrollTargetHeight() {
+    if (this._isValidScrollTarget()) {
+      return this.scrollTarget === this._doc ? window.innerHeight : this.scrollTarget.offsetHeight;
+    }
+    return 0;
+  },
+  _isValidScrollTarget: function() {
+    return this.scrollTarget instanceof HTMLElement;
+  }
+};
+
+(function() {
+  var IOS = navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/);
+  var IOS_TOUCH_SCROLLING = IOS && IOS[1] >= 8;
+  var DEFAULT_PHYSICAL_COUNT = 3;
+  var HIDDEN_Y = '-10000px';
+  var DEFAULT_GRID_SIZE = 200;
+  var SECRET_TABINDEX = -100;
+  Polymer({
+    is: 'iron-list',
+    properties: {
+      items: {
+        type: Array
+      },
+      maxPhysicalCount: {
+        type: Number,
+        value: 500
+      },
+      as: {
+        type: String,
+        value: 'item'
+      },
+      indexAs: {
+        type: String,
+        value: 'index'
+      },
+      selectedAs: {
+        type: String,
+        value: 'selected'
+      },
+      grid: {
+        type: Boolean,
+        value: false,
+        reflectToAttribute: true
+      },
+      selectionEnabled: {
+        type: Boolean,
+        value: false
+      },
+      selectedItem: {
+        type: Object,
+        notify: true
+      },
+      selectedItems: {
+        type: Object,
+        notify: true
+      },
+      multiSelection: {
+        type: Boolean,
+        value: false
+      }
+    },
+    observers: [ '_itemsChanged(items.*)', '_selectionEnabledChanged(selectionEnabled)', '_multiSelectionChanged(multiSelection)', '_setOverflow(scrollTarget)' ],
+    behaviors: [ Polymer.Templatizer, Polymer.IronResizableBehavior, Polymer.IronA11yKeysBehavior, Polymer.IronScrollTargetBehavior ],
+    keyBindings: {
+      up: '_didMoveUp',
+      down: '_didMoveDown',
+      enter: '_didEnter'
+    },
+    _ratio: .5,
+    _scrollerPaddingTop: 0,
+    _scrollPosition: 0,
+    _physicalSize: 0,
+    _physicalAverage: 0,
+    _physicalAverageCount: 0,
+    _physicalTop: 0,
+    _virtualCount: 0,
+    _physicalIndexForKey: null,
+    _estScrollHeight: 0,
+    _scrollHeight: 0,
+    _viewportHeight: 0,
+    _viewportWidth: 0,
+    _physicalItems: null,
+    _physicalSizes: null,
+    _firstVisibleIndexVal: null,
+    _lastVisibleIndexVal: null,
+    _collection: null,
+    _itemsRendered: false,
+    _lastPage: null,
+    _maxPages: 3,
+    _focusedItem: null,
+    _focusedIndex: -1,
+    _offscreenFocusedItem: null,
+    _focusBackfillItem: null,
+    _itemsPerRow: 1,
+    _itemWidth: 0,
+    _rowHeight: 0,
+    get _physicalBottom() {
+      return this._physicalTop + this._physicalSize;
+    },
+    get _scrollBottom() {
+      return this._scrollPosition + this._viewportHeight;
+    },
+    get _virtualEnd() {
+      return this._virtualStart + this._physicalCount - 1;
+    },
+    get _hiddenContentSize() {
+      var size = this.grid ? this._physicalRows * this._rowHeight : this._physicalSize;
+      return size - this._viewportHeight;
+    },
+    get _maxScrollTop() {
+      return this._estScrollHeight - this._viewportHeight + this._scrollerPaddingTop;
+    },
+    _minVirtualStart: 0,
+    get _maxVirtualStart() {
+      return Math.max(0, this._virtualCount - this._physicalCount);
+    },
+    _virtualStartVal: 0,
+    set _virtualStart(val) {
+      this._virtualStartVal = Math.min(this._maxVirtualStart, Math.max(this._minVirtualStart, val));
+    },
+    get _virtualStart() {
+      return this._virtualStartVal || 0;
+    },
+    _physicalStartVal: 0,
+    set _physicalStart(val) {
+      this._physicalStartVal = val % this._physicalCount;
+      if (this._physicalStartVal < 0) {
+        this._physicalStartVal = this._physicalCount + this._physicalStartVal;
+      }
+      this._physicalEnd = (this._physicalStart + this._physicalCount - 1) % this._physicalCount;
+    },
+    get _physicalStart() {
+      return this._physicalStartVal || 0;
+    },
+    _physicalCountVal: 0,
+    set _physicalCount(val) {
+      this._physicalCountVal = val;
+      this._physicalEnd = (this._physicalStart + this._physicalCount - 1) % this._physicalCount;
+    },
+    get _physicalCount() {
+      return this._physicalCountVal;
+    },
+    _physicalEnd: 0,
+    get _optPhysicalSize() {
+      if (this.grid) {
+        return this._estRowsInView * this._rowHeight * this._maxPages;
+      }
+      return this._viewportHeight * this._maxPages;
+    },
+    get _optPhysicalCount() {
+      return this._estRowsInView * this._itemsPerRow * this._maxPages;
+    },
+    get _isVisible() {
+      return this.scrollTarget && Boolean(this.scrollTarget.offsetWidth || this.scrollTarget.offsetHeight);
+    },
+    get firstVisibleIndex() {
+      if (this._firstVisibleIndexVal === null) {
+        var physicalOffset = Math.floor(this._physicalTop + this._scrollerPaddingTop);
+        this._firstVisibleIndexVal = this._iterateItems(function(pidx, vidx) {
+          physicalOffset += this._getPhysicalSizeIncrement(pidx);
+          if (physicalOffset > this._scrollPosition) {
+            return this.grid ? vidx - vidx % this._itemsPerRow : vidx;
+          }
+          if (this.grid && this._virtualCount - 1 === vidx) {
+            return vidx - vidx % this._itemsPerRow;
+          }
+        }) || 0;
+      }
+      return this._firstVisibleIndexVal;
+    },
+    get lastVisibleIndex() {
+      if (this._lastVisibleIndexVal === null) {
+        if (this.grid) {
+          var lastIndex = this.firstVisibleIndex + this._estRowsInView * this._itemsPerRow - 1;
+          this._lastVisibleIndexVal = Math.min(this._virtualCount, lastIndex);
+        } else {
+          var physicalOffset = this._physicalTop;
+          this._iterateItems(function(pidx, vidx) {
+            if (physicalOffset < this._scrollBottom) {
+              this._lastVisibleIndexVal = vidx;
+            } else {
+              return true;
+            }
+            physicalOffset += this._getPhysicalSizeIncrement(pidx);
+          });
+        }
+      }
+      return this._lastVisibleIndexVal;
+    },
+    get _defaultScrollTarget() {
+      return this;
+    },
+    get _virtualRowCount() {
+      return Math.ceil(this._virtualCount / this._itemsPerRow);
+    },
+    get _estRowsInView() {
+      return Math.ceil(this._viewportHeight / this._rowHeight);
+    },
+    get _physicalRows() {
+      return Math.ceil(this._physicalCount / this._itemsPerRow);
+    },
+    ready: function() {
+      this.addEventListener('focus', this._didFocus.bind(this), true);
+    },
+    attached: function() {
+      this.updateViewportBoundaries();
+      this._render();
+      this.listen(this, 'iron-resize', '_resizeHandler');
+    },
+    detached: function() {
+      this._itemsRendered = false;
+      this.unlisten(this, 'iron-resize', '_resizeHandler');
+    },
+    _setOverflow: function(scrollTarget) {
+      this.style.webkitOverflowScrolling = scrollTarget === this ? 'touch' : '';
+      this.style.overflow = scrollTarget === this ? 'auto' : '';
+    },
+    updateViewportBoundaries: function() {
+      this._scrollerPaddingTop = this.scrollTarget === this ? 0 : parseInt(window.getComputedStyle(this)['padding-top'], 10);
+      this._viewportHeight = this._scrollTargetHeight;
+      if (this.grid) {
+        this._updateGridMetrics();
+      }
+    },
+    _scrollHandler: function() {
+      var scrollTop = Math.max(0, Math.min(this._maxScrollTop, this._scrollTop));
+      var delta = scrollTop - this._scrollPosition;
+      var tileHeight, tileTop, kth, recycledTileSet, scrollBottom, physicalBottom;
+      var ratio = this._ratio;
+      var recycledTiles = 0;
+      var hiddenContentSize = this._hiddenContentSize;
+      var currentRatio = ratio;
+      var movingUp = [];
+      this._scrollPosition = scrollTop;
+      this._firstVisibleIndexVal = null;
+      this._lastVisibleIndexVal = null;
+      scrollBottom = this._scrollBottom;
+      physicalBottom = this._physicalBottom;
+      if (Math.abs(delta) > this._physicalSize) {
+        this._physicalTop += delta;
+        recycledTiles = Math.round(delta / this._physicalAverage);
+      } else if (delta < 0) {
+        var topSpace = scrollTop - this._physicalTop;
+        var virtualStart = this._virtualStart;
+        recycledTileSet = [];
+        kth = this._physicalEnd;
+        currentRatio = topSpace / hiddenContentSize;
+        while (currentRatio < ratio && recycledTiles < this._physicalCount && virtualStart - recycledTiles > 0 && physicalBottom - this._getPhysicalSizeIncrement(kth) > scrollBottom) {
+          tileHeight = this._getPhysicalSizeIncrement(kth);
+          currentRatio += tileHeight / hiddenContentSize;
+          physicalBottom -= tileHeight;
+          recycledTileSet.push(kth);
+          recycledTiles++;
+          kth = kth === 0 ? this._physicalCount - 1 : kth - 1;
+        }
+        movingUp = recycledTileSet;
+        recycledTiles = -recycledTiles;
+      } else if (delta > 0) {
+        var bottomSpace = physicalBottom - scrollBottom;
+        var virtualEnd = this._virtualEnd;
+        var lastVirtualItemIndex = this._virtualCount - 1;
+        recycledTileSet = [];
+        kth = this._physicalStart;
+        currentRatio = bottomSpace / hiddenContentSize;
+        while (currentRatio < ratio && recycledTiles < this._physicalCount && virtualEnd + recycledTiles < lastVirtualItemIndex && this._physicalTop + this._getPhysicalSizeIncrement(kth) < scrollTop) {
+          tileHeight = this._getPhysicalSizeIncrement(kth);
+          currentRatio += tileHeight / hiddenContentSize;
+          this._physicalTop += tileHeight;
+          recycledTileSet.push(kth);
+          recycledTiles++;
+          kth = (kth + 1) % this._physicalCount;
+        }
+      }
+      if (recycledTiles === 0) {
+        if (physicalBottom < scrollBottom || this._physicalTop > scrollTop) {
+          this._increasePoolIfNeeded();
+        }
+      } else {
+        this._virtualStart = this._virtualStart + recycledTiles;
+        this._physicalStart = this._physicalStart + recycledTiles;
+        this._update(recycledTileSet, movingUp);
+      }
+    },
+    _update: function(itemSet, movingUp) {
+      this._manageFocus();
+      this._assignModels(itemSet);
+      this._updateMetrics(itemSet);
+      if (movingUp) {
+        while (movingUp.length) {
+          var idx = movingUp.pop();
+          this._physicalTop -= this._getPhysicalSizeIncrement(idx);
+        }
+      }
+      this._positionItems();
+      this._updateScrollerSize();
+      this._increasePoolIfNeeded();
+    },
+    _createPool: function(size) {
+      var physicalItems = new Array(size);
+      this._ensureTemplatized();
+      for (var i = 0; i < size; i++) {
+        var inst = this.stamp(null);
+        physicalItems[i] = inst.root.querySelector('*');
+        Polymer.dom(this).appendChild(inst.root);
+      }
+      return physicalItems;
+    },
+    _increasePoolIfNeeded: function() {
+      if (this._viewportHeight === 0) {
+        return false;
+      }
+      var isClientHeightFull = this._physicalBottom >= this._scrollBottom && this._physicalTop <= this._scrollPosition;
+      if (this._physicalSize >= this._optPhysicalSize && isClientHeightFull) {
+        return false;
+      }
+      var currentPage = Math.floor(this._physicalSize / this._viewportHeight);
+      if (currentPage === 0) {
+        this._debounceTemplate(this._increasePool.bind(this, Math.round(this._physicalCount * .5)));
+      } else if (this._lastPage !== currentPage && isClientHeightFull) {
+        Polymer.dom.addDebouncer(this.debounce('_debounceTemplate', this._increasePool.bind(this, this._itemsPerRow), 16));
+      } else {
+        this._debounceTemplate(this._increasePool.bind(this, this._itemsPerRow));
+      }
+      this._lastPage = currentPage;
+      return true;
+    },
+    _increasePool: function(missingItems) {
+      var nextPhysicalCount = Math.min(this._physicalCount + missingItems, this._virtualCount - this._virtualStart, Math.max(this.maxPhysicalCount, DEFAULT_PHYSICAL_COUNT));
+      var prevPhysicalCount = this._physicalCount;
+      var delta = nextPhysicalCount - prevPhysicalCount;
+      if (delta <= 0) {
+        return;
+      }
+      [].push.apply(this._physicalItems, this._createPool(delta));
+      [].push.apply(this._physicalSizes, new Array(delta));
+      this._physicalCount = prevPhysicalCount + delta;
+      if (this._physicalStart > this._physicalEnd && this._isIndexRendered(this._focusedIndex) && this._getPhysicalIndex(this._focusedIndex) < this._physicalEnd) {
+        this._physicalStart = this._physicalStart + delta;
+      }
+      this._update();
+    },
+    _render: function() {
+      var requiresUpdate = this._virtualCount > 0 || this._physicalCount > 0;
+      if (this.isAttached && !this._itemsRendered && this._isVisible && requiresUpdate) {
+        this._lastPage = 0;
+        this._update();
+        this._itemsRendered = true;
+      }
+    },
+    _ensureTemplatized: function() {
+      if (!this.ctor) {
+        var props = {};
+        props.__key__ = true;
+        props[this.as] = true;
+        props[this.indexAs] = true;
+        props[this.selectedAs] = true;
+        props.tabIndex = true;
+        this._instanceProps = props;
+        this._userTemplate = Polymer.dom(this).querySelector('template');
+        if (this._userTemplate) {
+          this.templatize(this._userTemplate);
+        } else {
+          console.warn('iron-list requires a template to be provided in light-dom');
+        }
+      }
+    },
+    _getStampedChildren: function() {
+      return this._physicalItems;
+    },
+    _forwardInstancePath: function(inst, path, value) {
+      if (path.indexOf(this.as + '.') === 0) {
+        this.notifyPath('items.' + inst.__key__ + '.' + path.slice(this.as.length + 1), value);
+      }
+    },
+    _forwardParentProp: function(prop, value) {
+      if (this._physicalItems) {
+        this._physicalItems.forEach(function(item) {
+          item._templateInstance[prop] = value;
+        }, this);
+      }
+    },
+    _forwardParentPath: function(path, value) {
+      if (this._physicalItems) {
+        this._physicalItems.forEach(function(item) {
+          item._templateInstance.notifyPath(path, value, true);
+        }, this);
+      }
+    },
+    _forwardItemPath: function(path, value) {
+      if (!this._physicalIndexForKey) {
+        return;
+      }
+      var dot = path.indexOf('.');
+      var key = path.substring(0, dot < 0 ? path.length : dot);
+      var idx = this._physicalIndexForKey[key];
+      var offscreenItem = this._offscreenFocusedItem;
+      var el = offscreenItem && offscreenItem._templateInstance.__key__ === key ? offscreenItem : this._physicalItems[idx];
+      if (!el || el._templateInstance.__key__ !== key) {
+        return;
+      }
+      if (dot >= 0) {
+        path = this.as + '.' + path.substring(dot + 1);
+        el._templateInstance.notifyPath(path, value, true);
+      } else {
+        var currentItem = el._templateInstance[this.as];
+        if (Array.isArray(this.selectedItems)) {
+          for (var i = 0; i < this.selectedItems.length; i++) {
+            if (this.selectedItems[i] === currentItem) {
+              this.set('selectedItems.' + i, value);
+              break;
+            }
+          }
+        } else if (this.selectedItem === currentItem) {
+          this.set('selectedItem', value);
+        }
+        el._templateInstance[this.as] = value;
+      }
+    },
+    _itemsChanged: function(change) {
+      if (change.path === 'items') {
+        this._virtualStart = 0;
+        this._physicalTop = 0;
+        this._virtualCount = this.items ? this.items.length : 0;
+        this._collection = this.items ? Polymer.Collection.get(this.items) : null;
+        this._physicalIndexForKey = {};
+        this._firstVisibleIndexVal = null;
+        this._lastVisibleIndexVal = null;
+        this._resetScrollPosition(0);
+        this._removeFocusedItem();
+        if (!this._physicalItems) {
+          this._physicalCount = Math.max(1, Math.min(DEFAULT_PHYSICAL_COUNT, this._virtualCount));
+          this._physicalItems = this._createPool(this._physicalCount);
+          this._physicalSizes = new Array(this._physicalCount);
+        }
+        this._physicalStart = 0;
+      } else if (change.path === 'items.splices') {
+        this._adjustVirtualIndex(change.value.indexSplices);
+        this._virtualCount = this.items ? this.items.length : 0;
+      } else {
+        this._forwardItemPath(change.path.split('.').slice(1).join('.'), change.value);
+        return;
+      }
+      this._itemsRendered = false;
+      this._debounceTemplate(this._render);
+    },
+    _adjustVirtualIndex: function(splices) {
+      splices.forEach(function(splice) {
+        splice.removed.forEach(this._removeItem, this);
+        if (splice.index < this._virtualStart) {
+          var delta = Math.max(splice.addedCount - splice.removed.length, splice.index - this._virtualStart);
+          this._virtualStart = this._virtualStart + delta;
+          if (this._focusedIndex >= 0) {
+            this._focusedIndex = this._focusedIndex + delta;
+          }
+        }
+      }, this);
+    },
+    _removeItem: function(item) {
+      this.$.selector.deselect(item);
+      if (this._focusedItem && this._focusedItem._templateInstance[this.as] === item) {
+        this._removeFocusedItem();
+      }
+    },
+    _iterateItems: function(fn, itemSet) {
+      var pidx, vidx, rtn, i;
+      if (arguments.length === 2 && itemSet) {
+        for (i = 0; i < itemSet.length; i++) {
+          pidx = itemSet[i];
+          vidx = this._computeVidx(pidx);
+          if ((rtn = fn.call(this, pidx, vidx)) != null) {
+            return rtn;
+          }
+        }
+      } else {
+        pidx = this._physicalStart;
+        vidx = this._virtualStart;
+        for (;pidx < this._physicalCount; pidx++, vidx++) {
+          if ((rtn = fn.call(this, pidx, vidx)) != null) {
+            return rtn;
+          }
+        }
+        for (pidx = 0; pidx < this._physicalStart; pidx++, vidx++) {
+          if ((rtn = fn.call(this, pidx, vidx)) != null) {
+            return rtn;
+          }
+        }
+      }
+    },
+    _computeVidx: function(pidx) {
+      if (pidx >= this._physicalStart) {
+        return this._virtualStart + (pidx - this._physicalStart);
+      }
+      return this._virtualStart + (this._physicalCount - this._physicalStart) + pidx;
+    },
+    _assignModels: function(itemSet) {
+      this._iterateItems(function(pidx, vidx) {
+        var el = this._physicalItems[pidx];
+        var inst = el._templateInstance;
+        var item = this.items && this.items[vidx];
+        if (item != null) {
+          inst[this.as] = item;
+          inst.__key__ = this._collection.getKey(item);
+          inst[this.selectedAs] = this.$.selector.isSelected(item);
+          inst[this.indexAs] = vidx;
+          inst.tabIndex = this._focusedIndex === vidx ? 0 : -1;
+          this._physicalIndexForKey[inst.__key__] = pidx;
+          el.removeAttribute('hidden');
+        } else {
+          inst.__key__ = null;
+          el.setAttribute('hidden', '');
+        }
+      }, itemSet);
+    },
+    _updateMetrics: function(itemSet) {
+      Polymer.dom.flush();
+      var newPhysicalSize = 0;
+      var oldPhysicalSize = 0;
+      var prevAvgCount = this._physicalAverageCount;
+      var prevPhysicalAvg = this._physicalAverage;
+      this._iterateItems(function(pidx, vidx) {
+        oldPhysicalSize += this._physicalSizes[pidx] || 0;
+        this._physicalSizes[pidx] = this._physicalItems[pidx].offsetHeight;
+        newPhysicalSize += this._physicalSizes[pidx];
+        this._physicalAverageCount += this._physicalSizes[pidx] ? 1 : 0;
+      }, itemSet);
+      this._viewportHeight = this._scrollTargetHeight;
+      if (this.grid) {
+        this._updateGridMetrics();
+        this._physicalSize = Math.ceil(this._physicalCount / this._itemsPerRow) * this._rowHeight;
+      } else {
+        this._physicalSize = this._physicalSize + newPhysicalSize - oldPhysicalSize;
+      }
+      if (this._physicalAverageCount !== prevAvgCount) {
+        this._physicalAverage = Math.round((prevPhysicalAvg * prevAvgCount + newPhysicalSize) / this._physicalAverageCount);
+      }
+    },
+    _updateGridMetrics: function() {
+      this._viewportWidth = this.$.items.offsetWidth;
+      this._itemWidth = this._physicalCount > 0 ? this._physicalItems[0].getBoundingClientRect().width : DEFAULT_GRID_SIZE;
+      this._rowHeight = this._physicalCount > 0 ? this._physicalItems[0].offsetHeight : DEFAULT_GRID_SIZE;
+      this._itemsPerRow = this._itemWidth ? Math.floor(this._viewportWidth / this._itemWidth) : this._itemsPerRow;
+    },
+    _positionItems: function() {
+      this._adjustScrollPosition();
+      var y = this._physicalTop;
+      if (this.grid) {
+        var totalItemWidth = this._itemsPerRow * this._itemWidth;
+        var rowOffset = (this._viewportWidth - totalItemWidth) / 2;
+        this._iterateItems(function(pidx, vidx) {
+          var modulus = vidx % this._itemsPerRow;
+          var x = Math.floor(modulus * this._itemWidth + rowOffset);
+          this.translate3d(x + 'px', y + 'px', 0, this._physicalItems[pidx]);
+          if (this._shouldRenderNextRow(vidx)) {
+            y += this._rowHeight;
+          }
+        });
+      } else {
+        this._iterateItems(function(pidx, vidx) {
+          this.translate3d(0, y + 'px', 0, this._physicalItems[pidx]);
+          y += this._physicalSizes[pidx];
+        });
+      }
+    },
+    _getPhysicalSizeIncrement: function(pidx) {
+      if (!this.grid) {
+        return this._physicalSizes[pidx];
+      }
+      if (this._computeVidx(pidx) % this._itemsPerRow !== this._itemsPerRow - 1) {
+        return 0;
+      }
+      return this._rowHeight;
+    },
+    _shouldRenderNextRow: function(vidx) {
+      return vidx % this._itemsPerRow === this._itemsPerRow - 1;
+    },
+    _adjustScrollPosition: function() {
+      var deltaHeight = this._virtualStart === 0 ? this._physicalTop : Math.min(this._scrollPosition + this._physicalTop, 0);
+      if (deltaHeight) {
+        this._physicalTop = this._physicalTop - deltaHeight;
+        if (!IOS_TOUCH_SCROLLING && this._physicalTop !== 0) {
+          this._resetScrollPosition(this._scrollTop - deltaHeight);
+        }
+      }
+    },
+    _resetScrollPosition: function(pos) {
+      if (this.scrollTarget) {
+        this._scrollTop = pos;
+        this._scrollPosition = this._scrollTop;
+      }
+    },
+    _updateScrollerSize: function(forceUpdate) {
+      if (this.grid) {
+        this._estScrollHeight = this._virtualRowCount * this._rowHeight;
+      } else {
+        this._estScrollHeight = this._physicalBottom + Math.max(this._virtualCount - this._physicalCount - this._virtualStart, 0) * this._physicalAverage;
+      }
+      forceUpdate = forceUpdate || this._scrollHeight === 0;
+      forceUpdate = forceUpdate || this._scrollPosition >= this._estScrollHeight - this._physicalSize;
+      forceUpdate = forceUpdate || this.grid && this.$.items.style.height < this._estScrollHeight;
+      if (forceUpdate || Math.abs(this._estScrollHeight - this._scrollHeight) >= this._optPhysicalSize) {
+        this.$.items.style.height = this._estScrollHeight + 'px';
+        this._scrollHeight = this._estScrollHeight;
+      }
+    },
+    scrollToItem: function(item) {
+      return this.scrollToIndex(this.items.indexOf(item));
+    },
+    scrollToIndex: function(idx) {
+      if (typeof idx !== 'number' || idx < 0 || idx > this.items.length - 1) {
+        return;
+      }
+      Polymer.dom.flush();
+      idx = Math.min(Math.max(idx, 0), this._virtualCount - 1);
+      if (!this._isIndexRendered(idx) || idx >= this._maxVirtualStart) {
+        this._virtualStart = this.grid ? idx - this._itemsPerRow * 2 : idx - 1;
+      }
+      this._manageFocus();
+      this._assignModels();
+      this._updateMetrics();
+      var estPhysicalTop = Math.floor(this._virtualStart / this._itemsPerRow) * this._physicalAverage;
+      this._physicalTop = estPhysicalTop;
+      var currentTopItem = this._physicalStart;
+      var currentVirtualItem = this._virtualStart;
+      var targetOffsetTop = 0;
+      var hiddenContentSize = this._hiddenContentSize;
+      while (currentVirtualItem < idx && targetOffsetTop <= hiddenContentSize) {
+        targetOffsetTop = targetOffsetTop + this._getPhysicalSizeIncrement(currentTopItem);
+        currentTopItem = (currentTopItem + 1) % this._physicalCount;
+        currentVirtualItem++;
+      }
+      this._updateScrollerSize(true);
+      this._positionItems();
+      this._resetScrollPosition(this._physicalTop + this._scrollerPaddingTop + targetOffsetTop);
+      this._increasePoolIfNeeded();
+      this._firstVisibleIndexVal = null;
+      this._lastVisibleIndexVal = null;
+    },
+    _resetAverage: function() {
+      this._physicalAverage = 0;
+      this._physicalAverageCount = 0;
+    },
+    _resizeHandler: function() {
+      if (IOS && Math.abs(this._viewportHeight - this._scrollTargetHeight) < 100) {
+        return;
+      }
+      Polymer.dom.addDebouncer(this.debounce('_debounceTemplate', function() {
+        this.updateViewportBoundaries();
+        this._render();
+        if (this._itemsRendered && this._physicalItems && this._isVisible) {
+          this._resetAverage();
+          this.scrollToIndex(this.firstVisibleIndex);
+        }
+      }.bind(this), 1));
+    },
+    _getModelFromItem: function(item) {
+      var key = this._collection.getKey(item);
+      var pidx = this._physicalIndexForKey[key];
+      if (pidx != null) {
+        return this._physicalItems[pidx]._templateInstance;
+      }
+      return null;
+    },
+    _getNormalizedItem: function(item) {
+      if (this._collection.getKey(item) === undefined) {
+        if (typeof item === 'number') {
+          item = this.items[item];
+          if (!item) {
+            throw new RangeError('<item> not found');
+          }
+          return item;
+        }
+        throw new TypeError('<item> should be a valid item');
+      }
+      return item;
+    },
+    selectItem: function(item) {
+      item = this._getNormalizedItem(item);
+      var model = this._getModelFromItem(item);
+      if (!this.multiSelection && this.selectedItem) {
+        this.deselectItem(this.selectedItem);
+      }
+      if (model) {
+        model[this.selectedAs] = true;
+      }
+      this.$.selector.select(item);
+      this.updateSizeForItem(item);
+    },
+    deselectItem: function(item) {
+      item = this._getNormalizedItem(item);
+      var model = this._getModelFromItem(item);
+      if (model) {
+        model[this.selectedAs] = false;
+      }
+      this.$.selector.deselect(item);
+      this.updateSizeForItem(item);
+    },
+    toggleSelectionForItem: function(item) {
+      item = this._getNormalizedItem(item);
+      if (this.$.selector.isSelected(item)) {
+        this.deselectItem(item);
+      } else {
+        this.selectItem(item);
+      }
+    },
+    clearSelection: function() {
+      function unselect(item) {
+        var model = this._getModelFromItem(item);
+        if (model) {
+          model[this.selectedAs] = false;
+        }
+      }
+      if (Array.isArray(this.selectedItems)) {
+        this.selectedItems.forEach(unselect, this);
+      } else if (this.selectedItem) {
+        unselect.call(this, this.selectedItem);
+      }
+      this.$.selector.clearSelection();
+    },
+    _selectionEnabledChanged: function(selectionEnabled) {
+      var handler = selectionEnabled ? this.listen : this.unlisten;
+      handler.call(this, this, 'tap', '_selectionHandler');
+    },
+    _selectionHandler: function(e) {
+      var model = this.modelForElement(e.target);
+      if (!model) {
+        return;
+      }
+      var modelTabIndex, activeElTabIndex;
+      var target = Polymer.dom(e).path[0];
+      var activeEl = Polymer.dom(this.domHost ? this.domHost.root : document).activeElement;
+      var physicalItem = this._physicalItems[this._getPhysicalIndex(model[this.indexAs])];
+      if (target.localName === 'input' || target.localName === 'button' || target.localName === 'select') {
+        return;
+      }
+      modelTabIndex = model.tabIndex;
+      model.tabIndex = SECRET_TABINDEX;
+      activeElTabIndex = activeEl ? activeEl.tabIndex : -1;
+      model.tabIndex = modelTabIndex;
+      if (activeEl && physicalItem.contains(activeEl) && activeElTabIndex !== SECRET_TABINDEX) {
+        return;
+      }
+      this.toggleSelectionForItem(model[this.as]);
+    },
+    _multiSelectionChanged: function(multiSelection) {
+      this.clearSelection();
+      this.$.selector.multi = multiSelection;
+    },
+    updateSizeForItem: function(item) {
+      item = this._getNormalizedItem(item);
+      var key = this._collection.getKey(item);
+      var pidx = this._physicalIndexForKey[key];
+      if (pidx != null) {
+        this._updateMetrics([ pidx ]);
+        this._positionItems();
+      }
+    },
+    _manageFocus: function() {
+      var fidx = this._focusedIndex;
+      if (fidx >= 0 && fidx < this._virtualCount) {
+        if (this._isIndexRendered(fidx)) {
+          this._restoreFocusedItem();
+        } else {
+          this._createFocusBackfillItem();
+        }
+      } else if (this._virtualCount > 0 && this._physicalCount > 0) {
+        this._focusedIndex = this._virtualStart;
+        this._focusedItem = this._physicalItems[this._physicalStart];
+      }
+    },
+    _isIndexRendered: function(idx) {
+      return idx >= this._virtualStart && idx <= this._virtualEnd;
+    },
+    _isIndexVisible: function(idx) {
+      return idx >= this.firstVisibleIndex && idx <= this.lastVisibleIndex;
+    },
+    _getPhysicalIndex: function(idx) {
+      return this._physicalIndexForKey[this._collection.getKey(this._getNormalizedItem(idx))];
+    },
+    _focusPhysicalItem: function(idx) {
+      if (idx < 0 || idx >= this._virtualCount) {
+        return;
+      }
+      this._restoreFocusedItem();
+      if (!this._isIndexRendered(idx)) {
+        this.scrollToIndex(idx);
+      }
+      var physicalItem = this._physicalItems[this._getPhysicalIndex(idx)];
+      var model = physicalItem._templateInstance;
+      var focusable;
+      model.tabIndex = SECRET_TABINDEX;
+      if (physicalItem.tabIndex === SECRET_TABINDEX) {
+        focusable = physicalItem;
+      }
+      if (!focusable) {
+        focusable = Polymer.dom(physicalItem).querySelector('[tabindex="' + SECRET_TABINDEX + '"]');
+      }
+      model.tabIndex = 0;
+      this._focusedIndex = idx;
+      focusable && focusable.focus();
+    },
+    _removeFocusedItem: function() {
+      if (this._offscreenFocusedItem) {
+        Polymer.dom(this).removeChild(this._offscreenFocusedItem);
+      }
+      this._offscreenFocusedItem = null;
+      this._focusBackfillItem = null;
+      this._focusedItem = null;
+      this._focusedIndex = -1;
+    },
+    _createFocusBackfillItem: function() {
+      var pidx, fidx = this._focusedIndex;
+      if (this._offscreenFocusedItem || fidx < 0) {
+        return;
+      }
+      if (!this._focusBackfillItem) {
+        var stampedTemplate = this.stamp(null);
+        this._focusBackfillItem = stampedTemplate.root.querySelector('*');
+        Polymer.dom(this).appendChild(stampedTemplate.root);
+      }
+      pidx = this._getPhysicalIndex(fidx);
+      if (pidx != null) {
+        this._offscreenFocusedItem = this._physicalItems[pidx];
+        this._physicalItems[pidx] = this._focusBackfillItem;
+        this.translate3d(0, HIDDEN_Y, 0, this._offscreenFocusedItem);
+      }
+    },
+    _restoreFocusedItem: function() {
+      var pidx, fidx = this._focusedIndex;
+      if (!this._offscreenFocusedItem || this._focusedIndex < 0) {
+        return;
+      }
+      this._assignModels();
+      pidx = this._getPhysicalIndex(fidx);
+      if (pidx != null) {
+        this._focusBackfillItem = this._physicalItems[pidx];
+        this._physicalItems[pidx] = this._offscreenFocusedItem;
+        this._offscreenFocusedItem = null;
+        this.translate3d(0, HIDDEN_Y, 0, this._focusBackfillItem);
+      }
+    },
+    _didFocus: function(e) {
+      var targetModel = this.modelForElement(e.target);
+      var focusedModel = this._focusedItem ? this._focusedItem._templateInstance : null;
+      var hasOffscreenFocusedItem = this._offscreenFocusedItem !== null;
+      var fidx = this._focusedIndex;
+      if (!targetModel || !focusedModel) {
+        return;
+      }
+      if (focusedModel === targetModel) {
+        if (!this._isIndexVisible(fidx)) {
+          this.scrollToIndex(fidx);
+        }
+      } else {
+        this._restoreFocusedItem();
+        focusedModel.tabIndex = -1;
+        targetModel.tabIndex = 0;
+        fidx = targetModel[this.indexAs];
+        this._focusedIndex = fidx;
+        this._focusedItem = this._physicalItems[this._getPhysicalIndex(fidx)];
+        if (hasOffscreenFocusedItem && !this._offscreenFocusedItem) {
+          this._update();
+        }
+      }
+    },
+    _didMoveUp: function() {
+      this._focusPhysicalItem(this._focusedIndex - 1);
+    },
+    _didMoveDown: function(e) {
+      e.detail.keyboardEvent.preventDefault();
+      this._focusPhysicalItem(this._focusedIndex + 1);
+    },
+    _didEnter: function(e) {
+      this._focusPhysicalItem(this._focusedIndex);
+      this._selectionHandler(e.detail.keyboardEvent);
+    }
+  });
+})();
+
+Polymer({
+  is: 'iron-scroll-threshold',
+  properties: {
+    upperThreshold: {
+      type: Number,
+      value: 100
+    },
+    lowerThreshold: {
+      type: Number,
+      value: 100
+    },
+    upperTriggered: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      readOnly: true
+    },
+    lowerTriggered: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      readOnly: true
+    },
+    horizontal: {
+      type: Boolean,
+      value: false
+    }
+  },
+  behaviors: [ Polymer.IronScrollTargetBehavior ],
+  observers: [ '_setOverflow(scrollTarget)', '_initCheck(horizontal, isAttached)' ],
+  get _defaultScrollTarget() {
+    return this;
+  },
+  _setOverflow: function(scrollTarget) {
+    this.style.overflow = scrollTarget === this ? 'auto' : '';
+  },
+  _scrollHandler: function() {
+    var THROTTLE_THRESHOLD = 200;
+    if (!this.isDebouncerActive('_checkTheshold')) {
+      this.debounce('_checkTheshold', function() {
+        this.checkScrollThesholds();
+      }, THROTTLE_THRESHOLD);
+    }
+  },
+  _initCheck: function(horizontal, isAttached) {
+    if (isAttached) {
+      this.debounce('_init', function() {
+        this.clearTriggers();
+        this.checkScrollThesholds();
+      });
+    }
+  },
+  checkScrollThesholds: function() {
+    if (!this.scrollTarget || this.lowerTriggered && this.upperTriggered) {
+      return;
+    }
+    var upperScrollValue = this.horizontal ? this._scrollLeft : this._scrollTop;
+    var lowerScrollValue = this.horizontal ? this.scrollTarget.scrollWidth - this._scrollTargetWidth - this._scrollLeft : this.scrollTarget.scrollHeight - this._scrollTargetHeight - this._scrollTop;
+    if (upperScrollValue <= this.upperThreshold && !this.upperTriggered) {
+      this._setUpperTriggered(true);
+      this.fire('upper-threshold');
+    }
+    if (lowerScrollValue <= this.lowerThreshold && !this.lowerTriggered) {
+      this._setLowerTriggered(true);
+      this.fire('lower-threshold');
+    }
+  },
+  clearTriggers: function() {
+    this._setUpperTriggered(false);
+    this._setLowerTriggered(false);
+  }
+});
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-list',
+  behaviors: [ HistoryListBehavior ],
+  properties: {
+    searchedTerm: {
+      type: String,
+      value: ''
+    },
+    lastSearchedTerm_: String,
+    querying: Boolean,
+    historyData_: Array,
+    resultLoadingDisabled_: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    'infinite-list.scroll': 'notifyListScroll_',
+    'remove-bookmark-stars': 'removeBookmarkStars_'
+  },
+  attached: function() {
+    this.$['infinite-list'].notifyResize();
+  },
+  removeBookmarkStars_: function(e) {
+    var url = e.detail;
+    if (this.historyData_ === undefined) return;
+    for (var i = 0; i < this.historyData_.length; i++) {
+      if (this.historyData_[i].url == url) this.set('historyData_.' + i + '.starred', false);
+    }
+  },
+  disableResultLoading: function() {
+    this.resultLoadingDisabled_ = true;
+  },
+  addNewResults: function(historyResults) {
+    var results = historyResults.slice();
+    this.$['scroll-threshold'].clearTriggers();
+    if (this.lastSearchedTerm_ != this.searchedTerm) {
+      this.resultLoadingDisabled_ = false;
+      if (this.historyData_) this.splice('historyData_', 0, this.historyData_.length);
+      this.fire('unselect-all');
+      this.lastSearchedTerm_ = this.searchedTerm;
+    }
+    if (this.historyData_) {
+      results.unshift('historyData_');
+      this.push.apply(this, results);
+    } else {
+      this.set('historyData_', results);
+    }
+  },
+  loadMoreData_: function() {
+    if (this.resultLoadingDisabled_ || this.querying) return;
+    this.fire('load-more-history');
+  },
+  needsTimeGap_: function(item, index, length) {
+    return md_history.HistoryItem.needsTimeGap(this.historyData_, index, this.searchedTerm);
+  },
+  isCardStart_: function(item, i, length) {
+    if (length == 0 || i > length - 1) return false;
+    return i == 0 || this.historyData_[i].dateRelativeDay != this.historyData_[i - 1].dateRelativeDay;
+  },
+  isCardEnd_: function(item, i, length) {
+    if (length == 0 || i > length - 1) return false;
+    return i == length - 1 || this.historyData_[i].dateRelativeDay != this.historyData_[i + 1].dateRelativeDay;
+  },
+  isFirstItem_: function(index) {
+    return index == 0;
+  },
+  notifyListScroll_: function() {
+    this.fire('history-list-scrolled');
+  },
+  pathForItem_: function(index) {
+    return 'historyData_.' + index;
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-list-container',
+  properties: {
+    selectedPage_: String,
+    grouped: Boolean,
+    queryState: Object,
+    queryResult: Object
+  },
+  observers: [ 'groupedRangeChanged_(queryState.range)' ],
+  listeners: {
+    'history-list-scrolled': 'closeMenu_',
+    'load-more-history': 'loadMoreHistory_',
+    'toggle-menu': 'toggleMenu_'
+  },
+  historyResult: function(info, results) {
+    this.initializeResults_(info, results);
+    this.closeMenu_();
+    if (this.selectedPage_ == 'grouped-list') {
+      this.$$('#grouped-list').historyData = results;
+      return;
+    }
+    var list = this.$['infinite-list'];
+    list.addNewResults(results);
+    if (info.finished) list.disableResultLoading();
+  },
+  queryHistory: function(incremental) {
+    var queryState = this.queryState;
+    var noResults = !this.queryResult || this.queryResult.results == null;
+    if (queryState.queryingDisabled || !this.queryState.searchTerm && noResults) {
+      return;
+    }
+    if (!incremental && this.$.dialog.open) this.$.dialog.close();
+    this.set('queryState.querying', true);
+    this.set('queryState.incremental', incremental);
+    var lastVisitTime = 0;
+    if (incremental) {
+      var lastVisit = this.queryResult.results.slice(-1)[0];
+      lastVisitTime = lastVisit ? lastVisit.time : 0;
+    }
+    var maxResults = queryState.range == HistoryRange.ALL_TIME ? RESULTS_PER_PAGE : 0;
+    chrome.send('queryHistory', [ queryState.searchTerm, queryState.groupedOffset, queryState.range, lastVisitTime, maxResults ]);
+  },
+  unselectAllItems: function(count) {
+    this.getSelectedList_().unselectAllItems(count);
+  },
+  deleteSelectedWithPrompt: function() {
+    if (!loadTimeData.getBoolean('allowDeletingHistory')) return;
+    this.$.dialog.showModal();
+  },
+  groupedRangeChanged_: function(range) {
+    this.selectedPage_ = this.queryState.range == HistoryRange.ALL_TIME ? 'infinite-list' : 'grouped-list';
+    this.queryHistory(false);
+  },
+  loadMoreHistory_: function() {
+    this.queryHistory(true);
+  },
+  initializeResults_: function(info, results) {
+    if (results.length == 0) return;
+    var currentDate = results[0].dateRelativeDay;
+    for (var i = 0; i < results.length; i++) {
+      results[i].selected = false;
+      results[i].readableTimestamp = info.term == '' ? results[i].dateTimeOfDay : results[i].dateShort;
+      if (results[i].dateRelativeDay != currentDate) {
+        currentDate = results[i].dateRelativeDay;
+      }
+    }
+  },
+  onDialogConfirmTap_: function() {
+    this.getSelectedList_().deleteSelected();
+    this.$.dialog.close();
+  },
+  onDialogCancelTap_: function() {
+    this.$.dialog.close();
+  },
+  closeMenu_: function() {
+    this.$.sharedMenu.closeMenu();
+  },
+  toggleMenu_: function(e) {
+    var target = e.detail.target;
+    this.$.sharedMenu.toggleMenu(target, e.detail.item);
+  },
+  onMoreFromSiteTap_: function() {
+    var menu = this.$.sharedMenu;
+    this.fire('search-domain', {
+      domain: menu.itemData.domain
+    });
+    menu.closeMenu();
+  },
+  onRemoveFromHistoryTap_: function() {
+    var menu = this.$.sharedMenu;
+    md_history.BrowserService.getInstance().deleteItems([ menu.itemData ]).then(function(items) {
+      this.getSelectedList_().removeItemsByPath(items[0].path);
+      this.fire('unselect-all');
+    }.bind(this));
+    menu.closeMenu();
+  },
+  getSelectedList_: function() {
+    return this.$.content.selectedItem;
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-synced-device-card',
+  properties: {
+    device: String,
+    lastUpdateTime: String,
+    tabs: {
+      type: Array,
+      value: function() {
+        return [];
+      },
+      observer: 'updateIcons_'
+    },
+    separatorIndexes: Array,
+    cardOpen_: {
+      type: Boolean,
+      value: true
+    },
+    searchTerm: String,
+    sessionTag: String
+  },
+  openTab_: function(e) {
+    var tab = e.model.tab;
+    md_history.BrowserService.getInstance().openForeignSessionTab(this.sessionTag, tab.windowId, tab.sessionId, e);
+    e.preventDefault();
+  },
+  toggleTabCard: function() {
+    this.$.collapse.toggle();
+    this.$['dropdown-indicator'].icon = this.$.collapse.opened ? 'cr:expand-less' : 'cr:expand-more';
+  },
+  updateIcons_: function() {
+    this.async(function() {
+      var icons = Polymer.dom(this.root).querySelectorAll('.website-icon');
+      for (var i = 0; i < this.tabs.length; i++) {
+        icons[i].style.backgroundImage = cr.icon.getFaviconImageSet(this.tabs[i].url);
+      }
+    });
+  },
+  isWindowSeparatorIndex_: function(index, separatorIndexes) {
+    return this.separatorIndexes.indexOf(index) != -1;
+  },
+  getCollapseTitle_: function(cardOpen) {
+    return cardOpen ? loadTimeData.getString('collapseSessionButton') : loadTimeData.getString('expandSessionButton');
+  },
+  onMenuButtonTap_: function(e) {
+    this.fire('toggle-menu', {
+      target: Polymer.dom(e).localTarget,
+      tag: this.sessionTag
+    });
+    e.stopPropagation();
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var ForeignDeviceInternal;
+
+Polymer({
+  is: 'history-synced-device-manager',
+  properties: {
+    sessionList: {
+      type: Array,
+      observer: 'updateSyncedDevices'
+    },
+    searchTerm: {
+      type: String,
+      observer: 'searchTermChanged'
+    },
+    syncedDevices_: {
+      type: Array,
+      value: function() {
+        return [];
+      }
+    },
+    signInState_: {
+      type: Boolean,
+      value: loadTimeData.getBoolean('isUserSignedIn')
+    },
+    guestSession_: {
+      type: Boolean,
+      value: loadTimeData.getBoolean('isGuestSession')
+    },
+    fetchingSyncedTabs_: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    'toggle-menu': 'onToggleMenu_'
+  },
+  attached: function() {
+    chrome.send('otherDevicesInitialized');
+  },
+  createInternalDevice_: function(session) {
+    var tabs = [];
+    var separatorIndexes = [];
+    for (var i = 0; i < session.windows.length; i++) {
+      var windowId = session.windows[i].sessionId;
+      var newTabs = session.windows[i].tabs;
+      if (newTabs.length == 0) continue;
+      newTabs.forEach(function(tab) {
+        tab.windowId = windowId;
+      });
+      var windowAdded = false;
+      if (!this.searchTerm) {
+        tabs = tabs.concat(newTabs);
+        windowAdded = true;
+      } else {
+        var searchText = this.searchTerm.toLowerCase();
+        for (var j = 0; j < newTabs.length; j++) {
+          var tab = newTabs[j];
+          if (tab.title.toLowerCase().indexOf(searchText) != -1) {
+            tabs.push(tab);
+            windowAdded = true;
+          }
+        }
+      }
+      if (windowAdded && i != session.windows.length - 1) separatorIndexes.push(tabs.length - 1);
+    }
+    return {
+      device: session.name,
+      lastUpdateTime: '– ' + session.modifiedTime,
+      separatorIndexes: separatorIndexes,
+      timestamp: session.timestamp,
+      tabs: tabs,
+      tag: session.tag
+    };
+  },
+  onSignInTap_: function() {
+    chrome.send('SyncSetupShowSetupUI');
+    chrome.send('SyncSetupStartSignIn', [ false ]);
+  },
+  onToggleMenu_: function(e) {
+    this.$.menu.toggleMenu(e.detail.target, e.detail.tag);
+  },
+  onOpenAllTap_: function() {
+    md_history.BrowserService.getInstance().openForeignSessionAllTabs(this.$.menu.itemData);
+    this.$.menu.closeMenu();
+  },
+  onDeleteSessionTap_: function() {
+    md_history.BrowserService.getInstance().deleteForeignSession(this.$.menu.itemData);
+    this.$.menu.closeMenu();
+  },
+  clearDisplayedSyncedDevices_: function() {
+    this.syncedDevices_ = [];
+  },
+  showNoSyncedMessage: function(signInState, syncedDevicesLength, guestSession) {
+    if (guestSession) return true;
+    return signInState && syncedDevicesLength == 0;
+  },
+  showSignInGuide: function(signInState, guestSession) {
+    return !signInState && !guestSession;
+  },
+  noSyncedTabsMessage: function(fetchingSyncedTabs) {
+    return loadTimeData.getString(fetchingSyncedTabs ? 'loading' : 'noSyncedResults');
+  },
+  updateSyncedDevices: function(sessionList) {
+    this.fetchingSyncedTabs_ = false;
+    if (!sessionList) return;
+    var updateCount = Math.min(sessionList.length, this.syncedDevices_.length);
+    for (var i = 0; i < updateCount; i++) {
+      var oldDevice = this.syncedDevices_[i];
+      if (oldDevice.tag != sessionList[i].tag || oldDevice.timestamp != sessionList[i].timestamp) {
+        this.splice('syncedDevices_', i, 1, this.createInternalDevice_(sessionList[i]));
+      }
+    }
+    for (var i = updateCount; i < sessionList.length; i++) {
+      this.push('syncedDevices_', this.createInternalDevice_(sessionList[i]));
+    }
+  },
+  updateSignInState: function(isUserSignedIn) {
+    if (this.signInState_ == isUserSignedIn) return;
+    this.signInState_ = isUserSignedIn;
+    if (!isUserSignedIn) {
+      this.clearDisplayedSyncedDevices_();
+      return;
+    }
+    this.fetchingSyncedTabs_ = true;
+  },
+  searchTermChanged: function(searchTerm) {
+    this.clearDisplayedSyncedDevices_();
+    this.updateSyncedDevices(this.sessionList);
+  }
+});
+
+Polymer({
+  is: 'iron-selector',
+  behaviors: [ Polymer.IronMultiSelectableBehavior ]
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-side-bar',
+  properties: {
+    selectedPage: {
+      type: String,
+      notify: true
+    },
+    route: Object,
+    showFooter: Boolean,
+    drawer: {
+      type: Boolean,
+      reflectToAttribute: true
+    }
+  },
+  onSelectorActivate_: function() {
+    this.fire('history-close-drawer');
+  },
+  onClearBrowsingDataTap_: function(e) {
+    md_history.BrowserService.getInstance().openClearBrowsingData();
+    e.preventDefault();
+  },
+  getQueryString_: function(route) {
+    return window.location.search;
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-app',
+  properties: {
+    showSidebarFooter: Boolean,
+    selectedPage_: {
+      type: String,
+      value: 'history',
+      observer: 'unselectAll'
+    },
+    grouped_: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    queryState_: {
+      type: Object,
+      value: function() {
+        return {
+          incremental: false,
+          querying: true,
+          queryingDisabled: false,
+          _range: HistoryRange.ALL_TIME,
+          searchTerm: '',
+          groupedOffset: 0,
+          set range(val) {
+            this._range = Number(val);
+          },
+          get range() {
+            return this._range;
+          }
+        };
+      }
+    },
+    queryResult_: {
+      type: Object,
+      value: function() {
+        return {
+          info: null,
+          results: null,
+          sessionList: null
+        };
+      }
+    },
+    routeData_: Object,
+    queryParams_: Object,
+    hasDrawer_: Boolean
+  },
+  observers: [ 'routeDataChanged_(routeData_.page)', 'selectedPageChanged_(selectedPage_)', 'searchTermChanged_(queryState_.searchTerm)', 'searchQueryParamChanged_(queryParams_.q)' ],
+  listeners: {
+    'cr-menu-tap': 'onMenuTap_',
+    'history-checkbox-select': 'checkboxSelected',
+    'unselect-all': 'unselectAll',
+    'delete-selected': 'deleteSelected',
+    'search-domain': 'searchDomain_',
+    'history-close-drawer': 'closeDrawer_'
+  },
+  ready: function() {
+    this.grouped_ = loadTimeData.getBoolean('groupByDomain');
+    cr.ui.decorate('command', cr.ui.Command);
+    document.addEventListener('canExecute', this.onCanExecute_.bind(this));
+    document.addEventListener('command', this.onCommand_.bind(this));
+    if (window.location.hash) {
+      window.location.href = window.location.href.split('#')[0] + '?' + window.location.hash.substr(1);
+    }
+  },
+  onMenuTap_: function() {
+    var drawer = this.$$('#drawer');
+    if (drawer) drawer.toggle();
+  },
+  checkboxSelected: function(e) {
+    var toolbar = this.$.toolbar;
+    toolbar.count += e.detail.countAddition;
+  },
+  unselectAll: function() {
+    var listContainer = this.$['history'];
+    var toolbar = this.$.toolbar;
+    listContainer.unselectAllItems(toolbar.count);
+    toolbar.count = 0;
+  },
+  deleteSelected: function() {
+    this.$.history.deleteSelectedWithPrompt();
+  },
+  historyResult: function(info, results) {
+    this.set('queryState_.querying', false);
+    this.set('queryResult_.info', info);
+    this.set('queryResult_.results', results);
+    var listContainer = this.$['history'];
+    listContainer.historyResult(info, results);
+  },
+  searchDomain_: function(e) {
+    this.$.toolbar.setSearchTerm(e.detail.domain);
+  },
+  onCanExecute_: function(e) {
+    e = e;
+    switch (e.command.id) {
+     case 'find-command':
+      e.canExecute = true;
+      break;
+
+     case 'slash-command':
+      e.canExecute = !this.$.toolbar.searchBar.isSearchFocused();
+      break;
+
+     case 'delete-command':
+      e.canExecute = this.$.toolbar.count > 0;
+      break;
+    }
+  },
+  searchTermChanged_: function(searchTerm) {
+    this.set('queryParams_.q', searchTerm || null);
+    this.$['history'].queryHistory(false);
+  },
+  searchQueryParamChanged_: function(searchQuery) {
+    this.$.toolbar.setSearchTerm(searchQuery || '');
+  },
+  onCommand_: function(e) {
+    if (e.command.id == 'find-command' || e.command.id == 'slash-command') this.$.toolbar.showSearchField();
+    if (e.command.id == 'delete-command') this.deleteSelected();
+  },
+  setForeignSessions: function(sessionList, isTabSyncEnabled) {
+    if (!isTabSyncEnabled) return;
+    this.set('queryResult_.sessionList', sessionList);
+  },
+  updateSignInState: function(isUserSignedIn) {
+    var syncedDeviceManagerElem = this.$$('history-synced-device-manager');
+    if (syncedDeviceManagerElem) syncedDeviceManagerElem.updateSignInState(isUserSignedIn);
+  },
+  syncedTabsSelected_: function(selectedPage) {
+    return selectedPage == 'syncedTabs';
+  },
+  shouldShowSpinner_: function(querying, incremental, searchTerm) {
+    return querying && !incremental && searchTerm != '';
+  },
+  routeDataChanged_: function(page) {
+    this.selectedPage_ = page;
+  },
+  selectedPageChanged_: function(selectedPage) {
+    this.set('routeData_.page', selectedPage);
+  },
+  getSelectedPage_: function(selectedPage, items) {
+    return selectedPage;
+  },
+  closeDrawer_: function() {
+    var drawer = this.$$('#drawer');
+    if (drawer) drawer.close();
+  }
+});